trojan-go/api/api.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: api.proto

package api

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type SetUserRequest_Operation int32

const (
	SetUserRequest_Add    SetUserRequest_Operation = 0
	SetUserRequest_Delete SetUserRequest_Operation = 1
	SetUserRequest_Modify SetUserRequest_Operation = 2
)

var SetUserRequest_Operation_name = map[int32]string{
	0: "Add",
	1: "Delete",
	2: "Modify",
}

var SetUserRequest_Operation_value = map[string]int32{
	"Add":    0,
	"Delete": 1,
	"Modify": 2,
}

func (x SetUserRequest_Operation) String() string {
	return proto.EnumName(SetUserRequest_Operation_name, int32(x))
}

func (SetUserRequest_Operation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{7, 0}
}

type Traffic struct {
	UploadTraffic        uint64   `protobuf:"varint,1,opt,name=upload_traffic,json=uploadTraffic,proto3" json:"upload_traffic,omitempty"`
	DownloadTraffic      uint64   `protobuf:"varint,2,opt,name=download_traffic,json=downloadTraffic,proto3" json:"download_traffic,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Traffic) Reset()         { *m = Traffic{} }
func (m *Traffic) String() string { return proto.CompactTextString(m) }
func (*Traffic) ProtoMessage()    {}
func (*Traffic) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{0}
}

func (m *Traffic) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Traffic.Unmarshal(m, b)
}
func (m *Traffic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Traffic.Marshal(b, m, deterministic)
}
func (m *Traffic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Traffic.Merge(m, src)
}
func (m *Traffic) XXX_Size() int {
	return xxx_messageInfo_Traffic.Size(m)
}
func (m *Traffic) XXX_DiscardUnknown() {
	xxx_messageInfo_Traffic.DiscardUnknown(m)
}

var xxx_messageInfo_Traffic proto.InternalMessageInfo

func (m *Traffic) GetUploadTraffic() uint64 {
	if m != nil {
		return m.UploadTraffic
	}
	return 0
}

func (m *Traffic) GetDownloadTraffic() uint64 {
	if m != nil {
		return m.DownloadTraffic
	}
	return 0
}

type Speed struct {
	UploadSpeed          uint64   `protobuf:"varint,1,opt,name=upload_speed,json=uploadSpeed,proto3" json:"upload_speed,omitempty"`
	DownloadSpeed        uint64   `protobuf:"varint,2,opt,name=download_speed,json=downloadSpeed,proto3" json:"download_speed,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Speed) Reset()         { *m = Speed{} }
func (m *Speed) String() string { return proto.CompactTextString(m) }
func (*Speed) ProtoMessage()    {}
func (*Speed) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{1}
}

func (m *Speed) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Speed.Unmarshal(m, b)
}
func (m *Speed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Speed.Marshal(b, m, deterministic)
}
func (m *Speed) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Speed.Merge(m, src)
}
func (m *Speed) XXX_Size() int {
	return xxx_messageInfo_Speed.Size(m)
}
func (m *Speed) XXX_DiscardUnknown() {
	xxx_messageInfo_Speed.DiscardUnknown(m)
}

var xxx_messageInfo_Speed proto.InternalMessageInfo

func (m *Speed) GetUploadSpeed() uint64 {
	if m != nil {
		return m.UploadSpeed
	}
	return 0
}

func (m *Speed) GetDownloadSpeed() uint64 {
	if m != nil {
		return m.DownloadSpeed
	}
	return 0
}

type User struct {
	Password             string   `protobuf:"bytes,1,opt,name=password,proto3" json:"password,omitempty"`
	Hash                 string   `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *User) Reset()         { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage()    {}
func (*User) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{2}
}

func (m *User) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_User.Unmarshal(m, b)
}
func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_User.Marshal(b, m, deterministic)
}
func (m *User) XXX_Merge(src proto.Message) {
	xxx_messageInfo_User.Merge(m, src)
}
func (m *User) XXX_Size() int {
	return xxx_messageInfo_User.Size(m)
}
func (m *User) XXX_DiscardUnknown() {
	xxx_messageInfo_User.DiscardUnknown(m)
}

var xxx_messageInfo_User proto.InternalMessageInfo

func (m *User) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func (m *User) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

type GetTrafficRequest struct {
	User                 *User    `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetTrafficRequest) Reset()         { *m = GetTrafficRequest{} }
