// Code generated by protoc-gen-go. DO NOT EDIT.
// source: as/external/api/tool.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"
	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 StreamInstallResponse 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 *StreamInstallResponse) Reset()         { *m = StreamInstallResponse{} }
func (m *StreamInstallResponse) String() string { return proto.CompactTextString(m) }
func (*StreamInstallResponse) ProtoMessage()    {}
func (*StreamInstallResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bb30a0cc57500dee, []int{0}
}

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

var xxx_messageInfo_StreamInstallResponse proto.InternalMessageInfo

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

type UploadResponse struct {
	// Types that are valid to be assigned to Type:
	//
	//	*UploadResponse_Empty
	//	*UploadResponse_Path
	Type                 isUploadResponse_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_UploadResponse proto.InternalMessageInfo

type isUploadResponse_Type interface {
	isUploadResponse_Type()
}

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

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

func (*UploadResponse_Empty) isUploadResponse_Type() {}

func (*UploadResponse_Path) isUploadResponse_Type() {}

func (m *UploadResponse) GetType() isUploadResponse_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

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

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*UploadResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*UploadResponse_Empty)(nil),
		(*UploadResponse_Path)(nil),
	}
}

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

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

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

var xxx_messageInfo_StreamImportDeviceListResponse proto.InternalMessageInfo

func (m *StreamImportDeviceListResponse) GetCsv() *FileUpload {
	if m != nil {
		return m.Csv
	}
	return nil
}

type GetNoderedResponse struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GetNoderedResponse proto.InternalMessageInfo

func (m *GetNoderedResponse) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

type SetNoderedRequest struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SetNoderedRequest proto.InternalMessageInfo

func (m *SetNoderedRequest) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

type PingRequest struct {
	Nic                  string   `protobuf:"bytes,1,opt,name=nic,proto3" json:"nic,omitempty"`
	Url                  string   `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PingRequest proto.InternalMessageInfo

func (m *PingRequest) GetNic() string {
	if m != nil {
		return m.Nic
	}
	return ""
}

func (m *PingRequest) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

type StreamPingResponse 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 *StreamPingResponse) Reset()         { *m = StreamPingResponse{} }
func (m *StreamPingResponse) String() string { return proto.CompactTextString(m) }
func (*StreamPingResponse) ProtoMessage()    {}
func (*StreamPingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bb30a0cc57500dee, []int{6}
}

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

var xxx_messageInfo_StreamPingResponse proto.InternalMessageInfo

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

type GetNTPResponse struct {
	Ntp                  *NTPConfig `protobuf:"bytes,1,opt,name=ntp,proto3" json:"ntp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_GetNTPResponse proto.InternalMessageInfo

func (m *GetNTPResponse) GetNtp() *NTPConfig {
	if m != nil {
		return m.Ntp
	}
	return nil
}

type SetNTPRequest struct {
	// Types that are valid to be assigned to Type:
	//
	//	*SetNTPRequest_Test
	//	*SetNTPRequest_Sync
	Type                 isSetNTPRequest_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_SetNTPRequest proto.InternalMessageInfo

type isSetNTPRequest_Type interface {
	isSetNTPRequest_Type()
}

type SetNTPRequest_Test struct {
	Test *NTPConfig `protobuf:"bytes,1,opt,name=test,proto3,oneof"`
}

type SetNTPRequest_Sync struct {
	Sync *NTPConfig `protobuf:"bytes,2,opt,name=sync,proto3,oneof"`
}

func (*SetNTPRequest_Test) isSetNTPRequest_Type() {}

func (*SetNTPRequest_Sync) isSetNTPRequest_Type() {}

func (m *SetNTPRequest) GetType() isSetNTPRequest_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *SetNTPRequest) GetTest() *NTPConfig {
	if x, ok := m.GetType().(*SetNTPRequest_Test); ok {
		return x.Test
	}
	return nil
}

func (m *SetNTPRequest) GetSync() *NTPConfig {
	if x, ok := m.GetType().(*SetNTPRequest_Sync); ok {
		return x.Sync
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SetNTPRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SetNTPRequest_Test)(nil),
		(*SetNTPRequest_Sync)(nil),
	}
}

