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

package api

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	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 CountriesResponse struct {
	Table                []*BandCountriesMap `protobuf:"bytes,1,rep,name=table,proto3" json:"table,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_CountriesResponse proto.InternalMessageInfo

func (m *CountriesResponse) GetTable() []*BandCountriesMap {
	if m != nil {
		return m.Table
	}
	return nil
}

type CountriesResquest struct {
	Config               *BandCountriesMap `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_CountriesResquest proto.InternalMessageInfo

func (m *CountriesResquest) GetConfig() *BandCountriesMap {
	if m != nil {
		return m.Config
	}
	return nil
}

type CountryResponse struct {
	Config               *BandCountriesMap `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_CountryResponse proto.InternalMessageInfo

func (m *CountryResponse) GetConfig() *BandCountriesMap {
	if m != nil {
		return m.Config
	}
	return nil
}

type BandCountriesMap struct {
	Band                 string   `protobuf:"bytes,1,opt,name=band,proto3" json:"band,omitempty"`
	Area                 string   `protobuf:"bytes,2,opt,name=area,proto3" json:"area,omitempty"`
	Country              string   `protobuf:"bytes,3,opt,name=country,proto3" json:"country,omitempty"`
	City                 string   `protobuf:"bytes,4,opt,name=city,proto3" json:"city,omitempty"`
	Timezone             string   `protobuf:"bytes,5,opt,name=timezone,proto3" json:"timezone,omitempty"`
	TAdditional          string   `protobuf:"bytes,6,opt,name=tAdditional,proto3" json:"tAdditional,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BandCountriesMap proto.InternalMessageInfo

func (m *BandCountriesMap) GetBand() string {
	if m != nil {
		return m.Band
	}
	return ""
}

func (m *BandCountriesMap) GetArea() string {
	if m != nil {
		return m.Area
	}
	return ""
}

func (m *BandCountriesMap) GetCountry() string {
	if m != nil {
		return m.Country
	}
	return ""
}

func (m *BandCountriesMap) GetCity() string {
	if m != nil {
		return m.City
	}
	return ""
}

func (m *BandCountriesMap) GetTimezone() string {
	if m != nil {
		return m.Timezone
	}
	return ""
}

func (m *BandCountriesMap) GetTAdditional() string {
	if m != nil {
		return m.TAdditional
	}
	return ""
}

type CountriesTimezoneMap struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Timezone             []string `protobuf:"bytes,2,rep,name=timezone,proto3" json:"timezone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CountriesTimezoneMap proto.InternalMessageInfo

func (m *CountriesTimezoneMap) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CountriesTimezoneMap) GetTimezone() []string {
	if m != nil {
		return m.Timezone
	}
	return nil
}

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

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

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

var xxx_messageInfo_FactoryRestoreResquest proto.InternalMessageInfo

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

type GetTimezoneResponse struct {
	Timezone             string   `protobuf:"bytes,1,opt,name=timezone,proto3" json:"timezone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GetTimezoneResponse proto.InternalMessageInfo

func (m *GetTimezoneResponse) GetTimezone() string {
	if m != nil {
		return m.Timezone
	}
	return ""
}

type SetTimezoneResquest struct {
	Timezone             string   `protobuf:"bytes,1,opt,name=timezone,proto3" json:"timezone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SetTimezoneResquest proto.InternalMessageInfo

func (m *SetTimezoneResquest) GetTimezone() string {
	if m != nil {
		return m.Timezone
	}
	return ""
}

type Timezone struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                []string `protobuf:"bytes,2,rep,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Timezone proto.InternalMessageInfo

func (m *Timezone) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *Timezone) GetValue() []string {
	if m != nil {
		return m.Value
	}
	return nil
}

type QueryResponse struct {
	System               *SystemInfo `protobuf:"bytes,1,opt,name=system,proto3" json:"system,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *QueryResponse) Reset()         { *m = QueryResponse{} }
func (m *QueryResponse) String() string { return proto.CompactTextString(m) }
func (*QueryResponse) ProtoMessage()    {}
func (*QueryResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{9}
}

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

var xxx_messageInfo_QueryResponse proto.InternalMessageInfo

func (m *QueryResponse) GetSystem() *SystemInfo {
	if m != nil {
		return m.System
	}
	return nil
}

type UsageResponse struct {
	CpuUsg               float32      `protobuf:"fixed32,1,opt,name=cpuUsg,proto3" json:"cpuUsg,omitempty"`
	MemUsg               *MemoryUsage `protobuf:"bytes,2,opt,name=memUsg,proto3" json:"memUsg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *UsageResponse) Reset()         { *m = UsageResponse{} }
func (m *UsageResponse) String() string { return proto.CompactTextString(m) }
func (*UsageResponse) ProtoMessage()    {}
func (*UsageResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{10}
}

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

var xxx_messageInfo_UsageResponse proto.InternalMessageInfo

func (m *UsageResponse) GetCpuUsg() float32 {
	if m != nil {
		return m.CpuUsg
	}
	return 0
}

func (m *UsageResponse) GetMemUsg() *MemoryUsage {
	if m != nil {
		return m.MemUsg
	}
	return nil
}

type BackupListResponse struct {
	TotalCount           int64                `protobuf:"varint,1,opt,name=totalCount,proto3" json:"totalCount,omitempty"`
	Result               []*BackupInformation `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *BackupListResponse) Reset()         { *m = BackupListResponse{} }
func (m *BackupListResponse) String() string { return proto.CompactTextString(m) }
func (*BackupListResponse) ProtoMessage()    {}
func (*BackupListResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{11}
}

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

var xxx_messageInfo_BackupListResponse proto.InternalMessageInfo

func (m *BackupListResponse) GetTotalCount() int64 {
	if m != nil {
		return m.TotalCount
	}
	return 0
}

func (m *BackupListResponse) GetResult() []*BackupInformation {
	if m != nil {
		return m.Result
	}
	return nil
}

type BackupRequest struct {
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BackupRequest) Reset()         { *m = BackupRequest{} }
func (m *BackupRequest) String() string { return proto.CompactTextString(m) }
func (*BackupRequest) ProtoMessage()    {}
func (*BackupRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{12}
}

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

var xxx_messageInfo_BackupRequest proto.InternalMessageInfo

func (m *BackupRequest) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type RestoreRequest struct {
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RestoreRequest) Reset()         { *m = RestoreRequest{} }
func (m *RestoreRequest) String() string { return proto.CompactTextString(m) }
func (*RestoreRequest) ProtoMessage()    {}
func (*RestoreRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{13}
}

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

var xxx_messageInfo_RestoreRequest proto.InternalMessageInfo

func (m *RestoreRequest) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type UploadFWRequest struct {
	Firmware             *FileUpload `protobuf:"bytes,1,opt,name=firmware,proto3" json:"firmware,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *UploadFWRequest) Reset()         { *m = UploadFWRequest{} }
func (m *UploadFWRequest) String() string { return proto.CompactTextString(m) }
func (*UploadFWRequest) ProtoMessage()    {}
func (*UploadFWRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{14}
}

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

var xxx_messageInfo_UploadFWRequest proto.InternalMessageInfo

func (m *UploadFWRequest) GetFirmware() *FileUpload {
	if m != nil {
		return m.Firmware
	}
	return nil
}

type UploadFWResponse struct {
	// Types that are valid to be assigned to Type:
	//
	//	*UploadFWResponse_Empty
	//	*UploadFWResponse_Path
	Type                 isUploadFWResponse_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *UploadFWResponse) Reset()         { *m = UploadFWResponse{} }
func (m *UploadFWResponse) String() string { return proto.CompactTextString(m) }
func (*UploadFWResponse) ProtoMessage()    {}
func (*UploadFWResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{15}
}

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

var xxx_messageInfo_UploadFWResponse proto.InternalMessageInfo

type isUploadFWResponse_Type interface {
	isUploadFWResponse_Type()
}

type UploadFWResponse_Empty struct {
	Empty *emptypb.Empty `protobuf:"bytes,1,opt,name=empty,proto3,oneof"`
}

type UploadFWResponse_Path struct {
	Path string `protobuf:"bytes,2,opt,name=path,proto3,oneof"`
}

func (*UploadFWResponse_Empty) isUploadFWResponse_Type() {}

func (*UploadFWResponse_Path) isUploadFWResponse_Type() {}

func (m *UploadFWResponse) GetType() isUploadFWResponse_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *UploadFWResponse) GetEmpty() *emptypb.Empty {
	if x, ok := m.GetType().(*UploadFWResponse_Empty); ok {
		return x.Empty
	}
	return nil
}

func (m *UploadFWResponse) GetPath() string {
	if x, ok := m.GetType().(*UploadFWResponse_Path); ok {
		return x.Path
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*UploadFWResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*UploadFWResponse_Empty)(nil),
		(*UploadFWResponse_Path)(nil),
	}
}

type UpgradeRequest struct {
	Path                 string   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpgradeRequest) Reset()         { *m = UpgradeRequest{} }
func (m *UpgradeRequest) String() string { return proto.CompactTextString(m) }
func (*UpgradeRequest) ProtoMessage()    {}
func (*UpgradeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{16}
}

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

var xxx_messageInfo_UpgradeRequest proto.InternalMessageInfo

func (m *UpgradeRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type GetSystemTimeResponse struct {
	Timestamp            *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *GetSystemTimeResponse) Reset()         { *m = GetSystemTimeResponse{} }
func (m *GetSystemTimeResponse) String() string { return proto.CompactTextString(m) }
func (*GetSystemTimeResponse) ProtoMessage()    {}
func (*GetSystemTimeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{17}
}

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

var xxx_messageInfo_GetSystemTimeResponse proto.InternalMessageInfo

func (m *GetSystemTimeResponse) GetTimestamp() *timestamppb.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

type StreamSystemTimeResponse struct {
	Timestamp            *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *StreamSystemTimeResponse) Reset()         { *m = StreamSystemTimeResponse{} }
func (m *StreamSystemTimeResponse) String() string { return proto.CompactTextString(m) }
func (*StreamSystemTimeResponse) ProtoMessage()    {}
func (*StreamSystemTimeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{18}
}

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

var xxx_messageInfo_StreamSystemTimeResponse proto.InternalMessageInfo

func (m *StreamSystemTimeResponse) GetTimestamp() *timestamppb.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

type StreamUpgradeLogResponse struct {
	Logs                 string   `protobuf:"bytes,1,opt,name=logs,proto3" json:"logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamUpgradeLogResponse) Reset()         { *m = StreamUpgradeLogResponse{} }
func (m *StreamUpgradeLogResponse) String() string { return proto.CompactTextString(m) }
func (*StreamUpgradeLogResponse) ProtoMessage()    {}
func (*StreamUpgradeLogResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{19}
}

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

var xxx_messageInfo_StreamUpgradeLogResponse proto.InternalMessageInfo

func (m *StreamUpgradeLogResponse) GetLogs() string {
	if m != nil {
		return m.Logs
	}
	return ""
}

type SetSystemTimeRequest struct {
	Timestamp            *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *SetSystemTimeRequest) Reset()         { *m = SetSystemTimeRequest{} }
func (m *SetSystemTimeRequest) String() string { return proto.CompactTextString(m) }
func (*SetSystemTimeRequest) ProtoMessage()    {}
func (*SetSystemTimeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{20}
}

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

var xxx_messageInfo_SetSystemTimeRequest proto.InternalMessageInfo

func (m *SetSystemTimeRequest) GetTimestamp() *timestamppb.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

type SystemInfo struct {
	ProductName         string                 `protobuf:"bytes,1,opt,name=productName,json=PN,proto3" json:"productName,omitempty"`
	ManufacturingDate   string                 `protobuf:"bytes,2,opt,name=manufacturingDate,json=MFGDate,proto3" json:"manufacturingDate,omitempty"`
	ProductSerialNumber string                 `protobuf:"bytes,3,opt,name=productSerialNumber,json=PSN,proto3" json:"productSerialNumber,omitempty"`
	Timestamp           *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	CpuUsg              float32                `protobuf:"fixed32,5,opt,name=cpuUsg,proto3" json:"cpuUsg,omitempty"`
	MemUsg              *MemoryUsage           `protobuf:"bytes,6,opt,name=memUsg,proto3" json:"memUsg,omitempty"`
	GatewayID           string                 `protobuf:"bytes,7,opt,name=gatewayID,proto3" json:"gatewayID,omitempty"`
	Lora                *GatewayLoraInfo       `protobuf:"bytes,8,opt,name=lora,proto3" json:"lora,omitempty"`
	// WiFiStation wifiSTA        = 9 [json_name = "wifiSTA"];
	WifiAP               *WiFiAP     `protobuf:"bytes,10,opt,name=wifiAP,proto3" json:"wifiAP,omitempty"`
	Eth                  *Ethernet   `protobuf:"bytes,11,opt,name=eth,proto3" json:"eth,omitempty"`
	Cat1                 *MoudleCat1 `protobuf:"bytes,12,opt,name=cat1,proto3" json:"cat1,omitempty"`
	Version              string      `protobuf:"bytes,13,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *SystemInfo) Reset()         { *m = SystemInfo{} }
func (m *SystemInfo) String() string { return proto.CompactTextString(m) }
func (*SystemInfo) ProtoMessage()    {}
func (*SystemInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{21}
}

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

var xxx_messageInfo_SystemInfo proto.InternalMessageInfo

func (m *SystemInfo) GetProductName() string {
	if m != nil {
		return m.ProductName
	}
	return ""
}

func (m *SystemInfo) GetManufacturingDate() string {
	if m != nil {
		return m.ManufacturingDate
	}
	return ""
}

func (m *SystemInfo) GetProductSerialNumber() string {
	if m != nil {
		return m.ProductSerialNumber
	}
	return ""
}

func (m *SystemInfo) GetTimestamp() *timestamppb.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *SystemInfo) GetCpuUsg() float32 {
	if m != nil {
		return m.CpuUsg
	}
	return 0
}

func (m *SystemInfo) GetMemUsg() *MemoryUsage {
	if m != nil {
		return m.MemUsg
	}
	return nil
}

func (m *SystemInfo) GetGatewayID() string {
	if m != nil {
		return m.GatewayID
	}
	return ""
}

func (m *SystemInfo) GetLora() *GatewayLoraInfo {
	if m != nil {
		return m.Lora
	}
	return nil
}

func (m *SystemInfo) GetWifiAP() *WiFiAP {
	if m != nil {
		return m.WifiAP
	}
	return nil
}

func (m *SystemInfo) GetEth() *Ethernet {
	if m != nil {
		return m.Eth
	}
	return nil
}

func (m *SystemInfo) GetCat1() *MoudleCat1 {
	if m != nil {
		return m.Cat1
	}
	return nil
}

func (m *SystemInfo) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type MemoryUsage struct {
	Used                 int64    `protobuf:"varint,1,opt,name=used,proto3" json:"used,omitempty"`
	Total                int64    `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MemoryUsage) Reset()         { *m = MemoryUsage{} }
func (m *MemoryUsage) String() string { return proto.CompactTextString(m) }
func (*MemoryUsage) ProtoMessage()    {}
func (*MemoryUsage) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{22}
}

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

var xxx_messageInfo_MemoryUsage proto.InternalMessageInfo

func (m *MemoryUsage) GetUsed() int64 {
	if m != nil {
		return m.Used
	}
	return 0
}

func (m *MemoryUsage) GetTotal() int64 {
	if m != nil {
		return m.Total
	}
	return 0
}

type GatewayLoraInfo struct {
	NumberOfChannels     int32    `protobuf:"varint,1,opt,name=numberOfChannels,json=noc,proto3" json:"numberOfChannels,omitempty"`
	FullDuplex           bool     `protobuf:"varint,2,opt,name=fullDuplex,json=fdx,proto3" json:"fullDuplex,omitempty"`
	Fb                   string   `protobuf:"bytes,3,opt,name=fb,json=FB,proto3" json:"fb,omitempty"`
	Status               string   `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GatewayLoraInfo) Reset()         { *m = GatewayLoraInfo{} }
func (m *GatewayLoraInfo) String() string { return proto.CompactTextString(m) }
func (*GatewayLoraInfo) ProtoMessage()    {}
func (*GatewayLoraInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{23}
}

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

var xxx_messageInfo_GatewayLoraInfo proto.InternalMessageInfo

func (m *GatewayLoraInfo) GetNumberOfChannels() int32 {
	if m != nil {
		return m.NumberOfChannels
	}
	return 0
}

func (m *GatewayLoraInfo) GetFullDuplex() bool {
	if m != nil {
		return m.FullDuplex
	}
	return false
}

func (m *GatewayLoraInfo) GetFb() string {
	if m != nil {
		return m.Fb
	}
	return ""
}

func (m *GatewayLoraInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type BackupInformation struct {
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Date                 string   `protobuf:"bytes,2,opt,name=date,proto3" json:"date,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BackupInformation) Reset()         { *m = BackupInformation{} }
func (m *BackupInformation) String() string { return proto.CompactTextString(m) }
func (*BackupInformation) ProtoMessage()    {}
func (*BackupInformation) Descriptor() ([]byte, []int) {
	return fileDescriptor_1114900150c3b3b2, []int{24}
}

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

var xxx_messageInfo_BackupInformation proto.InternalMessageInfo

func (m *BackupInformation) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *BackupInformation) GetDate() string {
	if m != nil {
		return m.Date
	}
	return ""
}

func init() {
	proto.RegisterType((*CountriesResponse)(nil), "api.CountriesResponse")
	proto.RegisterType((*CountriesResquest)(nil), "api.CountriesResquest")
	proto.RegisterType((*CountryResponse)(nil), "api.CountryResponse")
	proto.RegisterType((*BandCountriesMap)(nil), "api.BandCountriesMap")
	proto.RegisterType((*CountriesTimezoneMap)(nil), "api.CountriesTimezoneMap")
	proto.RegisterType((*FactoryRestoreResquest)(nil), "api.FactoryRestoreResquest")
	proto.RegisterType((*GetTimezoneResponse)(nil), "api.GetTimezoneResponse")
	proto.RegisterType((*SetTimezoneResquest)(nil), "api.SetTimezoneResquest")
	proto.RegisterType((*Timezone)(nil), "api.Timezone")
	proto.RegisterType((*QueryResponse)(nil), "api.QueryResponse")
	proto.RegisterType((*UsageResponse)(nil), "api.UsageResponse")
	proto.RegisterType((*BackupListResponse)(nil), "api.BackupListResponse")
	proto.RegisterType((*BackupRequest)(nil), "api.BackupRequest")
	proto.RegisterType((*RestoreRequest)(nil), "api.RestoreRequest")
	proto.RegisterType((*UploadFWRequest)(nil), "api.UploadFWRequest")
	proto.RegisterType((*UploadFWResponse)(nil), "api.UploadFWResponse")
	proto.RegisterType((*UpgradeRequest)(nil), "api.UpgradeRequest")
	proto.RegisterType((*GetSystemTimeResponse)(nil), "api.GetSystemTimeResponse")
	proto.RegisterType((*StreamSystemTimeResponse)(nil), "api.StreamSystemTimeResponse")
	proto.RegisterType((*StreamUpgradeLogResponse)(nil), "api.StreamUpgradeLogResponse")
	proto.RegisterType((*SetSystemTimeRequest)(nil), "api.SetSystemTimeRequest")
	proto.RegisterType((*SystemInfo)(nil), "api.SystemInfo")
	proto.RegisterType((*MemoryUsage)(nil), "api.MemoryUsage")
	proto.RegisterType((*GatewayLoraInfo)(nil), "api.GatewayLoraInfo")
	proto.RegisterType((*BackupInformation)(nil), "api.BackupInformation")
}

func init() {
	proto.RegisterFile("as/external/api/system.proto", fileDescriptor_1114900150c3b3b2)
}

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

// SystemServiceClient is the client API for SystemService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SystemServiceClient interface {
	Query(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*QueryResponse, error)
	Usage(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*UsageResponse, error)
	Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	BackupList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*BackupListResponse, error)
	Restore(ctx context.Context, in *RestoreRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	Upload(ctx context.Context, in *UploadFWRequest, opts ...grpc.CallOption) (*UploadFWResponse, error)
	Upgrade(ctx context.Context, in *UpgradeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StreamUpgradeLog(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (SystemService_StreamUpgradeLogClient, error)
	GetSystemTime(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetSystemTimeResponse, error)
	SetSystemTime(ctx context.Context, in *SetSystemTimeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetTimezone(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetTimezoneResponse, error)
	SetTimezone(ctx context.Context, in *SetTimezoneResquest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	FactoryRestore(ctx context.Context, in *FactoryRestoreResquest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VaildToken(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetCountries(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CountriesResponse, error)
	SetCountry(ctx context.Context, in *CountriesResquest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetCountry(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CountryResponse, error)
}

type systemServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSystemServiceClient(cc grpc.ClientConnInterface) SystemServiceClient {
	return &systemServiceClient{cc}
}

func (c *systemServiceClient) Query(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*QueryResponse, error) {
	out := new(QueryResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/Query", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) Usage(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*UsageResponse, error) {
	out := new(UsageResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/Usage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/Backup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) BackupList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*BackupListResponse, error) {
	out := new(BackupListResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/BackupList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) Restore(ctx context.Context, in *RestoreRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/Restore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) Upload(ctx context.Context, in *UploadFWRequest, opts ...grpc.CallOption) (*UploadFWResponse, error) {
	out := new(UploadFWResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/Upload", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) Upgrade(ctx context.Context, in *UpgradeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/Upgrade", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) StreamUpgradeLog(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (SystemService_StreamUpgradeLogClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SystemService_serviceDesc.Streams[0], "/api.systemService/StreamUpgradeLog", opts...)
	if err != nil {
		return nil, err
	}
	x := &systemServiceStreamUpgradeLogClient{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 SystemService_StreamUpgradeLogClient interface {
	Recv() (*StreamUpgradeLogResponse, error)
	grpc.ClientStream
}

type systemServiceStreamUpgradeLogClient struct {
	grpc.ClientStream
}

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

func (c *systemServiceClient) GetSystemTime(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetSystemTimeResponse, error) {
	out := new(GetSystemTimeResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/GetSystemTime", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) SetSystemTime(ctx context.Context, in *SetSystemTimeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/SetSystemTime", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) GetTimezone(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetTimezoneResponse, error) {
	out := new(GetTimezoneResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/GetTimezone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) SetTimezone(ctx context.Context, in *SetTimezoneResquest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/SetTimezone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) FactoryRestore(ctx context.Context, in *FactoryRestoreResquest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/FactoryRestore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) VaildToken(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/VaildToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) GetCountries(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CountriesResponse, error) {
	out := new(CountriesResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/GetCountries", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) SetCountry(ctx context.Context, in *CountriesResquest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.systemService/SetCountry", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *systemServiceClient) GetCountry(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CountryResponse, error) {
	out := new(CountryResponse)
	err := c.cc.Invoke(ctx, "/api.systemService/GetCountry", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SystemServiceServer is the server API for SystemService service.
type SystemServiceServer interface {
	Query(context.Context, *emptypb.Empty) (*QueryResponse, error)
	Usage(context.Context, *emptypb.Empty) (*UsageResponse, error)
	Backup(context.Context, *BackupRequest) (*emptypb.Empty, error)
	BackupList(context.Context, *emptypb.Empty) (*BackupListResponse, error)
	Restore(context.Context, *RestoreRequest) (*emptypb.Empty, error)
	Upload(context.Context, *UploadFWRequest) (*UploadFWResponse, error)
	Upgrade(context.Context, *UpgradeRequest) (*emptypb.Empty, error)
	StreamUpgradeLog(*emptypb.Empty, SystemService_StreamUpgradeLogServer) error
	GetSystemTime(context.Context, *emptypb.Empty) (*GetSystemTimeResponse, error)
	SetSystemTime(context.Context, *SetSystemTimeRequest) (*emptypb.Empty, error)
	GetTimezone(context.Context, *emptypb.Empty) (*GetTimezoneResponse, error)
	SetTimezone(context.Context, *SetTimezoneResquest) (*emptypb.Empty, error)
	FactoryRestore(context.Context, *FactoryRestoreResquest) (*emptypb.Empty, error)
	VaildToken(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
	GetCountries(context.Context, *emptypb.Empty) (*CountriesResponse, error)
	SetCountry(context.Context, *CountriesResquest) (*emptypb.Empty, error)
	GetCountry(context.Context, *emptypb.Empty) (*CountryResponse, error)
}

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

func (*UnimplementedSystemServiceServer) Query(ctx context.Context, req *emptypb.Empty) (*QueryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Query not implemented")
}
func (*UnimplementedSystemServiceServer) Usage(ctx context.Context, req *emptypb.Empty) (*UsageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Usage not implemented")
}
func (*UnimplementedSystemServiceServer) Backup(ctx context.Context, req *BackupRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Backup not implemented")
}
func (*UnimplementedSystemServiceServer) BackupList(ctx context.Context, req *emptypb.Empty) (*BackupListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BackupList not implemented")
}
func (*UnimplementedSystemServiceServer) Restore(ctx context.Context, req *RestoreRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Restore not implemented")
}
func (*UnimplementedSystemServiceServer) Upload(ctx context.Context, req *UploadFWRequest) (*UploadFWResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Upload not implemented")
}
func (*UnimplementedSystemServiceServer) Upgrade(ctx context.Context, req *UpgradeRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Upgrade not implemented")
}
func (*UnimplementedSystemServiceServer) StreamUpgradeLog(req *emptypb.Empty, srv SystemService_StreamUpgradeLogServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamUpgradeLog not implemented")
}
func (*UnimplementedSystemServiceServer) GetSystemTime(ctx context.Context, req *emptypb.Empty) (*GetSystemTimeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSystemTime not implemented")
}
func (*UnimplementedSystemServiceServer) SetSystemTime(ctx context.Context, req *SetSystemTimeRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetSystemTime not implemented")
}
func (*UnimplementedSystemServiceServer) GetTimezone(ctx context.Context, req *emptypb.Empty) (*GetTimezoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTimezone not implemented")
}
func (*UnimplementedSystemServiceServer) SetTimezone(ctx context.Context, req *SetTimezoneResquest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetTimezone not implemented")
}
func (*UnimplementedSystemServiceServer) FactoryRestore(ctx context.Context, req *FactoryRestoreResquest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FactoryRestore not implemented")
}
func (*UnimplementedSystemServiceServer) VaildToken(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VaildToken not implemented")
}
func (*UnimplementedSystemServiceServer) GetCountries(ctx context.Context, req *emptypb.Empty) (*CountriesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCountries not implemented")
}
func (*UnimplementedSystemServiceServer) SetCountry(ctx context.Context, req *CountriesResquest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetCountry not implemented")
}
func (*UnimplementedSystemServiceServer) GetCountry(ctx context.Context, req *emptypb.Empty) (*CountryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCountry not implemented")
}

func RegisterSystemServiceServer(s *grpc.Server, srv SystemServiceServer) {
	s.RegisterService(&_SystemService_serviceDesc, srv)
}

func _SystemService_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).Query(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/Query",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).Query(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_Usage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).Usage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/Usage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).Usage(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_Backup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).Backup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/Backup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).Backup(ctx, req.(*BackupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_BackupList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).BackupList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/BackupList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).BackupList(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestoreRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).Restore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/Restore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).Restore(ctx, req.(*RestoreRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_Upload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UploadFWRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).Upload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/Upload",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).Upload(ctx, req.(*UploadFWRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_Upgrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpgradeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).Upgrade(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/Upgrade",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).Upgrade(ctx, req.(*UpgradeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_StreamUpgradeLog_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SystemServiceServer).StreamUpgradeLog(m, &systemServiceStreamUpgradeLogServer{stream})
}

type SystemService_StreamUpgradeLogServer interface {
	Send(*StreamUpgradeLogResponse) error
	grpc.ServerStream
}

type systemServiceStreamUpgradeLogServer struct {
	grpc.ServerStream
}

func (x *systemServiceStreamUpgradeLogServer) Send(m *StreamUpgradeLogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _SystemService_GetSystemTime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).GetSystemTime(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/GetSystemTime",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).GetSystemTime(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_SetSystemTime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSystemTimeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).SetSystemTime(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/SetSystemTime",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).SetSystemTime(ctx, req.(*SetSystemTimeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_GetTimezone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).GetTimezone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/GetTimezone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).GetTimezone(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_SetTimezone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetTimezoneResquest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).SetTimezone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/SetTimezone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).SetTimezone(ctx, req.(*SetTimezoneResquest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_FactoryRestore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FactoryRestoreResquest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).FactoryRestore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/FactoryRestore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).FactoryRestore(ctx, req.(*FactoryRestoreResquest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_VaildToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).VaildToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/VaildToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).VaildToken(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_GetCountries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).GetCountries(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/GetCountries",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).GetCountries(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_SetCountry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CountriesResquest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).SetCountry(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/SetCountry",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).SetCountry(ctx, req.(*CountriesResquest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SystemService_GetCountry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SystemServiceServer).GetCountry(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.systemService/GetCountry",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SystemServiceServer).GetCountry(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _SystemService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.systemService",
	HandlerType: (*SystemServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Query",
			Handler:    _SystemService_Query_Handler,
		},
		{
			MethodName: "Usage",
			Handler:    _SystemService_Usage_Handler,
		},
		{
			MethodName: "Backup",
			Handler:    _SystemService_Backup_Handler,
		},
		{
			MethodName: "BackupList",
			Handler:    _SystemService_BackupList_Handler,
		},
		{
			MethodName: "Restore",
			Handler:    _SystemService_Restore_Handler,
		},
		{
			MethodName: "Upload",
			Handler:    _SystemService_Upload_Handler,
		},
		{
			MethodName: "Upgrade",
			Handler:    _SystemService_Upgrade_Handler,
		},
		{
			MethodName: "GetSystemTime",
			Handler:    _SystemService_GetSystemTime_Handler,
		},
		{
			MethodName: "SetSystemTime",
			Handler:    _SystemService_SetSystemTime_Handler,
		},
		{
			MethodName: "GetTimezone",
			Handler:    _SystemService_GetTimezone_Handler,
		},
		{
			MethodName: "SetTimezone",
			Handler:    _SystemService_SetTimezone_Handler,
		},
		{
			MethodName: "FactoryRestore",
			Handler:    _SystemService_FactoryRestore_Handler,
		},
		{
			MethodName: "VaildToken",
			Handler:    _SystemService_VaildToken_Handler,
		},
		{
			MethodName: "GetCountries",
			Handler:    _SystemService_GetCountries_Handler,
		},
		{
			MethodName: "SetCountry",
			Handler:    _SystemService_SetCountry_Handler,
		},
		{
			MethodName: "GetCountry",
			Handler:    _SystemService_GetCountry_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamUpgradeLog",
			Handler:       _SystemService_StreamUpgradeLog_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "as/external/api/system.proto",
}