func (m *GetTrafficRequest) String() string { return proto.CompactTextString(m) }
func (*GetTrafficRequest) ProtoMessage()    {}
func (*GetTrafficRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{3}
}

func (m *GetTrafficRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetTrafficRequest.Unmarshal(m, b)
}
func (m *GetTrafficRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetTrafficRequest.Marshal(b, m, deterministic)
}
func (m *GetTrafficRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTrafficRequest.Merge(m, src)
}
func (m *GetTrafficRequest) XXX_Size() int {
	return xxx_messageInfo_GetTrafficRequest.Size(m)
}
func (m *GetTrafficRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTrafficRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetTrafficRequest proto.InternalMessageInfo

func (m *GetTrafficRequest) GetUser() *User {
	if m != nil {
		return m.User
	}
	return nil
}

type GetTrafficResponse struct {
	Success              bool     `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	TrafficTotal         *Traffic `protobuf:"bytes,2,opt,name=traffic_total,json=trafficTotal,proto3" json:"traffic_total,omitempty"`
	SpeedCurrent         *Speed   `protobuf:"bytes,3,opt,name=speed_current,json=speedCurrent,proto3" json:"speed_current,omitempty"`
	SpeedLimit           *Speed   `protobuf:"bytes,4,opt,name=speed_limit,json=speedLimit,proto3" json:"speed_limit,omitempty"`
	Info                 string   `protobuf:"bytes,5,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetTrafficResponse) Reset()         { *m = GetTrafficResponse{} }
func (m *GetTrafficResponse) String() string { return proto.CompactTextString(m) }
func (*GetTrafficResponse) ProtoMessage()    {}
func (*GetTrafficResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{4}
}

func (m *GetTrafficResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetTrafficResponse.Unmarshal(m, b)
}
func (m *GetTrafficResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetTrafficResponse.Marshal(b, m, deterministic)
}
func (m *GetTrafficResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTrafficResponse.Merge(m, src)
}
func (m *GetTrafficResponse) XXX_Size() int {
	return xxx_messageInfo_GetTrafficResponse.Size(m)
}
func (m *GetTrafficResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTrafficResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetTrafficResponse proto.InternalMessageInfo

func (m *GetTrafficResponse) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func (m *GetTrafficResponse) GetTrafficTotal() *Traffic {
	if m != nil {
		return m.TrafficTotal
	}
	return nil
}

func (m *GetTrafficResponse) GetSpeedCurrent() *Speed {
	if m != nil {
		return m.SpeedCurrent
	}
	return nil
}

func (m *GetTrafficResponse) GetSpeedLimit() *Speed {
	if m != nil {
		return m.SpeedLimit
	}
	return nil
}

func (m *GetTrafficResponse) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

type ListUserRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListUserRequest) Reset()         { *m = ListUserRequest{} }
func (m *ListUserRequest) String() string { return proto.CompactTextString(m) }
func (*ListUserRequest) ProtoMessage()    {}
func (*ListUserRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{5}
}

func (m *ListUserRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListUserRequest.Unmarshal(m, b)
}
func (m *ListUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListUserRequest.Marshal(b, m, deterministic)
}
func (m *ListUserRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListUserRequest.Merge(m, src)
}
func (m *ListUserRequest) XXX_Size() int {
	return xxx_messageInfo_ListUserRequest.Size(m)
}
func (m *ListUserRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListUserRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListUserRequest proto.InternalMessageInfo

type ListUserResponse struct {
	User                 *User    `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	Online               bool     `protobuf:"varint,2,opt,name=online,proto3" json:"online,omitempty"`
	TrafficTotal         *Traffic `protobuf:"bytes,3,opt,name=traffic_total,json=trafficTotal,proto3" json:"traffic_total,omitempty"`
	SpeedCurrent         *Speed   `protobuf:"bytes,4,opt,name=speed_current,json=speedCurrent,proto3" json:"speed_current,omitempty"`
	SpeedLimit           *Speed   `protobuf:"bytes,5,opt,name=speed_limit,json=speedLimit,proto3" json:"speed_limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListUserResponse) Reset()         { *m = ListUserResponse{} }
func (m *ListUserResponse) String() string { return proto.CompactTextString(m) }
func (*ListUserResponse) ProtoMessage()    {}
func (*ListUserResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{6}
}

func (m *ListUserResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListUserResponse.Unmarshal(m, b)
}
func (m *ListUserResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListUserResponse.Marshal(b, m, deterministic)
}
func (m *ListUserResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListUserResponse.Merge(m, src)
}
func (m *ListUserResponse) XXX_Size() int {
	return xxx_messageInfo_ListUserResponse.Size(m)
}
func (m *ListUserResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListUserResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListUserResponse proto.InternalMessageInfo

func (m *ListUserResponse) GetUser() *User {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *ListUserResponse) GetOnline() bool {
	if m != nil {
		return m.Online
	}
	return false
}

func (m *ListUserResponse) GetTrafficTotal() *Traffic {
	if m != nil {
		return m.TrafficTotal
	}
	return nil
}

func (m *ListUserResponse) GetSpeedCurrent() *Speed {
	if m != nil {
		return m.SpeedCurrent
	}
	return nil
}

func (m *ListUserResponse) GetSpeedLimit() *Speed {
	if m != nil {
		return m.SpeedLimit
	}
	return nil
}

type SetUserRequest struct {
	User                 *User                    `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	SpeedLimit           *Speed                   `protobuf:"bytes,2,opt,name=speed_limit,json=speedLimit,proto3" json:"speed_limit,omitempty"`
	Operation            SetUserRequest_Operation `protobuf:"varint,3,opt,name=operation,proto3,enum=api.SetUserRequest_Operation" json:"operation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *SetUserRequest) Reset()         { *m = SetUserRequest{} }
func (m *SetUserRequest) String() string { return proto.CompactTextString(m) }
func (*SetUserRequest) ProtoMessage()    {}
func (*SetUserRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{7}
}

func (m *SetUserRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetUserRequest.Unmarshal(m, b)
}
func (m *SetUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetUserRequest.Marshal(b, m, deterministic)
}
func (m *SetUserRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetUserRequest.Merge(m, src)
}
func (m *SetUserRequest) XXX_Size() int {
	return xxx_messageInfo_SetUserRequest.Size(m)
}
func (m *SetUserRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetUserRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetUserRequest proto.InternalMessageInfo

func (m *SetUserRequest) GetUser() *User {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *SetUserRequest) GetSpeedLimit() *Speed {
	if m != nil {
		return m.SpeedLimit
	}
	return nil
}

func (m *SetUserRequest) GetOperation() SetUserRequest_Operation {
	if m != nil {
		return m.Operation
	}
	return SetUserRequest_Add
}

type SetUserResponse struct {
	Success              bool     `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Info                 string   `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetUserResponse) Reset()         { *m = SetUserResponse{} }
func (m *SetUserResponse) String() string { return proto.CompactTextString(m) }
func (*SetUserResponse) ProtoMessage()    {}
func (*SetUserResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{8}
}

func (m *SetUserResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetUserResponse.Unmarshal(m, b)
}
func (m *SetUserResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetUserResponse.Marshal(b, m, deterministic)
}
func (m *SetUserResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetUserResponse.Merge(m, src)
}
func (m *SetUserResponse) XXX_Size() int {
	return xxx_messageInfo_SetUserResponse.Size(m)
}
func (m *SetUserResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SetUserResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SetUserResponse proto.InternalMessageInfo

func (m *SetUserResponse) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func (m *SetUserResponse) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func init() {
	proto.RegisterEnum("api.SetUserRequest_Operation", SetUserRequest_Operation_name, SetUserRequest_Operation_value)
	proto.RegisterType((*Traffic)(nil), "api.Traffic")
	proto.RegisterType((*Speed)(nil), "api.Speed")
	proto.RegisterType((*User)(nil), "api.User")
	proto.RegisterType((*GetTrafficRequest)(nil), "api.GetTrafficRequest")
	proto.RegisterType((*GetTrafficResponse)(nil), "api.GetTrafficResponse")
	proto.RegisterType((*ListUserRequest)(nil), "api.ListUserRequest")
	proto.RegisterType((*ListUserResponse)(nil), "api.ListUserResponse")
	proto.RegisterType((*SetUserRequest)(nil), "api.SetUserRequest")
	proto.RegisterType((*SetUserResponse)(nil), "api.SetUserResponse")
}

func init() {
	proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c)
}

var fileDescriptor_00212fb1f9d3bf1c = []byte{
	// 543 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6b, 0x13, 0x41,
	0x14, 0x86, 0xbb, 0xc9, 0xe6, 0x63, 0x4f, 0x3e, 0x7b, 0x5a, 0x6b, 0x08, 0x14, 0x74, 0x40, 0xa8,
	0x28, 0x51, 0x57, 0xf0, 0xa6, 0x42, 0x91, 0x08, 0xde, 0x54, 0xc4, 0x4d, 0xf4, 0xc6, 0x8b, 0xb0,
	0x66, 0x27, 0x74, 0x64, 0xdd, 0x59, 0x77, 0x26, 0x16, 0x7f, 0xa1, 0x3f, 0x40, 0xbc, 0xf1, 0xd7,
	0x98, 0x3d, 0xb3, 0x93, 0x4f, 0x49, 0x29, 0xde, 0xcd, 0xbc, 0xf3, 0x9e, 0x67, 0xcf, 0x79, 0x67,
	0x12, 0xf0, 0xc2, 0x54, 0x0c, 0xd2, 0x4c, 0x6a, 0x89, 0xe5, 0xc5, 0x92, 0x7d, 0x82, 0xda, 0x38,
	0x0b, 0x67, 0x33, 0x31, 0xc5, 0x07, 0xd0, 0x9e, 0xa7, 0xb1, 0x0c, 0xa3, 0x89, 0x36, 0x4a, 0xcf,
	0xb9, 0xe7, 0x9c, 0xb9, 0x41, 0xcb, 0xa8, 0xd6, 0xf6, 0x10, 0xba, 0x91, 0xbc, 0x4e, 0x36, 0x8c,
	0x25, 0x32, 0x76, 0xac, 0x5e, 0x58, 0xd9, 0x7b, 0xa8, 0x8c, 0x52, 0xce, 0x23, 0xbc, 0x0f, 0xcd,
	0x02, 0xad, 0xf2, 0x7d, 0x01, 0x6e, 0x18, 0xcd, 0x58, 0x16, 0x5f, 0x5f, 0x62, 0x8d, 0xc9, 0x40,
	0x5b, 0x56, 0x25, 0x1b, 0x7b, 0x01, 0xee, 0x07, 0xc5, 0x33, 0xec, 0x43, 0x3d, 0x0d, 0x95, 0xba,
	0x96, 0x99, 0xa1, 0x79, 0xc1, 0x72, 0x8f, 0x08, 0xee, 0x55, 0xa8, 0xae, 0x08, 0xe0, 0x05, 0xb4,
	0x66, 0x3e, 0x1c, 0xbe, 0xe1, 0xba, 0x68, 0x2c, 0xe0, 0xdf, 0xe6, 0x5c, 0x69, 0x3c, 0x05, 0x77,
	0xbe, 0x80, 0x11, 0xa0, 0xe1, 0x7b, 0x83, 0x3c, 0x9b, 0x9c, 0x1e, 0x90, 0xcc, 0x7e, 0x39, 0x80,
	0xeb, 0x45, 0x2a, 0x95, 0x89, 0xe2, 0xd8, 0x83, 0x9a, 0x9a, 0x4f, 0xa7, 0x5c, 0x29, 0x2a, 0xac,
	0x07, 0x76, 0x8b, 0xcf, 0xa0, 0x55, 0x24, 0x32, 0xd1, 0x52, 0x87, 0x31, 0x75, 0xd0, 0xf0, 0x9b,
	0x04, 0xb6, 0x98, 0x66, 0x61, 0x19, 0xe7, 0x0e, 0x7c, 0x02, 0x2d, 0x9a, 0x76, 0x32, 0x9d, 0x67,
	0x19, 0x4f, 0x74, 0xaf, 0x4c, 0x25, 0x40, 0x25, 0x34, 0x72, 0xd0, 0x24, 0xc3, 0xd0, 0x9c, 0xe3,
	0x23, 0x68, 0x98, 0x82, 0x58, 0x7c, 0x15, 0xba, 0xe7, 0xee, 0xd8, 0x81, 0x8e, 0x2f, 0xf3, 0xd3,
	0x3c, 0x09, 0x91, 0xcc, 0x64, 0xaf, 0x62, 0x92, 0xc8, 0xd7, 0xec, 0x10, 0x3a, 0x97, 0x42, 0x69,
	0x9a, 0xd3, 0xe4, 0xc0, 0xfe, 0x38, 0xd0, 0x5d, 0x69, 0xc5, 0x98, 0xfb, 0xc3, 0xc1, 0x13, 0xa8,
	0xca, 0x24, 0x16, 0x09, 0xa7, 0x21, 0xeb, 0x41, 0xb1, 0xdb, 0xcd, 0xa0, 0x7c, 0xfb, 0x0c, 0xdc,
	0xdb, 0x65, 0x50, 0xd9, 0x97, 0x01, 0xfb, 0xe9, 0x40, 0x7b, 0xc4, 0xd7, 0xe7, 0xbd, 0x69, 0xb4,
	0x2d, 0x7c, 0x69, 0x6f, 0xc4, 0xe7, 0xe0, 0xc9, 0x94, 0x67, 0xa1, 0x16, 0x32, 0xa1, 0x59, 0xdb,
	0xfe, 0xa9, 0xb1, 0x6e, 0x7c, 0x73, 0xf0, 0xce, 0x9a, 0x82, 0x95, 0x9f, 0x3d, 0x06, 0x6f, 0xa9,
	0x63, 0x0d, 0xca, 0xaf, 0xa2, 0xa8, 0x7b, 0x80, 0x00, 0xd5, 0xd7, 0x3c, 0xe6, 0x9a, 0x77, 0x9d,
	0x7c, 0xfd, 0x56, 0x46, 0x62, 0xf6, 0xa3, 0x5b, 0x62, 0x17, 0xd0, 0x59, 0x42, 0x6f, 0x7c, 0x8b,
	0xf6, 0xea, 0x4b, 0xab, 0xab, 0xf7, 0x3f, 0xc2, 0xd1, 0x38, 0x93, 0x5f, 0xc2, 0x64, 0x18, 0x8b,
	0x45, 0x8e, 0x23, 0x9e, 0x7d, 0x17, 0x53, 0x8e, 0x17, 0x00, 0xab, 0x67, 0x8e, 0x27, 0xd4, 0xfd,
	0xce, 0x8f, 0xa5, 0x7f, 0x77, 0x47, 0x37, 0x3d, 0xb0, 0x03, 0xff, 0xb7, 0x63, 0xc1, 0x39, 0x92,
	0x67, 0x16, 0xfc, 0x12, 0x3c, 0xfb, 0xac, 0x14, 0x1e, 0x53, 0xfd, 0xd6, 0xd3, 0xeb, 0xdf, 0xd9,
	0x52, 0x2d, 0xf3, 0xa9, 0x83, 0xc3, 0xff, 0x6c, 0xeb, 0xcc, 0x59, 0x40, 0xce, 0xa1, 0x5e, 0x64,
	0xa6, 0xf0, 0xe8, 0x1f, 0xf7, 0xd2, 0x3f, 0xde, 0x14, 0xd7, 0x8b, 0x3f, 0x57, 0xe9, 0x8f, 0xf2,
	0xf9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x39, 0xcf, 0x4f, 0x4f, 0x35, 0x05, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// TrojanClientServiceClient is the client API for TrojanClientService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TrojanClientServiceClient interface {
	GetTraffic(ctx context.Context, in *GetTrafficRequest, opts ...grpc.CallOption) (*GetTrafficResponse, error)
}

type trojanClientServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTrojanClientServiceClient(cc grpc.ClientConnInterface) TrojanClientServiceClient {
	return &trojanClientServiceClient{cc}
}

func (c *trojanClientServiceClient) GetTraffic(ctx context.Context, in *GetTrafficRequest, opts ...grpc.CallOption) (*GetTrafficResponse, error) {
	out := new(GetTrafficResponse)
	err := c.cc.Invoke(ctx, "/api.TrojanClientService/GetTraffic", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TrojanClientServiceServer is the server API for TrojanClientService service.
type TrojanClientServiceServer interface {
	GetTraffic(context.Context, *GetTrafficRequest) (*GetTrafficResponse, error)
}

// UnimplementedTrojanClientServiceServer can be embedded to have forward compatible implementations.
type UnimplementedTrojanClientServiceServer struct {
}

func (*UnimplementedTrojanClientServiceServer) GetTraffic(ctx context.Context, req *GetTrafficRequest) (*GetTrafficResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTraffic not implemented")
}

func RegisterTrojanClientServiceServer(s *grpc.Server, srv TrojanClientServiceServer) {
	s.RegisterService(&_TrojanClientService_serviceDesc, srv)
}

func _TrojanClientService_GetTraffic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTrafficRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrojanClientServiceServer).GetTraffic(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.TrojanClientService/GetTraffic",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrojanClientServiceServer).GetTraffic(ctx, req.(*GetTrafficRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _TrojanClientService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.TrojanClientService",
	HandlerType: (*TrojanClientServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetTraffic",
			Handler:    _TrojanClientService_GetTraffic_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// TrojanServerServiceClient is the client API for TrojanServerService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TrojanServerServiceClient interface {
	ListUsers(ctx context.Context, in *ListUserRequest, opts ...grpc.CallOption) (TrojanServerService_ListUsersClient, error)
	GetTraffic(ctx context.Context, opts ...grpc.CallOption) (TrojanServerService_GetTrafficClient, error)
	SetUsers(ctx context.Context, opts ...grpc.CallOption) (TrojanServerService_SetUsersClient, error)
}

type trojanServerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTrojanServerServiceClient(cc grpc.ClientConnInterface) TrojanServerServiceClient {
	return &trojanServerServiceClient{cc}
}

func (c *trojanServerServiceClient) ListUsers(ctx context.Context, in *ListUserRequest, opts ...grpc.CallOption) (TrojanServerService_ListUsersClient, error) {
	stream, err := c.cc.NewStream(ctx, &_TrojanServerService_serviceDesc.Streams[0], "/api.TrojanServerService/ListUsers", opts...)
	if err != nil {
		return nil, err
	}
	x := &trojanServerServiceListUsersClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type TrojanServerService_ListUsersClient interface {
	Recv() (*ListUserResponse, error)
	grpc.ClientStream
}

type trojanServerServiceListUsersClient struct {
	grpc.ClientStream
}

func (x *trojanServerServiceListUsersClient) Recv() (*ListUserResponse, error) {
	m := new(ListUserResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *trojanServerServiceClient) GetTraffic(ctx context.Context, opts ...grpc.CallOption) (TrojanServerService_GetTrafficClient, error) {
	stream, err := c.cc.NewStream(ctx, &_TrojanServerService_serviceDesc.Streams[1], "/api.TrojanServerService/GetTraffic", opts...)
	if err != nil {
		return nil, err
	}
	x := &trojanServerServiceGetTrafficClient{stream}
	return x, nil
}

type TrojanServerService_GetTrafficClient interface {
	Send(*GetTrafficRequest) error
	Recv() (*GetTrafficResponse, error)
	grpc.ClientStream
}

type trojanServerServiceGetTrafficClient struct {
	grpc.ClientStream
}

func (x *trojanServerServiceGetTrafficClient) Send(m *GetTrafficRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *trojanServerServiceGetTrafficClient) Recv() (*GetTrafficResponse, error) {
	m := new(GetTrafficResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *trojanServerServiceClient) SetUsers(ctx context.Context, opts ...grpc.CallOption) (TrojanServerService_SetUsersClient, error) {
	stream, err := c.cc.NewStream(ctx, &_TrojanServerService_serviceDesc.Streams[2], "/api.TrojanServerService/SetUsers", opts...)
	if err != nil {
		return nil, err
	}
	x := &trojanServerServiceSetUsersClient{stream}
	return x, nil
}

type TrojanServerService_SetUsersClient interface {
	Send(*SetUserRequest) error
	Recv() (*SetUserResponse, error)
	grpc.ClientStream
}

type trojanServerServiceSetUsersClient struct {
	grpc.ClientStream
}

func (x *trojanServerServiceSetUsersClient) Send(m *SetUserRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *trojanServerServiceSetUsersClient) Recv() (*SetUserResponse, error) {
	m := new(SetUserResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// TrojanServerServiceServer is the server API for TrojanServerService service.
type TrojanServerServiceServer interface {
	ListUsers(*ListUserRequest, TrojanServerService_ListUsersServer) error
	GetTraffic(TrojanServerService_GetTrafficServer) error
	SetUsers(TrojanServerService_SetUsersServer) error
}

// UnimplementedTrojanServerServiceServer can be embedded to have forward compatible implementations.
type UnimplementedTrojanServerServiceServer struct {
}

func (*UnimplementedTrojanServerServiceServer) ListUsers(req *ListUserRequest, srv TrojanServerService_ListUsersServer) error {
	return status.Errorf(codes.Unimplemented, "method ListUsers not implemented")
}
func (*UnimplementedTrojanServerServiceServer) GetTraffic(srv TrojanServerService_GetTrafficServer) error {
	return status.Errorf(codes.Unimplemented, "method GetTraffic not implemented")
}
func (*UnimplementedTrojanServerServiceServer) SetUsers(srv TrojanServerService_SetUsersServer) error {
	return status.Errorf(codes.Unimplemented, "method SetUsers not implemented")
}

func RegisterTrojanServerServiceServer(s *grpc.Server, srv TrojanServerServiceServer) {
	s.RegisterService(&_TrojanServerService_serviceDesc, srv)
}

func _TrojanServerService_ListUsers_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListUserRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TrojanServerServiceServer).ListUsers(m, &trojanServerServiceListUsersServer{stream})
}

type TrojanServerService_ListUsersServer interface {
	Send(*ListUserResponse) error
	grpc.ServerStream
}

type trojanServerServiceListUsersServer struct {
	grpc.ServerStream
}

func (x *trojanServerServiceListUsersServer) Send(m *ListUserResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _TrojanServerService_GetTraffic_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TrojanServerServiceServer).GetTraffic(&trojanServerServiceGetTrafficServer{stream})
}

type TrojanServerService_GetTrafficServer interface {
	Send(*GetTrafficResponse) error
	Recv() (*GetTrafficRequest, error)
	grpc.ServerStream
}

type trojanServerServiceGetTrafficServer struct {
	grpc.ServerStream
}

func (x *trojanServerServiceGetTrafficServer) Send(m *GetTrafficResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *trojanServerServiceGetTrafficServer) Recv() (*GetTrafficRequest, error) {
	m := new(GetTrafficRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _TrojanServerService_SetUsers_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TrojanServerServiceServer).SetUsers(&trojanServerServiceSetUsersServer{stream})
}

type TrojanServerService_SetUsersServer interface {
	Send(*SetUserResponse) error
	Recv() (*SetUserRequest, error)
	grpc.ServerStream
}

type trojanServerServiceSetUsersServer struct {
	grpc.ServerStream
}

func (x *trojanServerServiceSetUsersServer) Send(m *SetUserResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *trojanServerServiceSetUsersServer) Recv() (*SetUserRequest, error) {
	m := new(SetUserRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _TrojanServerService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.TrojanServerService",
	HandlerType: (*TrojanServerServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListUsers",
			Handler:       _TrojanServerService_ListUsers_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetTraffic",
			Handler:       _TrojanServerService_GetTraffic_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "SetUsers",
			Handler:       _TrojanServerService_SetUsers_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "api.proto",
}