type StreamNTPResponse 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 *StreamNTPResponse) Reset()         { *m = StreamNTPResponse{} }
func (m *StreamNTPResponse) String() string { return proto.CompactTextString(m) }
func (*StreamNTPResponse) ProtoMessage()    {}
func (*StreamNTPResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_bb30a0cc57500dee, []int{9}
}

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

var xxx_messageInfo_StreamNTPResponse proto.InternalMessageInfo

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

type NTPConfig struct {
	NtpServer1           string   `protobuf:"bytes,1,opt,name=ntpServer1,proto3" json:"ntpServer1,omitempty"`
	NtpServer2           string   `protobuf:"bytes,2,opt,name=ntpServer2,proto3" json:"ntpServer2,omitempty"`
	NtpServer3           string   `protobuf:"bytes,3,opt,name=ntpServer3,proto3" json:"ntpServer3,omitempty"`
	NtpServer4           string   `protobuf:"bytes,4,opt,name=ntpServer4,proto3" json:"ntpServer4,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_NTPConfig proto.InternalMessageInfo

func (m *NTPConfig) GetNtpServer1() string {
	if m != nil {
		return m.NtpServer1
	}
	return ""
}

func (m *NTPConfig) GetNtpServer2() string {
	if m != nil {
		return m.NtpServer2
	}
	return ""
}

func (m *NTPConfig) GetNtpServer3() string {
	if m != nil {
		return m.NtpServer3
	}
	return ""
}

func (m *NTPConfig) GetNtpServer4() string {
	if m != nil {
		return m.NtpServer4
	}
	return ""
}

type InstallListRequest struct {
	Limit                int64    `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset               int64    `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_InstallListRequest proto.InternalMessageInfo

func (m *InstallListRequest) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *InstallListRequest) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

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

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

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

var xxx_messageInfo_InstallListResponse proto.InternalMessageInfo

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

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

type UninstallRequest struct {
	Software             *SoftwareInformation `protobuf:"bytes,1,opt,name=software,proto3" json:"software,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_UninstallRequest proto.InternalMessageInfo

func (m *UninstallRequest) GetSoftware() *SoftwareInformation {
	if m != nil {
		return m.Software
	}
	return nil
}

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

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

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

var xxx_messageInfo_SoftwareInformation proto.InternalMessageInfo

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

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

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

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

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

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

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

var xxx_messageInfo_UploadRequest proto.InternalMessageInfo

func (m *UploadRequest) GetSoftware() *FileUpload {
	if m != nil {
		return m.Software
	}
	return nil
}

type FileUpload struct {
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Total                int64    `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`
	Offset               int64    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	Transfer             int64    `protobuf:"varint,4,opt,name=transfer,proto3" json:"transfer,omitempty"`
	Sha256               string   `protobuf:"bytes,5,opt,name=sha256,proto3" json:"sha256,omitempty"`
	Data                 string   `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_FileUpload proto.InternalMessageInfo

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

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

func (m *FileUpload) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *FileUpload) GetTransfer() int64 {
	if m != nil {
		return m.Transfer
	}
	return 0
}

func (m *FileUpload) GetSha256() string {
	if m != nil {
		return m.Sha256
	}
	return ""
}

func (m *FileUpload) GetData() string {
	if m != nil {
		return m.Data
	}
	return ""
}

type InstallRequest 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 *InstallRequest) Reset()         { *m = InstallRequest{} }
func (m *InstallRequest) String() string { return proto.CompactTextString(m) }
func (*InstallRequest) ProtoMessage()    {}
func (*InstallRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_bb30a0cc57500dee, []int{17}
}

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

var xxx_messageInfo_InstallRequest proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*StreamInstallResponse)(nil), "api.StreamInstallResponse")
	proto.RegisterType((*UploadResponse)(nil), "api.UploadResponse")
	proto.RegisterType((*StreamImportDeviceListResponse)(nil), "api.StreamImportDeviceListResponse")
	proto.RegisterType((*GetNoderedResponse)(nil), "api.GetNoderedResponse")
	proto.RegisterType((*SetNoderedRequest)(nil), "api.SetNoderedRequest")
	proto.RegisterType((*PingRequest)(nil), "api.PingRequest")
	proto.RegisterType((*StreamPingResponse)(nil), "api.StreamPingResponse")
	proto.RegisterType((*GetNTPResponse)(nil), "api.GetNTPResponse")
	proto.RegisterType((*SetNTPRequest)(nil), "api.SetNTPRequest")
	proto.RegisterType((*StreamNTPResponse)(nil), "api.StreamNTPResponse")
	proto.RegisterType((*NTPConfig)(nil), "api.NTPConfig")
	proto.RegisterType((*InstallListRequest)(nil), "api.InstallListRequest")
	proto.RegisterType((*InstallListResponse)(nil), "api.InstallListResponse")
	proto.RegisterType((*UninstallRequest)(nil), "api.UninstallRequest")
	proto.RegisterType((*SoftwareInformation)(nil), "api.SoftwareInformation")
	proto.RegisterType((*UploadRequest)(nil), "api.UploadRequest")
	proto.RegisterType((*FileUpload)(nil), "api.FileUpload")
	proto.RegisterType((*InstallRequest)(nil), "api.InstallRequest")
}

func init() {
	proto.RegisterFile("as/external/api/tool.proto", fileDescriptor_bb30a0cc57500dee)
}

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

// ToolsServiceClient is the client API for ToolsService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ToolsServiceClient interface {
	GetNodered(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetNoderedResponse, error)
	SetNodeRed(ctx context.Context, in *SetNoderedRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StreamPing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamPingClient, error)
	GetNTP(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetNTPResponse, error)
	SetNTP(ctx context.Context, in *SetNTPRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StreamNTP(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamNTPClient, error)
	Reboot(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
	InstallList(ctx context.Context, in *InstallListRequest, opts ...grpc.CallOption) (*InstallListResponse, error)
	Uninstall(ctx context.Context, in *UninstallRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	Upload(ctx context.Context, in *UploadRequest, opts ...grpc.CallOption) (*UploadResponse, error)
	Install(ctx context.Context, in *InstallRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StreamInstall(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamInstallClient, error)
	StreamImportDeviceList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamImportDeviceListClient, error)
}

type toolsServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewToolsServiceClient(cc grpc.ClientConnInterface) ToolsServiceClient {
	return &toolsServiceClient{cc}
}

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

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

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

func (c *toolsServiceClient) StreamPing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamPingClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ToolsService_serviceDesc.Streams[0], "/api.ToolsService/StreamPing", opts...)
	if err != nil {
		return nil, err
	}
	x := &toolsServiceStreamPingClient{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 ToolsService_StreamPingClient interface {
	Recv() (*StreamPingResponse, error)
	grpc.ClientStream
}

type toolsServiceStreamPingClient struct {
	grpc.ClientStream
}

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

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

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

func (c *toolsServiceClient) StreamNTP(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamNTPClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ToolsService_serviceDesc.Streams[1], "/api.ToolsService/StreamNTP", opts...)
	if err != nil {
		return nil, err
	}
	x := &toolsServiceStreamNTPClient{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 ToolsService_StreamNTPClient interface {
	Recv() (*StreamNTPResponse, error)
	grpc.ClientStream
}

type toolsServiceStreamNTPClient struct {
	grpc.ClientStream
}

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

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

func (c *toolsServiceClient) InstallList(ctx context.Context, in *InstallListRequest, opts ...grpc.CallOption) (*InstallListResponse, error) {
	out := new(InstallListResponse)
	err := c.cc.Invoke(ctx, "/api.ToolsService/InstallList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

func (c *toolsServiceClient) StreamInstall(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamInstallClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ToolsService_serviceDesc.Streams[2], "/api.ToolsService/StreamInstall", opts...)
	if err != nil {
		return nil, err
	}
	x := &toolsServiceStreamInstallClient{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 ToolsService_StreamInstallClient interface {
	Recv() (*StreamInstallResponse, error)
	grpc.ClientStream
}

type toolsServiceStreamInstallClient struct {
	grpc.ClientStream
}

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

func (c *toolsServiceClient) StreamImportDeviceList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (ToolsService_StreamImportDeviceListClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ToolsService_serviceDesc.Streams[3], "/api.ToolsService/StreamImportDeviceList", opts...)
	if err != nil {
		return nil, err
	}
	x := &toolsServiceStreamImportDeviceListClient{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 ToolsService_StreamImportDeviceListClient interface {
	Recv() (*StreamImportDeviceListResponse, error)
	grpc.ClientStream
}

type toolsServiceStreamImportDeviceListClient struct {
	grpc.ClientStream
}

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

// ToolsServiceServer is the server API for ToolsService service.
type ToolsServiceServer interface {
	GetNodered(context.Context, *emptypb.Empty) (*GetNoderedResponse, error)
	SetNodeRed(context.Context, *SetNoderedRequest) (*emptypb.Empty, error)
	Ping(context.Context, *PingRequest) (*emptypb.Empty, error)
	StreamPing(*emptypb.Empty, ToolsService_StreamPingServer) error
	GetNTP(context.Context, *emptypb.Empty) (*GetNTPResponse, error)
	SetNTP(context.Context, *SetNTPRequest) (*emptypb.Empty, error)
	StreamNTP(*emptypb.Empty, ToolsService_StreamNTPServer) error
	Reboot(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
	InstallList(context.Context, *InstallListRequest) (*InstallListResponse, error)
	Uninstall(context.Context, *UninstallRequest) (*emptypb.Empty, error)
	Upload(context.Context, *UploadRequest) (*UploadResponse, error)
	Install(context.Context, *InstallRequest) (*emptypb.Empty, error)
	StreamInstall(*emptypb.Empty, ToolsService_StreamInstallServer) error
	StreamImportDeviceList(*emptypb.Empty, ToolsService_StreamImportDeviceListServer) error
}

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

func (*UnimplementedToolsServiceServer) GetNodered(ctx context.Context, req *emptypb.Empty) (*GetNoderedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNodered not implemented")
}
func (*UnimplementedToolsServiceServer) SetNodeRed(ctx context.Context, req *SetNoderedRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetNodeRed not implemented")
}
func (*UnimplementedToolsServiceServer) Ping(ctx context.Context, req *PingRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (*UnimplementedToolsServiceServer) StreamPing(req *emptypb.Empty, srv ToolsService_StreamPingServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamPing not implemented")
}
func (*UnimplementedToolsServiceServer) GetNTP(ctx context.Context, req *emptypb.Empty) (*GetNTPResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNTP not implemented")
}
func (*UnimplementedToolsServiceServer) SetNTP(ctx context.Context, req *SetNTPRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetNTP not implemented")
}
func (*UnimplementedToolsServiceServer) StreamNTP(req *emptypb.Empty, srv ToolsService_StreamNTPServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamNTP not implemented")
}
func (*UnimplementedToolsServiceServer) Reboot(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Reboot not implemented")
}
func (*UnimplementedToolsServiceServer) InstallList(ctx context.Context, req *InstallListRequest) (*InstallListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InstallList not implemented")
}
func (*UnimplementedToolsServiceServer) Uninstall(ctx context.Context, req *UninstallRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Uninstall not implemented")
}
func (*UnimplementedToolsServiceServer) Upload(ctx context.Context, req *UploadRequest) (*UploadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Upload not implemented")
}
func (*UnimplementedToolsServiceServer) Install(ctx context.Context, req *InstallRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Install not implemented")
}
func (*UnimplementedToolsServiceServer) StreamInstall(req *emptypb.Empty, srv ToolsService_StreamInstallServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamInstall not implemented")
}
func (*UnimplementedToolsServiceServer) StreamImportDeviceList(req *emptypb.Empty, srv ToolsService_StreamImportDeviceListServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamImportDeviceList not implemented")
}

func RegisterToolsServiceServer(s *grpc.Server, srv ToolsServiceServer) {
	s.RegisterService(&_ToolsService_serviceDesc, srv)
}

func _ToolsService_GetNodered_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.(ToolsServiceServer).GetNodered(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/GetNodered",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).GetNodered(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_SetNodeRed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetNoderedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ToolsServiceServer).SetNodeRed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/SetNodeRed",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).SetNodeRed(ctx, req.(*SetNoderedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ToolsServiceServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).Ping(ctx, req.(*PingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_StreamPing_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ToolsServiceServer).StreamPing(m, &toolsServiceStreamPingServer{stream})
}

type ToolsService_StreamPingServer interface {
	Send(*StreamPingResponse) error
	grpc.ServerStream
}

type toolsServiceStreamPingServer struct {
	grpc.ServerStream
}

func (x *toolsServiceStreamPingServer) Send(m *StreamPingResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ToolsService_GetNTP_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.(ToolsServiceServer).GetNTP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/GetNTP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).GetNTP(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_SetNTP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetNTPRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ToolsServiceServer).SetNTP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/SetNTP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).SetNTP(ctx, req.(*SetNTPRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_StreamNTP_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ToolsServiceServer).StreamNTP(m, &toolsServiceStreamNTPServer{stream})
}

type ToolsService_StreamNTPServer interface {
	Send(*StreamNTPResponse) error
	grpc.ServerStream
}

type toolsServiceStreamNTPServer struct {
	grpc.ServerStream
}

func (x *toolsServiceStreamNTPServer) Send(m *StreamNTPResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ToolsService_Reboot_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.(ToolsServiceServer).Reboot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/Reboot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).Reboot(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_InstallList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InstallListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ToolsServiceServer).InstallList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/InstallList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).InstallList(ctx, req.(*InstallListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_Uninstall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UninstallRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ToolsServiceServer).Uninstall(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/Uninstall",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).Uninstall(ctx, req.(*UninstallRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _ToolsService_Install_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InstallRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ToolsServiceServer).Install(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.ToolsService/Install",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ToolsServiceServer).Install(ctx, req.(*InstallRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ToolsService_StreamInstall_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ToolsServiceServer).StreamInstall(m, &toolsServiceStreamInstallServer{stream})
}

type ToolsService_StreamInstallServer interface {
	Send(*StreamInstallResponse) error
	grpc.ServerStream
}

type toolsServiceStreamInstallServer struct {
	grpc.ServerStream
}

func (x *toolsServiceStreamInstallServer) Send(m *StreamInstallResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ToolsService_StreamImportDeviceList_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ToolsServiceServer).StreamImportDeviceList(m, &toolsServiceStreamImportDeviceListServer{stream})
}

type ToolsService_StreamImportDeviceListServer interface {
	Send(*StreamImportDeviceListResponse) error
	grpc.ServerStream
}

type toolsServiceStreamImportDeviceListServer struct {
	grpc.ServerStream
}

func (x *toolsServiceStreamImportDeviceListServer) Send(m *StreamImportDeviceListResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _ToolsService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.ToolsService",
	HandlerType: (*ToolsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetNodered",
			Handler:    _ToolsService_GetNodered_Handler,
		},
		{
			MethodName: "SetNodeRed",
			Handler:    _ToolsService_SetNodeRed_Handler,
		},
		{
			MethodName: "Ping",
			Handler:    _ToolsService_Ping_Handler,
		},
		{
			MethodName: "GetNTP",
			Handler:    _ToolsService_GetNTP_Handler,
		},
		{
			MethodName: "SetNTP",
			Handler:    _ToolsService_SetNTP_Handler,
		},
		{
			MethodName: "Reboot",
			Handler:    _ToolsService_Reboot_Handler,
		},
		{
			MethodName: "InstallList",
			Handler:    _ToolsService_InstallList_Handler,
		},
		{
			MethodName: "Uninstall",
			Handler:    _ToolsService_Uninstall_Handler,
		},
		{
			MethodName: "Upload",
			Handler:    _ToolsService_Upload_Handler,
		},
		{
			MethodName: "Install",
			Handler:    _ToolsService_Install_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamPing",
			Handler:       _ToolsService_StreamPing_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamNTP",
			Handler:       _ToolsService_StreamNTP_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamInstall",
			Handler:       _ToolsService_StreamInstall_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamImportDeviceList",
			Handler:       _ToolsService_StreamImportDeviceList_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "as/external/api/tool.proto",
}