api

package
v0.0.0-...-58627ae Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 23, 2024 License: MIT Imports: 20 Imported by: 2

Documentation

Overview

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package api is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

This section is empty.

Variables

View Source 
var FUOTADeploymentDeviceState_name = map[int32]string{
	0: "PENDING",
	1: "SUCCESS",
	2: "ERROR",
}
View Source 
var FUOTADeploymentDeviceState_value = map[string]int32{
	"PENDING": 0,
	"SUCCESS": 1,
	"ERROR":   2,
}
View Source 
var InfluxDBPrecision_name = map[int32]string{
	0: "NS",
	1: "U",
	2: "MS",
	3: "S",
	4: "M",
	5: "H",
}
View Source 
var InfluxDBPrecision_value = map[string]int32{
	"NS": 0,
	"U":  1,
	"MS": 2,
	"S":  3,
	"M":  4,
	"H":  5,
}
View Source 
var IntegrationKind_name = map[int32]string{
	0: "HTTP",
	1: "INFLUXDB",
	2: "THINGSBOARD",
	3: "MYDEVICES",
	4: "LORACLOUD",
	5: "GCP_PUBSUB",
	6: "AWS_SNS",
	7: "AZURE_SERVICE_BUS",
	8: "PILOT_THINGS",
}
View Source 
var IntegrationKind_value = map[string]int32{
	"HTTP":              0,
	"INFLUXDB":          1,
	"THINGSBOARD":       2,
	"MYDEVICES":         3,
	"LORACLOUD":         4,
	"GCP_PUBSUB":        5,
	"AWS_SNS":           6,
	"AZURE_SERVICE_BUS": 7,
	"PILOT_THINGS":      8,
}
View Source 
var Marshaler_name = map[int32]string{
	0: "JSON",
	1: "PROTOBUF",
	2: "JSON_V3",
}
View Source 
var Marshaler_value = map[string]int32{
	"JSON":     0,
	"PROTOBUF": 1,
	"JSON_V3":  2,
}
View Source 
var MulticastGroupType_name = map[int32]string{
	0: "CLASS_C",
	1: "CLASS_B",
}
View Source 
var MulticastGroupType_value = map[string]int32{
	"CLASS_C": 0,
	"CLASS_B": 1,
}
View Source 
var RXWindow_name = map[int32]string{
	0: "RX1",
	1: "RX2",
}
View Source 
var RXWindow_value = map[string]int32{
	"RX1": 0,
	"RX2": 1,
}
View Source 
var RatePolicy_name = map[int32]string{
	0: "DROP",
	1: "MARK",
}
View Source 
var RatePolicy_value = map[string]int32{
	"DROP": 0,
	"MARK": 1,
}

Functions

func RegisterApplicationServiceHandler 

func RegisterApplicationServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterApplicationServiceHandler registers the http handlers for service ApplicationService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterApplicationServiceHandlerClient 

func RegisterApplicationServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ApplicationServiceClient) error

RegisterApplicationServiceHandlerClient registers the http handlers for service ApplicationService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ApplicationServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ApplicationServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ApplicationServiceClient" to call the correct interceptors.

func RegisterApplicationServiceHandlerFromEndpoint 

func RegisterApplicationServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterApplicationServiceHandlerFromEndpoint is same as RegisterApplicationServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterApplicationServiceHandlerServer 

func RegisterApplicationServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ApplicationServiceServer) error

RegisterApplicationServiceHandlerServer registers the http handlers for service ApplicationService to "mux". UnaryRPC :call ApplicationServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterApplicationServiceServer 

func RegisterApplicationServiceServer(s *grpc.Server, srv ApplicationServiceServer)

func RegisterDebugServiceHandler 

func RegisterDebugServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterDebugServiceHandler registers the http handlers for service DebugService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterDebugServiceHandlerClient 

func RegisterDebugServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client DebugServiceClient) error

RegisterDebugServiceHandlerClient registers the http handlers for service DebugService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "DebugServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "DebugServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "DebugServiceClient" to call the correct interceptors.

func RegisterDebugServiceHandlerFromEndpoint 

func RegisterDebugServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterDebugServiceHandlerFromEndpoint is same as RegisterDebugServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterDebugServiceHandlerServer 

func RegisterDebugServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server DebugServiceServer) error

RegisterDebugServiceHandlerServer registers the http handlers for service DebugService to "mux". UnaryRPC :call DebugServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterDebugServiceServer 

func RegisterDebugServiceServer(s *grpc.Server, srv DebugServiceServer)

func RegisterDeviceProfileServiceHandler 

func RegisterDeviceProfileServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterDeviceProfileServiceHandler registers the http handlers for service DeviceProfileService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterDeviceProfileServiceHandlerClient 

func RegisterDeviceProfileServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client DeviceProfileServiceClient) error

RegisterDeviceProfileServiceHandlerClient registers the http handlers for service DeviceProfileService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "DeviceProfileServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "DeviceProfileServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "DeviceProfileServiceClient" to call the correct interceptors.

func RegisterDeviceProfileServiceHandlerFromEndpoint 

func RegisterDeviceProfileServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterDeviceProfileServiceHandlerFromEndpoint is same as RegisterDeviceProfileServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterDeviceProfileServiceHandlerServer 

func RegisterDeviceProfileServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server DeviceProfileServiceServer) error

RegisterDeviceProfileServiceHandlerServer registers the http handlers for service DeviceProfileService to "mux". UnaryRPC :call DeviceProfileServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterDeviceProfileServiceServer 

func RegisterDeviceProfileServiceServer(s *grpc.Server, srv DeviceProfileServiceServer)

func RegisterDeviceQueueServiceHandler 

func RegisterDeviceQueueServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterDeviceQueueServiceHandler registers the http handlers for service DeviceQueueService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterDeviceQueueServiceHandlerClient 

func RegisterDeviceQueueServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client DeviceQueueServiceClient) error

RegisterDeviceQueueServiceHandlerClient registers the http handlers for service DeviceQueueService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "DeviceQueueServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "DeviceQueueServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "DeviceQueueServiceClient" to call the correct interceptors.

func RegisterDeviceQueueServiceHandlerFromEndpoint 

func RegisterDeviceQueueServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterDeviceQueueServiceHandlerFromEndpoint is same as RegisterDeviceQueueServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterDeviceQueueServiceHandlerServer 

func RegisterDeviceQueueServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server DeviceQueueServiceServer) error

RegisterDeviceQueueServiceHandlerServer registers the http handlers for service DeviceQueueService to "mux". UnaryRPC :call DeviceQueueServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterDeviceQueueServiceServer 

func RegisterDeviceQueueServiceServer(s *grpc.Server, srv DeviceQueueServiceServer)

func RegisterDeviceServiceHandler 

func RegisterDeviceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterDeviceServiceHandler registers the http handlers for service DeviceService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterDeviceServiceHandlerClient 

func RegisterDeviceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client DeviceServiceClient) error

RegisterDeviceServiceHandlerClient registers the http handlers for service DeviceService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "DeviceServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "DeviceServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "DeviceServiceClient" to call the correct interceptors.

func RegisterDeviceServiceHandlerFromEndpoint 

func RegisterDeviceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterDeviceServiceHandlerFromEndpoint is same as RegisterDeviceServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterDeviceServiceHandlerServer 

func RegisterDeviceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server DeviceServiceServer) error

RegisterDeviceServiceHandlerServer registers the http handlers for service DeviceService to "mux". UnaryRPC :call DeviceServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterDeviceServiceServer 

func RegisterDeviceServiceServer(s *grpc.Server, srv DeviceServiceServer)

func RegisterFUOTADeploymentServiceHandler 

func RegisterFUOTADeploymentServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterFUOTADeploymentServiceHandler registers the http handlers for service FUOTADeploymentService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterFUOTADeploymentServiceHandlerClient 

func RegisterFUOTADeploymentServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FUOTADeploymentServiceClient) error

RegisterFUOTADeploymentServiceHandlerClient registers the http handlers for service FUOTADeploymentService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "FUOTADeploymentServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "FUOTADeploymentServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "FUOTADeploymentServiceClient" to call the correct interceptors.

func RegisterFUOTADeploymentServiceHandlerFromEndpoint 

func RegisterFUOTADeploymentServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterFUOTADeploymentServiceHandlerFromEndpoint is same as RegisterFUOTADeploymentServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterFUOTADeploymentServiceHandlerServer 

func RegisterFUOTADeploymentServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FUOTADeploymentServiceServer) error

RegisterFUOTADeploymentServiceHandlerServer registers the http handlers for service FUOTADeploymentService to "mux". UnaryRPC :call FUOTADeploymentServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterFUOTADeploymentServiceServer 

func RegisterFUOTADeploymentServiceServer(s *grpc.Server, srv FUOTADeploymentServiceServer)

func RegisterGatewayProfileServiceHandler 

func RegisterGatewayProfileServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterGatewayProfileServiceHandler registers the http handlers for service GatewayProfileService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterGatewayProfileServiceHandlerClient 

func RegisterGatewayProfileServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client GatewayProfileServiceClient) error

RegisterGatewayProfileServiceHandlerClient registers the http handlers for service GatewayProfileService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "GatewayProfileServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "GatewayProfileServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "GatewayProfileServiceClient" to call the correct interceptors.

func RegisterGatewayProfileServiceHandlerFromEndpoint 

func RegisterGatewayProfileServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterGatewayProfileServiceHandlerFromEndpoint is same as RegisterGatewayProfileServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterGatewayProfileServiceHandlerServer 

func RegisterGatewayProfileServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server GatewayProfileServiceServer) error

RegisterGatewayProfileServiceHandlerServer registers the http handlers for service GatewayProfileService to "mux". UnaryRPC :call GatewayProfileServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterGatewayProfileServiceServer 

func RegisterGatewayProfileServiceServer(s *grpc.Server, srv GatewayProfileServiceServer)

func RegisterGatewayServiceHandler 

func RegisterGatewayServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterGatewayServiceHandler registers the http handlers for service GatewayService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterGatewayServiceHandlerClient 

func RegisterGatewayServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client GatewayServiceClient) error

RegisterGatewayServiceHandlerClient registers the http handlers for service GatewayService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "GatewayServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "GatewayServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "GatewayServiceClient" to call the correct interceptors.

func RegisterGatewayServiceHandlerFromEndpoint 

func RegisterGatewayServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterGatewayServiceHandlerFromEndpoint is same as RegisterGatewayServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterGatewayServiceHandlerServer 

func RegisterGatewayServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server GatewayServiceServer) error

RegisterGatewayServiceHandlerServer registers the http handlers for service GatewayService to "mux". UnaryRPC :call GatewayServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterGatewayServiceServer 

func RegisterGatewayServiceServer(s *grpc.Server, srv GatewayServiceServer)

func RegisterInternalServiceHandler 

func RegisterInternalServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterInternalServiceHandler registers the http handlers for service InternalService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterInternalServiceHandlerClient 

func RegisterInternalServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client InternalServiceClient) error

RegisterInternalServiceHandlerClient registers the http handlers for service InternalService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "InternalServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "InternalServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "InternalServiceClient" to call the correct interceptors.

func RegisterInternalServiceHandlerFromEndpoint 

func RegisterInternalServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterInternalServiceHandlerFromEndpoint is same as RegisterInternalServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterInternalServiceHandlerServer 

func RegisterInternalServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server InternalServiceServer) error

RegisterInternalServiceHandlerServer registers the http handlers for service InternalService to "mux". UnaryRPC :call InternalServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterInternalServiceServer 

func RegisterInternalServiceServer(s *grpc.Server, srv InternalServiceServer)

func RegisterLoraWANServiceHandler 

func RegisterLoraWANServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterLoraWANServiceHandler registers the http handlers for service LoraWANService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterLoraWANServiceHandlerClient 

func RegisterLoraWANServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LoraWANServiceClient) error

RegisterLoraWANServiceHandlerClient registers the http handlers for service LoraWANService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LoraWANServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LoraWANServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "LoraWANServiceClient" to call the correct interceptors.

func RegisterLoraWANServiceHandlerFromEndpoint 

func RegisterLoraWANServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterLoraWANServiceHandlerFromEndpoint is same as RegisterLoraWANServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterLoraWANServiceHandlerServer 

func RegisterLoraWANServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server LoraWANServiceServer) error

RegisterLoraWANServiceHandlerServer registers the http handlers for service LoraWANService to "mux". UnaryRPC :call LoraWANServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterLoraWANServiceServer 

func RegisterLoraWANServiceServer(s *grpc.Server, srv LoraWANServiceServer)

func RegisterMulticastGroupServiceHandler 

func RegisterMulticastGroupServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMulticastGroupServiceHandler registers the http handlers for service MulticastGroupService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMulticastGroupServiceHandlerClient 

func RegisterMulticastGroupServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MulticastGroupServiceClient) error

RegisterMulticastGroupServiceHandlerClient registers the http handlers for service MulticastGroupService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MulticastGroupServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MulticastGroupServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "MulticastGroupServiceClient" to call the correct interceptors.

func RegisterMulticastGroupServiceHandlerFromEndpoint 

func RegisterMulticastGroupServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMulticastGroupServiceHandlerFromEndpoint is same as RegisterMulticastGroupServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMulticastGroupServiceHandlerServer 

func RegisterMulticastGroupServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MulticastGroupServiceServer) error

RegisterMulticastGroupServiceHandlerServer registers the http handlers for service MulticastGroupService to "mux". UnaryRPC :call MulticastGroupServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterMulticastGroupServiceServer 

func RegisterMulticastGroupServiceServer(s *grpc.Server, srv MulticastGroupServiceServer)

func RegisterNetworkServerServiceHandler 

func RegisterNetworkServerServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNetworkServerServiceHandler registers the http handlers for service NetworkServerService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNetworkServerServiceHandlerClient 

func RegisterNetworkServerServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NetworkServerServiceClient) error

RegisterNetworkServerServiceHandlerClient registers the http handlers for service NetworkServerService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NetworkServerServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NetworkServerServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NetworkServerServiceClient" to call the correct interceptors.

func RegisterNetworkServerServiceHandlerFromEndpoint 

func RegisterNetworkServerServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNetworkServerServiceHandlerFromEndpoint is same as RegisterNetworkServerServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNetworkServerServiceHandlerServer 

func RegisterNetworkServerServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NetworkServerServiceServer) error

RegisterNetworkServerServiceHandlerServer registers the http handlers for service NetworkServerService to "mux". UnaryRPC :call NetworkServerServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterNetworkServerServiceServer 

func RegisterNetworkServerServiceServer(s *grpc.Server, srv NetworkServerServiceServer)

func RegisterNetworkServiceHandler 

func RegisterNetworkServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNetworkServiceHandler registers the http handlers for service NetworkService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNetworkServiceHandlerClient 

func RegisterNetworkServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NetworkServiceClient) error

RegisterNetworkServiceHandlerClient registers the http handlers for service NetworkService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NetworkServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NetworkServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NetworkServiceClient" to call the correct interceptors.

func RegisterNetworkServiceHandlerFromEndpoint 

func RegisterNetworkServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNetworkServiceHandlerFromEndpoint is same as RegisterNetworkServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNetworkServiceHandlerServer 

func RegisterNetworkServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NetworkServiceServer) error

RegisterNetworkServiceHandlerServer registers the http handlers for service NetworkService to "mux". UnaryRPC :call NetworkServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterNetworkServiceServer 

func RegisterNetworkServiceServer(s *grpc.Server, srv NetworkServiceServer)

func RegisterOTPServiceHandler 

func RegisterOTPServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterOTPServiceHandler registers the http handlers for service OTPService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterOTPServiceHandlerClient 

func RegisterOTPServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client OTPServiceClient) error

RegisterOTPServiceHandlerClient registers the http handlers for service OTPService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "OTPServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "OTPServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "OTPServiceClient" to call the correct interceptors.

func RegisterOTPServiceHandlerFromEndpoint 

func RegisterOTPServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterOTPServiceHandlerFromEndpoint is same as RegisterOTPServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterOTPServiceHandlerServer 

func RegisterOTPServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server OTPServiceServer) error

RegisterOTPServiceHandlerServer registers the http handlers for service OTPService to "mux". UnaryRPC :call OTPServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterOTPServiceServer 

func RegisterOTPServiceServer(s *grpc.Server, srv OTPServiceServer)

func RegisterOrganizationServiceHandler 

func RegisterOrganizationServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterOrganizationServiceHandler registers the http handlers for service OrganizationService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterOrganizationServiceHandlerClient 

func RegisterOrganizationServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client OrganizationServiceClient) error

RegisterOrganizationServiceHandlerClient registers the http handlers for service OrganizationService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "OrganizationServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "OrganizationServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "OrganizationServiceClient" to call the correct interceptors.

func RegisterOrganizationServiceHandlerFromEndpoint 

func RegisterOrganizationServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterOrganizationServiceHandlerFromEndpoint is same as RegisterOrganizationServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterOrganizationServiceHandlerServer 

func RegisterOrganizationServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server OrganizationServiceServer) error

RegisterOrganizationServiceHandlerServer registers the http handlers for service OrganizationService to "mux". UnaryRPC :call OrganizationServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterOrganizationServiceServer 

func RegisterOrganizationServiceServer(s *grpc.Server, srv OrganizationServiceServer)

func RegisterServiceProfileServiceHandler 

func RegisterServiceProfileServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterServiceProfileServiceHandler registers the http handlers for service ServiceProfileService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterServiceProfileServiceHandlerClient 

func RegisterServiceProfileServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceProfileServiceClient) error

RegisterServiceProfileServiceHandlerClient registers the http handlers for service ServiceProfileService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServiceProfileServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServiceProfileServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ServiceProfileServiceClient" to call the correct interceptors.

func RegisterServiceProfileServiceHandlerFromEndpoint 

func RegisterServiceProfileServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterServiceProfileServiceHandlerFromEndpoint is same as RegisterServiceProfileServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterServiceProfileServiceHandlerServer 

func RegisterServiceProfileServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceProfileServiceServer) error

RegisterServiceProfileServiceHandlerServer registers the http handlers for service ServiceProfileService to "mux". UnaryRPC :call ServiceProfileServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterServiceProfileServiceServer 

func RegisterServiceProfileServiceServer(s *grpc.Server, srv ServiceProfileServiceServer)

func RegisterStatisticsServiceHandler 

func RegisterStatisticsServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterStatisticsServiceHandler registers the http handlers for service StatisticsService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterStatisticsServiceHandlerClient 

func RegisterStatisticsServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client StatisticsServiceClient) error

RegisterStatisticsServiceHandlerClient registers the http handlers for service StatisticsService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "StatisticsServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "StatisticsServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "StatisticsServiceClient" to call the correct interceptors.

func RegisterStatisticsServiceHandlerFromEndpoint 

func RegisterStatisticsServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterStatisticsServiceHandlerFromEndpoint is same as RegisterStatisticsServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterStatisticsServiceHandlerServer 

func RegisterStatisticsServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server StatisticsServiceServer) error

RegisterStatisticsServiceHandlerServer registers the http handlers for service StatisticsService to "mux". UnaryRPC :call StatisticsServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterStatisticsServiceServer 

func RegisterStatisticsServiceServer(s *grpc.Server, srv StatisticsServiceServer)

func RegisterSystemServiceHandler 

func RegisterSystemServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterSystemServiceHandler registers the http handlers for service SystemService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterSystemServiceHandlerClient 

func RegisterSystemServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SystemServiceClient) error

RegisterSystemServiceHandlerClient registers the http handlers for service SystemService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SystemServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SystemServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "SystemServiceClient" to call the correct interceptors.

func RegisterSystemServiceHandlerFromEndpoint 

func RegisterSystemServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterSystemServiceHandlerFromEndpoint is same as RegisterSystemServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterSystemServiceHandlerServer 

func RegisterSystemServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SystemServiceServer) error

RegisterSystemServiceHandlerServer registers the http handlers for service SystemService to "mux". UnaryRPC :call SystemServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterSystemServiceServer 

func RegisterSystemServiceServer(s *grpc.Server, srv SystemServiceServer)

func RegisterToolsServiceHandler 

func RegisterToolsServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterToolsServiceHandler registers the http handlers for service ToolsService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterToolsServiceHandlerClient 

func RegisterToolsServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ToolsServiceClient) error

RegisterToolsServiceHandlerClient registers the http handlers for service ToolsService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ToolsServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ToolsServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ToolsServiceClient" to call the correct interceptors.

func RegisterToolsServiceHandlerFromEndpoint 

func RegisterToolsServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterToolsServiceHandlerFromEndpoint is same as RegisterToolsServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterToolsServiceHandlerServer 

func RegisterToolsServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ToolsServiceServer) error

RegisterToolsServiceHandlerServer registers the http handlers for service ToolsService to "mux". UnaryRPC :call ToolsServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterToolsServiceServer 

func RegisterToolsServiceServer(s *grpc.Server, srv ToolsServiceServer)

func RegisterUserServiceHandler 

func RegisterUserServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterUserServiceHandler registers the http handlers for service UserService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterUserServiceHandlerClient 

func RegisterUserServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client UserServiceClient) error

RegisterUserServiceHandlerClient registers the http handlers for service UserService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "UserServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "UserServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "UserServiceClient" to call the correct interceptors.

func RegisterUserServiceHandlerFromEndpoint 

func RegisterUserServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterUserServiceHandlerFromEndpoint is same as RegisterUserServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterUserServiceHandlerServer 

func RegisterUserServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server UserServiceServer) error

RegisterUserServiceHandlerServer registers the http handlers for service UserService to "mux". UnaryRPC :call UserServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.

func RegisterUserServiceServer 

func RegisterUserServiceServer(s *grpc.Server, srv UserServiceServer)

Types

type ABPDevice 

type ABPDevice struct {
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	DevEui               string   `protobuf:"bytes,3,opt,name=dev_eui,json=DEVEUI,proto3" json:"dev_eui,omitempty"`
	Mac                  string   `protobuf:"bytes,4,opt,name=mac,json=MAC,proto3" json:"mac,omitempty"`
	Type                 string   `protobuf:"bytes,5,opt,name=type,json=TYPE,proto3" json:"type,omitempty"`
	SkipFCntCheck        bool     `protobuf:"varint,6,opt,name=skip_f_cnt_check,json=skipFCntCheck,proto3" json:"skip_f_cnt_check,omitempty"`
	DevAddr              string   `protobuf:"bytes,7,opt,name=dev_addr,json=DEVADDR,proto3" json:"dev_addr,omitempty"`
	Nwkskey              string   `protobuf:"bytes,8,opt,name=nwkskey,json=NWKSKEY,proto3" json:"nwkskey,omitempty"`
	Appskey              string   `protobuf:"bytes,9,opt,name=appskey,json=APPSKEY,proto3" json:"appskey,omitempty"`
	IsDisabled           bool     `protobuf:"varint,10,opt,name=is_disabled,json=isDisabled,proto3" json:"is_disabled,omitempty"`
	Description          string   `protobuf:"bytes,11,opt,name=description,proto3" json:"description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ABPDevice) Descriptor 

func (*ABPDevice) Descriptor() ([]byte, []int)

func (*ABPDevice) GetApplicationId 

func (m *ABPDevice) GetApplicationId() int64

func (*ABPDevice) GetAppskey 

func (m *ABPDevice) GetAppskey() string

func (*ABPDevice) GetDescription 

func (m *ABPDevice) GetDescription() string

func (*ABPDevice) GetDevAddr 

func (m *ABPDevice) GetDevAddr() string

func (*ABPDevice) GetDevEui 

func (m *ABPDevice) GetDevEui() string

func (*ABPDevice) GetIsDisabled 

func (m *ABPDevice) GetIsDisabled() bool

func (*ABPDevice) GetMac 

func (m *ABPDevice) GetMac() string

func (*ABPDevice) GetName 

func (m *ABPDevice) GetName() string

func (*ABPDevice) GetNwkskey 

func (m *ABPDevice) GetNwkskey() string

func (*ABPDevice) GetSkipFCntCheck 

func (m *ABPDevice) GetSkipFCntCheck() bool

func (*ABPDevice) GetType 

func (m *ABPDevice) GetType() string

func (*ABPDevice) ProtoMessage 

func (*ABPDevice) ProtoMessage()

func (*ABPDevice) Reset 

func (m *ABPDevice) Reset()

func (*ABPDevice) String 

func (m *ABPDevice) String() string

func (*ABPDevice) XXX_DiscardUnknown 

func (m *ABPDevice) XXX_DiscardUnknown()

func (*ABPDevice) XXX_Marshal 

func (m *ABPDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ABPDevice) XXX_Merge 

func (m *ABPDevice) XXX_Merge(src proto.Message)

func (*ABPDevice) XXX_Size 

func (m *ABPDevice) XXX_Size() int

func (*ABPDevice) XXX_Unmarshal 

func (m *ABPDevice) XXX_Unmarshal(b []byte) error

type APIKey 

type APIKey struct {
	// API key ID.
	// This value will be automatically generated on create.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Is global admin key.
	IsAdmin bool `protobuf:"varint,3,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// Organization ID.
	// In case this API key is to manage resources within a single organization
	// set this to the ID of this organization.
	OrganizationId int64 `protobuf:"varint,4,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Application ID.
	// In case the API key is to manage resources within an application, set
	// this to the ID of this application.message
	ApplicationId        int64    `protobuf:"varint,5,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*APIKey) Descriptor 

func (*APIKey) Descriptor() ([]byte, []int)

func (*APIKey) GetApplicationId 

func (m *APIKey) GetApplicationId() int64

func (*APIKey) GetId 

func (m *APIKey) GetId() string

func (*APIKey) GetIsAdmin 

func (m *APIKey) GetIsAdmin() bool

func (*APIKey) GetName 

func (m *APIKey) GetName() string

func (*APIKey) GetOrganizationId 

func (m *APIKey) GetOrganizationId() int64

func (*APIKey) ProtoMessage 

func (*APIKey) ProtoMessage()

func (*APIKey) Reset 

func (m *APIKey) Reset()

func (*APIKey) String 

func (m *APIKey) String() string

func (*APIKey) XXX_DiscardUnknown 

func (m *APIKey) XXX_DiscardUnknown()

func (*APIKey) XXX_Marshal 

func (m *APIKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*APIKey) XXX_Merge 

func (m *APIKey) XXX_Merge(src proto.Message)

func (*APIKey) XXX_Size 

func (m *APIKey) XXX_Size() int

func (*APIKey) XXX_Unmarshal 

func (m *APIKey) XXX_Unmarshal(b []byte) error

type AWSSNSIntegration 

type AWSSNSIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Marshaler.
	// This defines the marshaler that is used to encode the event payload.
	Marshaler Marshaler `protobuf:"varint,2,opt,name=marshaler,proto3,enum=api.Marshaler" json:"marshaler,omitempty"`
	// AWS region.
	Region string `protobuf:"bytes,3,opt,name=region,proto3" json:"region,omitempty"`
	// AWS Access Key ID.
	AccessKeyId string `protobuf:"bytes,4,opt,name=access_key_id,json=accessKeyID,proto3" json:"access_key_id,omitempty"`
	// AWS Secret Access Key.
	SecretAccessKey string `protobuf:"bytes,5,opt,name=secret_access_key,json=secretAccessKey,proto3" json:"secret_access_key,omitempty"`
	// Topic ARN.
	TopicArn             string   `protobuf:"bytes,6,opt,name=topic_arn,json=topicARN,proto3" json:"topic_arn,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*AWSSNSIntegration) Descriptor 

func (*AWSSNSIntegration) Descriptor() ([]byte, []int)

func (*AWSSNSIntegration) GetAccessKeyId 

func (m *AWSSNSIntegration) GetAccessKeyId() string

func (*AWSSNSIntegration) GetApplicationId 

func (m *AWSSNSIntegration) GetApplicationId() int64

func (*AWSSNSIntegration) GetMarshaler 

func (m *AWSSNSIntegration) GetMarshaler() Marshaler

func (*AWSSNSIntegration) GetRegion 

func (m *AWSSNSIntegration) GetRegion() string

func (*AWSSNSIntegration) GetSecretAccessKey 

func (m *AWSSNSIntegration) GetSecretAccessKey() string

func (*AWSSNSIntegration) GetTopicArn 

func (m *AWSSNSIntegration) GetTopicArn() string

func (*AWSSNSIntegration) ProtoMessage 

func (*AWSSNSIntegration) ProtoMessage()

func (*AWSSNSIntegration) Reset 

func (m *AWSSNSIntegration) Reset()

func (*AWSSNSIntegration) String 

func (m *AWSSNSIntegration) String() string

func (*AWSSNSIntegration) XXX_DiscardUnknown 

func (m *AWSSNSIntegration) XXX_DiscardUnknown()

func (*AWSSNSIntegration) XXX_Marshal 

func (m *AWSSNSIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AWSSNSIntegration) XXX_Merge 

func (m *AWSSNSIntegration) XXX_Merge(src proto.Message)

func (*AWSSNSIntegration) XXX_Size 

func (m *AWSSNSIntegration) XXX_Size() int

func (*AWSSNSIntegration) XXX_Unmarshal 

func (m *AWSSNSIntegration) XXX_Unmarshal(b []byte) error

type ActivateDeviceRequest 

type ActivateDeviceRequest struct {
	DeviceActivation     *DeviceActivation `protobuf:"bytes,1,opt,name=device_activation,json=deviceActivation,proto3" json:"device_activation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*ActivateDeviceRequest) Descriptor 

func (*ActivateDeviceRequest) Descriptor() ([]byte, []int)

func (*ActivateDeviceRequest) GetDeviceActivation 

func (m *ActivateDeviceRequest) GetDeviceActivation() *DeviceActivation

func (*ActivateDeviceRequest) ProtoMessage 

func (*ActivateDeviceRequest) ProtoMessage()

func (*ActivateDeviceRequest) Reset 

func (m *ActivateDeviceRequest) Reset()

func (*ActivateDeviceRequest) String 

func (m *ActivateDeviceRequest) String() string

func (*ActivateDeviceRequest) XXX_DiscardUnknown 

func (m *ActivateDeviceRequest) XXX_DiscardUnknown()

func (*ActivateDeviceRequest) XXX_Marshal 

func (m *ActivateDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ActivateDeviceRequest) XXX_Merge 

func (m *ActivateDeviceRequest) XXX_Merge(src proto.Message)

func (*ActivateDeviceRequest) XXX_Size 

func (m *ActivateDeviceRequest) XXX_Size() int

func (*ActivateDeviceRequest) XXX_Unmarshal 

func (m *ActivateDeviceRequest) XXX_Unmarshal(b []byte) error

type AddDeviceToMulticastGroupRequest 

type AddDeviceToMulticastGroupRequest struct {
	// Multicast-group ID (string formatted UUID).
	MulticastGroupId string `protobuf:"bytes,1,opt,name=multicast_group_id,json=multicastGroupID,proto3" json:"multicast_group_id,omitempty"`
	// Device EUI (HEX encoded string).
	// Note that the device must be under the same service-profile as the
	// multicast-group.
	DevEui               string   `protobuf:"bytes,2,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*AddDeviceToMulticastGroupRequest) Descriptor 

func (*AddDeviceToMulticastGroupRequest) Descriptor() ([]byte, []int)

func (*AddDeviceToMulticastGroupRequest) GetDevEui 

func (m *AddDeviceToMulticastGroupRequest) GetDevEui() string

func (*AddDeviceToMulticastGroupRequest) GetMulticastGroupId 

func (m *AddDeviceToMulticastGroupRequest) GetMulticastGroupId() string

func (*AddDeviceToMulticastGroupRequest) ProtoMessage 

func (*AddDeviceToMulticastGroupRequest) ProtoMessage()

func (*AddDeviceToMulticastGroupRequest) Reset 

func (m *AddDeviceToMulticastGroupRequest) Reset()

func (*AddDeviceToMulticastGroupRequest) String 

func (m *AddDeviceToMulticastGroupRequest) String() string

func (*AddDeviceToMulticastGroupRequest) XXX_DiscardUnknown 

func (m *AddDeviceToMulticastGroupRequest) XXX_DiscardUnknown()

func (*AddDeviceToMulticastGroupRequest) XXX_Marshal 

func (m *AddDeviceToMulticastGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AddDeviceToMulticastGroupRequest) XXX_Merge 

func (m *AddDeviceToMulticastGroupRequest) XXX_Merge(src proto.Message)

func (*AddDeviceToMulticastGroupRequest) XXX_Size 

func (m *AddDeviceToMulticastGroupRequest) XXX_Size() int

func (*AddDeviceToMulticastGroupRequest) XXX_Unmarshal 

func (m *AddDeviceToMulticastGroupRequest) XXX_Unmarshal(b []byte) error

type AddOrganizationUserRequest 

type AddOrganizationUserRequest struct {
	// Organization-user object to create.
	OrganizationUser     *OrganizationUser `protobuf:"bytes,1,opt,name=organization_user,json=organizationUser,proto3" json:"organization_user,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*AddOrganizationUserRequest) Descriptor 

func (*AddOrganizationUserRequest) Descriptor() ([]byte, []int)

func (*AddOrganizationUserRequest) GetOrganizationUser 

func (m *AddOrganizationUserRequest) GetOrganizationUser() *OrganizationUser

func (*AddOrganizationUserRequest) ProtoMessage 

func (*AddOrganizationUserRequest) ProtoMessage()

func (*AddOrganizationUserRequest) Reset 

func (m *AddOrganizationUserRequest) Reset()

func (*AddOrganizationUserRequest) String 

func (m *AddOrganizationUserRequest) String() string

func (*AddOrganizationUserRequest) XXX_DiscardUnknown 

func (m *AddOrganizationUserRequest) XXX_DiscardUnknown()

func (*AddOrganizationUserRequest) XXX_Marshal 

func (m *AddOrganizationUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AddOrganizationUserRequest) XXX_Merge 

func (m *AddOrganizationUserRequest) XXX_Merge(src proto.Message)

func (*AddOrganizationUserRequest) XXX_Size 

func (m *AddOrganizationUserRequest) XXX_Size() int

func (*AddOrganizationUserRequest) XXX_Unmarshal 

func (m *AddOrganizationUserRequest) XXX_Unmarshal(b []byte) error

type AnalogChannel 

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

func (*AnalogChannel) Descriptor 

func (*AnalogChannel) Descriptor() ([]byte, []int)

func (*AnalogChannel) GetEnable 

func (m *AnalogChannel) GetEnable() bool

func (*AnalogChannel) GetId 

func (m *AnalogChannel) GetId() int32

func (*AnalogChannel) ProtoMessage 

func (*AnalogChannel) ProtoMessage()

func (*AnalogChannel) Reset 

func (m *AnalogChannel) Reset()

func (*AnalogChannel) String 

func (m *AnalogChannel) String() string

func (*AnalogChannel) XXX_DiscardUnknown 

func (m *AnalogChannel) XXX_DiscardUnknown()

func (*AnalogChannel) XXX_Marshal 

func (m *AnalogChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AnalogChannel) XXX_Merge 

func (m *AnalogChannel) XXX_Merge(src proto.Message)

func (*AnalogChannel) XXX_Size 

func (m *AnalogChannel) XXX_Size() int

func (*AnalogChannel) XXX_Unmarshal 

func (m *AnalogChannel) XXX_Unmarshal(b []byte) error

type Application 

type Application struct {
	// Application ID.
	// This will be automatically assigned on create.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Name of the application (must be unique).
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Description of the application.
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// ID of the organization to which the application belongs.
	// After create, this can not be modified.
	OrganizationId int64 `protobuf:"varint,4,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// ID of the service profile.
	ServiceProfileId string `protobuf:"bytes,5,opt,name=service_profile_id,json=serviceProfileID,proto3" json:"service_profile_id,omitempty"`
	// Payload codec.
	// NOTE: These field have moved to the device-profile and will be removed
	// in the next major release. When set, the device-profile payload_ fields
	// have priority over the application payload_ fields.
	PayloadCodec string `protobuf:"bytes,6,opt,name=payload_codec,json=payloadCodec,proto3" json:"payload_codec,omitempty"`
	// Payload encoder script.
	// NOTE: These field have moved to the device-profile and will be removed
	// in the next major release. When set, the device-profile payload_ fields
	// have priority over the application payload_ fields.
	PayloadEncoderScript string `protobuf:"bytes,7,opt,name=payload_encoder_script,json=payloadEncoderScript,proto3" json:"payload_encoder_script,omitempty"`
	// Payload decoder script.
	// NOTE: These field have moved to the device-profile and will be removed
	// in the next major release. When set, the device-profile payload_ fields
	// have priority over the application payload_ fields.
	PayloadDecoderScript string             `protobuf:"bytes,8,opt,name=payload_decoder_script,json=payloadDecoderScript,proto3" json:"payload_decoder_script,omitempty"`
	Default              bool               `protobuf:"varint,9,opt,name=default,proto3" json:"default,omitempty"`
	AutoJoin             bool               `protobuf:"varint,10,opt,name=auto_join,json=autoJoin,proto3" json:"auto_join,omitempty"`
	KeyPairs             []*ApplicationKeys `protobuf:"bytes,11,rep,name=key_pairs,json=keyPairs,proto3" json:"key_pairs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*Application) Descriptor 

func (*Application) Descriptor() ([]byte, []int)

func (*Application) GetAutoJoin 

func (m *Application) GetAutoJoin() bool

func (*Application) GetDefault 

func (m *Application) GetDefault() bool

func (*Application) GetDescription 

func (m *Application) GetDescription() string

func (*Application) GetId 

func (m *Application) GetId() int64

func (*Application) GetKeyPairs 

func (m *Application) GetKeyPairs() []*ApplicationKeys

func (*Application) GetName 

func (m *Application) GetName() string

func (*Application) GetOrganizationId 

func (m *Application) GetOrganizationId() int64

func (*Application) GetPayloadCodec 

func (m *Application) GetPayloadCodec() string

func (*Application) GetPayloadDecoderScript 

func (m *Application) GetPayloadDecoderScript() string

func (*Application) GetPayloadEncoderScript 

func (m *Application) GetPayloadEncoderScript() string

func (*Application) GetServiceProfileId 

func (m *Application) GetServiceProfileId() string

func (*Application) ProtoMessage 

func (*Application) ProtoMessage()

func (*Application) Reset 

func (m *Application) Reset()

func (*Application) String 

func (m *Application) String() string

func (*Application) XXX_DiscardUnknown 

func (m *Application) XXX_DiscardUnknown()

func (*Application) XXX_Marshal 

func (m *Application) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Application) XXX_Merge 

func (m *Application) XXX_Merge(src proto.Message)

func (*Application) XXX_Size 

func (m *Application) XXX_Size() int

func (*Application) XXX_Unmarshal 

func (m *Application) XXX_Unmarshal(b []byte) error

type ApplicationKeys 

type ApplicationKeys struct {
	AppEui               string   `protobuf:"bytes,1,opt,name=app_eui,json=appEUI,proto3" json:"app_eui,omitempty"`
	AppKey               string   `protobuf:"bytes,2,opt,name=app_key,json=appKey,proto3" json:"app_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ApplicationKeys) Descriptor 

func (*ApplicationKeys) Descriptor() ([]byte, []int)

func (*ApplicationKeys) GetAppEui 

func (m *ApplicationKeys) GetAppEui() string

func (*ApplicationKeys) GetAppKey 

func (m *ApplicationKeys) GetAppKey() string

func (*ApplicationKeys) ProtoMessage 

func (*ApplicationKeys) ProtoMessage()

func (*ApplicationKeys) Reset 

func (m *ApplicationKeys) Reset()

func (*ApplicationKeys) String 

func (m *ApplicationKeys) String() string

func (*ApplicationKeys) XXX_DiscardUnknown 

func (m *ApplicationKeys) XXX_DiscardUnknown()

func (*ApplicationKeys) XXX_Marshal 

func (m *ApplicationKeys) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ApplicationKeys) XXX_Merge 

func (m *ApplicationKeys) XXX_Merge(src proto.Message)

func (*ApplicationKeys) XXX_Size 

func (m *ApplicationKeys) XXX_Size() int

func (*ApplicationKeys) XXX_Unmarshal 

func (m *ApplicationKeys) XXX_Unmarshal(b []byte) error

type ApplicationListItem 

type ApplicationListItem struct {
	// Application ID.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Name of the application.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Description of the application.
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// ID of the organization to which the application belongs.
	OrganizationId int64 `protobuf:"varint,4,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// ID of the service profile.
	ServiceProfileId string `protobuf:"bytes,5,opt,name=service_profile_id,json=serviceProfileID,proto3" json:"service_profile_id,omitempty"`
	// Service-profile name.
	ServiceProfileName   string             `protobuf:"bytes,6,opt,name=service_profile_name,json=serviceProfileName,proto3" json:"service_profile_name,omitempty"`
	Default              bool               `protobuf:"varint,9,opt,name=default,proto3" json:"default,omitempty"`
	AutoJoin             bool               `protobuf:"varint,10,opt,name=auto_join,json=autoJoin,proto3" json:"auto_join,omitempty"`
	KeyPairs             []*ApplicationKeys `protobuf:"bytes,11,rep,name=key_pairs,json=keyPairs,proto3" json:"key_pairs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*ApplicationListItem) Descriptor 

func (*ApplicationListItem) Descriptor() ([]byte, []int)

func (*ApplicationListItem) GetAutoJoin 

func (m *ApplicationListItem) GetAutoJoin() bool

func (*ApplicationListItem) GetDefault 

func (m *ApplicationListItem) GetDefault() bool

func (*ApplicationListItem) GetDescription 

func (m *ApplicationListItem) GetDescription() string

func (*ApplicationListItem) GetId 

func (m *ApplicationListItem) GetId() int64

func (*ApplicationListItem) GetKeyPairs 

func (m *ApplicationListItem) GetKeyPairs() []*ApplicationKeys

func (*ApplicationListItem) GetName 

func (m *ApplicationListItem) GetName() string

func (*ApplicationListItem) GetOrganizationId 

func (m *ApplicationListItem) GetOrganizationId() int64

func (*ApplicationListItem) GetServiceProfileId 

func (m *ApplicationListItem) GetServiceProfileId() string

func (*ApplicationListItem) GetServiceProfileName 

func (m *ApplicationListItem) GetServiceProfileName() string

func (*ApplicationListItem) ProtoMessage 

func (*ApplicationListItem) ProtoMessage()

func (*ApplicationListItem) Reset 

func (m *ApplicationListItem) Reset()

func (*ApplicationListItem) String 

func (m *ApplicationListItem) String() string

func (*ApplicationListItem) XXX_DiscardUnknown 

func (m *ApplicationListItem) XXX_DiscardUnknown()

func (*ApplicationListItem) XXX_Marshal 

func (m *ApplicationListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ApplicationListItem) XXX_Merge 

func (m *ApplicationListItem) XXX_Merge(src proto.Message)

func (*ApplicationListItem) XXX_Size 

func (m *ApplicationListItem) XXX_Size() int

func (*ApplicationListItem) XXX_Unmarshal 

func (m *ApplicationListItem) XXX_Unmarshal(b []byte) error

type ApplicationServiceClient 

type ApplicationServiceClient interface {
	// Create creates the given application.
	Create(ctx context.Context, in *CreateApplicationRequest, opts ...grpc.CallOption) (*CreateApplicationResponse, error)
	// Get returns the requested application.
	Get(ctx context.Context, in *GetApplicationRequest, opts ...grpc.CallOption) (*GetApplicationResponse, error)
	// Update updates the given application.
	Update(ctx context.Context, in *UpdateApplicationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete deletes the given application.
	Delete(ctx context.Context, in *DeleteApplicationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List lists the available applications.
	List(ctx context.Context, in *ListApplicationRequest, opts ...grpc.CallOption) (*ListApplicationResponse, error)
	// CreateHTTPIntegration creates a HTTP application-integration.
	CreateHTTPIntegration(ctx context.Context, in *CreateHTTPIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetHTTPIntegration returns the HTTP application-integration.
	GetHTTPIntegration(ctx context.Context, in *GetHTTPIntegrationRequest, opts ...grpc.CallOption) (*GetHTTPIntegrationResponse, error)
	// UpdateHTTPIntegration updates the HTTP application-integration.
	UpdateHTTPIntegration(ctx context.Context, in *UpdateHTTPIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteIntegration deletes the HTTP application-integration.
	DeleteHTTPIntegration(ctx context.Context, in *DeleteHTTPIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateInfluxDBIntegration create an InfluxDB application-integration.
	CreateInfluxDBIntegration(ctx context.Context, in *CreateInfluxDBIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetInfluxDBIntegration returns the InfluxDB application-integration.
	GetInfluxDBIntegration(ctx context.Context, in *GetInfluxDBIntegrationRequest, opts ...grpc.CallOption) (*GetInfluxDBIntegrationResponse, error)
	// UpdateInfluxDBIntegration updates the InfluxDB application-integration.
	UpdateInfluxDBIntegration(ctx context.Context, in *UpdateInfluxDBIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteInfluxDBIntegration deletes the InfluxDB application-integration.
	DeleteInfluxDBIntegration(ctx context.Context, in *DeleteInfluxDBIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateThingsBoardIntegration creates a ThingsBoard application-integration.
	CreateThingsBoardIntegration(ctx context.Context, in *CreateThingsBoardIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetThingsBoardIntegration returns the ThingsBoard application-integration.
	GetThingsBoardIntegration(ctx context.Context, in *GetThingsBoardIntegrationRequest, opts ...grpc.CallOption) (*GetThingsBoardIntegrationResponse, error)
	// UpdateThingsBoardIntegration updates the ThingsBoard application-integration.
	UpdateThingsBoardIntegration(ctx context.Context, in *UpdateThingsBoardIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteThingsBoardIntegration deletes the ThingsBoard application-integration.
	DeleteThingsBoardIntegration(ctx context.Context, in *DeleteThingsBoardIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateMyDevicesIntegration creates a MyDevices application-integration.
	CreateMyDevicesIntegration(ctx context.Context, in *CreateMyDevicesIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetMyDevicesIntegration returns the MyDevices application-integration.
	GetMyDevicesIntegration(ctx context.Context, in *GetMyDevicesIntegrationRequest, opts ...grpc.CallOption) (*GetMyDevicesIntegrationResponse, error)
	// UpdateMyDevicesIntegration updates the MyDevices application-integration.
	UpdateMyDevicesIntegration(ctx context.Context, in *UpdateMyDevicesIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteMyDevicesIntegration deletes the MyDevices application-integration.
	DeleteMyDevicesIntegration(ctx context.Context, in *DeleteMyDevicesIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateLoRaCloudIntegration creates A LoRaCloud application-integration.
	CreateLoRaCloudIntegration(ctx context.Context, in *CreateLoRaCloudIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetLoRaCloudIntegration returns the LoRaCloud application-integration.
	GetLoRaCloudIntegration(ctx context.Context, in *GetLoRaCloudIntegrationRequest, opts ...grpc.CallOption) (*GetLoRaCloudIntegrationResponse, error)
	// UpdateLoRaCloudIntegration updates the LoRaCloud application-integration.
	UpdateLoRaCloudIntegration(ctx context.Context, in *UpdateLoRaCloudIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteLoRaCloudIntegration deletes the LoRaCloud application-integration.
	DeleteLoRaCloudIntegration(ctx context.Context, in *DeleteLoRaCloudIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateGCPPubSubIntegration creates a GCP PubSub application-integration.
	CreateGCPPubSubIntegration(ctx context.Context, in *CreateGCPPubSubIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetGCPPubSubIntegration returns the GCP PubSub application-integration.
	GetGCPPubSubIntegration(ctx context.Context, in *GetGCPPubSubIntegrationRequest, opts ...grpc.CallOption) (*GetGCPPubSubIntegrationResponse, error)
	// UpdateGCPPubSubIntegration updates the GCP PubSub application-integration.
	UpdateGCPPubSubIntegration(ctx context.Context, in *UpdateGCPPubSubIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteGCPPubSubIntegration deletes the GCP PubSub application-integration.
	DeleteGCPPubSubIntegration(ctx context.Context, in *DeleteGCPPubSubIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateAWSSNSIntegration creates a AWS SNS application-integration.
	CreateAWSSNSIntegration(ctx context.Context, in *CreateAWSSNSIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetAWSSNSIntegration returns the AWS SNS application-integration.
	GetAWSSNSIntegration(ctx context.Context, in *GetAWSSNSIntegrationRequest, opts ...grpc.CallOption) (*GetAWSSNSIntegrationResponse, error)
	// UpdateAWSSNSIntegration updates the AWS SNS application-integration.
	UpdateAWSSNSIntegration(ctx context.Context, in *UpdateAWSSNSIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteAWSSNSIntegration deletes the AWS SNS application-integration.
	DeleteAWSSNSIntegration(ctx context.Context, in *DeleteAWSSNSIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateAzureServiceBusIntegration creates an Azure Service-Bus application-integration.
	CreateAzureServiceBusIntegration(ctx context.Context, in *CreateAzureServiceBusIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetAzureServiceBusIntegration returns the Azure Service-Bus application-integration.
	GetAzureServiceBusIntegration(ctx context.Context, in *GetAzureServiceBusIntegrationRequest, opts ...grpc.CallOption) (*GetAzureServiceBusIntegrationResponse, error)
	// UpdateAzureServiceBusIntegration updates the Azure Service-Bus application-integration.
	UpdateAzureServiceBusIntegration(ctx context.Context, in *UpdateAzureServiceBusIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteAzureServiceBusIntegration deletes the Azure Service-Bus application-integration.
	DeleteAzureServiceBusIntegration(ctx context.Context, in *DeleteAzureServiceBusIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreatePilotThingsIntegration creates an Pilot Things application-integration.
	CreatePilotThingsIntegration(ctx context.Context, in *CreatePilotThingsIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetPilotThingsIntegration returns the Pilot Things application-integration.
	GetPilotThingsIntegration(ctx context.Context, in *GetPilotThingsIntegrationRequest, opts ...grpc.CallOption) (*GetPilotThingsIntegrationResponse, error)
	// UpdatePilotThingsIntegration updates the Pilot Things application-integration.
	UpdatePilotThingsIntegration(ctx context.Context, in *UpdatePilotThingsIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeletePilotThingsIntegration deletes the Pilot Things application-integration.
	DeletePilotThingsIntegration(ctx context.Context, in *DeletePilotThingsIntegrationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// ListIntegrations lists all configured integrations.
	ListIntegrations(ctx context.Context, in *ListIntegrationRequest, opts ...grpc.CallOption) (*ListIntegrationResponse, error)
}

ApplicationServiceClient is the client API for ApplicationService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewApplicationServiceClient 

func NewApplicationServiceClient(cc grpc.ClientConnInterface) ApplicationServiceClient

type ApplicationServiceServer 

type ApplicationServiceServer interface {
	// Create creates the given application.
	Create(context.Context, *CreateApplicationRequest) (*CreateApplicationResponse, error)
	// Get returns the requested application.
	Get(context.Context, *GetApplicationRequest) (*GetApplicationResponse, error)
	// Update updates the given application.
	Update(context.Context, *UpdateApplicationRequest) (*emptypb.Empty, error)
	// Delete deletes the given application.
	Delete(context.Context, *DeleteApplicationRequest) (*emptypb.Empty, error)
	// List lists the available applications.
	List(context.Context, *ListApplicationRequest) (*ListApplicationResponse, error)
	// CreateHTTPIntegration creates a HTTP application-integration.
	CreateHTTPIntegration(context.Context, *CreateHTTPIntegrationRequest) (*emptypb.Empty, error)
	// GetHTTPIntegration returns the HTTP application-integration.
	GetHTTPIntegration(context.Context, *GetHTTPIntegrationRequest) (*GetHTTPIntegrationResponse, error)
	// UpdateHTTPIntegration updates the HTTP application-integration.
	UpdateHTTPIntegration(context.Context, *UpdateHTTPIntegrationRequest) (*emptypb.Empty, error)
	// DeleteIntegration deletes the HTTP application-integration.
	DeleteHTTPIntegration(context.Context, *DeleteHTTPIntegrationRequest) (*emptypb.Empty, error)
	// CreateInfluxDBIntegration create an InfluxDB application-integration.
	CreateInfluxDBIntegration(context.Context, *CreateInfluxDBIntegrationRequest) (*emptypb.Empty, error)
	// GetInfluxDBIntegration returns the InfluxDB application-integration.
	GetInfluxDBIntegration(context.Context, *GetInfluxDBIntegrationRequest) (*GetInfluxDBIntegrationResponse, error)
	// UpdateInfluxDBIntegration updates the InfluxDB application-integration.
	UpdateInfluxDBIntegration(context.Context, *UpdateInfluxDBIntegrationRequest) (*emptypb.Empty, error)
	// DeleteInfluxDBIntegration deletes the InfluxDB application-integration.
	DeleteInfluxDBIntegration(context.Context, *DeleteInfluxDBIntegrationRequest) (*emptypb.Empty, error)
	// CreateThingsBoardIntegration creates a ThingsBoard application-integration.
	CreateThingsBoardIntegration(context.Context, *CreateThingsBoardIntegrationRequest) (*emptypb.Empty, error)
	// GetThingsBoardIntegration returns the ThingsBoard application-integration.
	GetThingsBoardIntegration(context.Context, *GetThingsBoardIntegrationRequest) (*GetThingsBoardIntegrationResponse, error)
	// UpdateThingsBoardIntegration updates the ThingsBoard application-integration.
	UpdateThingsBoardIntegration(context.Context, *UpdateThingsBoardIntegrationRequest) (*emptypb.Empty, error)
	// DeleteThingsBoardIntegration deletes the ThingsBoard application-integration.
	DeleteThingsBoardIntegration(context.Context, *DeleteThingsBoardIntegrationRequest) (*emptypb.Empty, error)
	// CreateMyDevicesIntegration creates a MyDevices application-integration.
	CreateMyDevicesIntegration(context.Context, *CreateMyDevicesIntegrationRequest) (*emptypb.Empty, error)
	// GetMyDevicesIntegration returns the MyDevices application-integration.
	GetMyDevicesIntegration(context.Context, *GetMyDevicesIntegrationRequest) (*GetMyDevicesIntegrationResponse, error)
	// UpdateMyDevicesIntegration updates the MyDevices application-integration.
	UpdateMyDevicesIntegration(context.Context, *UpdateMyDevicesIntegrationRequest) (*emptypb.Empty, error)
	// DeleteMyDevicesIntegration deletes the MyDevices application-integration.
	DeleteMyDevicesIntegration(context.Context, *DeleteMyDevicesIntegrationRequest) (*emptypb.Empty, error)
	// CreateLoRaCloudIntegration creates A LoRaCloud application-integration.
	CreateLoRaCloudIntegration(context.Context, *CreateLoRaCloudIntegrationRequest) (*emptypb.Empty, error)
	// GetLoRaCloudIntegration returns the LoRaCloud application-integration.
	GetLoRaCloudIntegration(context.Context, *GetLoRaCloudIntegrationRequest) (*GetLoRaCloudIntegrationResponse, error)
	// UpdateLoRaCloudIntegration updates the LoRaCloud application-integration.
	UpdateLoRaCloudIntegration(context.Context, *UpdateLoRaCloudIntegrationRequest) (*emptypb.Empty, error)
	// DeleteLoRaCloudIntegration deletes the LoRaCloud application-integration.
	DeleteLoRaCloudIntegration(context.Context, *DeleteLoRaCloudIntegrationRequest) (*emptypb.Empty, error)
	// CreateGCPPubSubIntegration creates a GCP PubSub application-integration.
	CreateGCPPubSubIntegration(context.Context, *CreateGCPPubSubIntegrationRequest) (*emptypb.Empty, error)
	// GetGCPPubSubIntegration returns the GCP PubSub application-integration.
	GetGCPPubSubIntegration(context.Context, *GetGCPPubSubIntegrationRequest) (*GetGCPPubSubIntegrationResponse, error)
	// UpdateGCPPubSubIntegration updates the GCP PubSub application-integration.
	UpdateGCPPubSubIntegration(context.Context, *UpdateGCPPubSubIntegrationRequest) (*emptypb.Empty, error)
	// DeleteGCPPubSubIntegration deletes the GCP PubSub application-integration.
	DeleteGCPPubSubIntegration(context.Context, *DeleteGCPPubSubIntegrationRequest) (*emptypb.Empty, error)
	// CreateAWSSNSIntegration creates a AWS SNS application-integration.
	CreateAWSSNSIntegration(context.Context, *CreateAWSSNSIntegrationRequest) (*emptypb.Empty, error)
	// GetAWSSNSIntegration returns the AWS SNS application-integration.
	GetAWSSNSIntegration(context.Context, *GetAWSSNSIntegrationRequest) (*GetAWSSNSIntegrationResponse, error)
	// UpdateAWSSNSIntegration updates the AWS SNS application-integration.
	UpdateAWSSNSIntegration(context.Context, *UpdateAWSSNSIntegrationRequest) (*emptypb.Empty, error)
	// DeleteAWSSNSIntegration deletes the AWS SNS application-integration.
	DeleteAWSSNSIntegration(context.Context, *DeleteAWSSNSIntegrationRequest) (*emptypb.Empty, error)
	// CreateAzureServiceBusIntegration creates an Azure Service-Bus application-integration.
	CreateAzureServiceBusIntegration(context.Context, *CreateAzureServiceBusIntegrationRequest) (*emptypb.Empty, error)
	// GetAzureServiceBusIntegration returns the Azure Service-Bus application-integration.
	GetAzureServiceBusIntegration(context.Context, *GetAzureServiceBusIntegrationRequest) (*GetAzureServiceBusIntegrationResponse, error)
	// UpdateAzureServiceBusIntegration updates the Azure Service-Bus application-integration.
	UpdateAzureServiceBusIntegration(context.Context, *UpdateAzureServiceBusIntegrationRequest) (*emptypb.Empty, error)
	// DeleteAzureServiceBusIntegration deletes the Azure Service-Bus application-integration.
	DeleteAzureServiceBusIntegration(context.Context, *DeleteAzureServiceBusIntegrationRequest) (*emptypb.Empty, error)
	// CreatePilotThingsIntegration creates an Pilot Things application-integration.
	CreatePilotThingsIntegration(context.Context, *CreatePilotThingsIntegrationRequest) (*emptypb.Empty, error)
	// GetPilotThingsIntegration returns the Pilot Things application-integration.
	GetPilotThingsIntegration(context.Context, *GetPilotThingsIntegrationRequest) (*GetPilotThingsIntegrationResponse, error)
	// UpdatePilotThingsIntegration updates the Pilot Things application-integration.
	UpdatePilotThingsIntegration(context.Context, *UpdatePilotThingsIntegrationRequest) (*emptypb.Empty, error)
	// DeletePilotThingsIntegration deletes the Pilot Things application-integration.
	DeletePilotThingsIntegration(context.Context, *DeletePilotThingsIntegrationRequest) (*emptypb.Empty, error)
	// ListIntegrations lists all configured integrations.
	ListIntegrations(context.Context, *ListIntegrationRequest) (*ListIntegrationResponse, error)
}

ApplicationServiceServer is the server API for ApplicationService service.

type AutoFilter 

type AutoFilter struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	JoinPeriod           int32    `protobuf:"varint,2,opt,name=joinPeriod,proto3" json:"joinPeriod,omitempty"`
	JoinInterval         int32    `protobuf:"varint,3,opt,name=joinInterval,proto3" json:"joinInterval,omitempty"`
	JoinCount1           int32    `protobuf:"varint,4,opt,name=joinCount1,proto3" json:"joinCount1,omitempty"`
	JoinCount2           int32    `protobuf:"varint,5,opt,name=joinCount2,proto3" json:"joinCount2,omitempty"`
	DiscardPeriod        int32    `protobuf:"varint,6,opt,name=discardPeriod,proto3" json:"discardPeriod,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*AutoFilter) Descriptor 

func (*AutoFilter) Descriptor() ([]byte, []int)

func (*AutoFilter) GetDiscardPeriod 

func (m *AutoFilter) GetDiscardPeriod() int32

func (*AutoFilter) GetEnable 

func (m *AutoFilter) GetEnable() bool

func (*AutoFilter) GetJoinCount1 

func (m *AutoFilter) GetJoinCount1() int32

func (*AutoFilter) GetJoinCount2 

func (m *AutoFilter) GetJoinCount2() int32

func (*AutoFilter) GetJoinInterval 

func (m *AutoFilter) GetJoinInterval() int32

func (*AutoFilter) GetJoinPeriod 

func (m *AutoFilter) GetJoinPeriod() int32

func (*AutoFilter) ProtoMessage 

func (*AutoFilter) ProtoMessage()

func (*AutoFilter) Reset 

func (m *AutoFilter) Reset()

func (*AutoFilter) String 

func (m *AutoFilter) String() string

func (*AutoFilter) XXX_DiscardUnknown 

func (m *AutoFilter) XXX_DiscardUnknown()

func (*AutoFilter) XXX_Marshal 

func (m *AutoFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AutoFilter) XXX_Merge 

func (m *AutoFilter) XXX_Merge(src proto.Message)

func (*AutoFilter) XXX_Size 

func (m *AutoFilter) XXX_Size() int

func (*AutoFilter) XXX_Unmarshal 

func (m *AutoFilter) XXX_Unmarshal(b []byte) error

type AzureServiceBusIntegration 

type AzureServiceBusIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Marshaler.
	// This defines the marshaler that is used to encode the event payload.
	Marshaler Marshaler `protobuf:"varint,2,opt,name=marshaler,proto3,enum=api.Marshaler" json:"marshaler,omitempty"`
	// Connection string.
	ConnectionString string `protobuf:"bytes,3,opt,name=connection_string,json=connectionString,proto3" json:"connection_string,omitempty"`
	// Publish name.
	// This is the name of the topic or queue.
	PublishName          string   `protobuf:"bytes,4,opt,name=publish_name,json=publishName,proto3" json:"publish_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*AzureServiceBusIntegration) Descriptor 

func (*AzureServiceBusIntegration) Descriptor() ([]byte, []int)

func (*AzureServiceBusIntegration) GetApplicationId 

func (m *AzureServiceBusIntegration) GetApplicationId() int64

func (*AzureServiceBusIntegration) GetConnectionString 

func (m *AzureServiceBusIntegration) GetConnectionString() string

func (*AzureServiceBusIntegration) GetMarshaler 

func (m *AzureServiceBusIntegration) GetMarshaler() Marshaler

func (*AzureServiceBusIntegration) GetPublishName 

func (m *AzureServiceBusIntegration) GetPublishName() string

func (*AzureServiceBusIntegration) ProtoMessage 

func (*AzureServiceBusIntegration) ProtoMessage()

func (*AzureServiceBusIntegration) Reset 

func (m *AzureServiceBusIntegration) Reset()

func (*AzureServiceBusIntegration) String 

func (m *AzureServiceBusIntegration) String() string

func (*AzureServiceBusIntegration) XXX_DiscardUnknown 

func (m *AzureServiceBusIntegration) XXX_DiscardUnknown()

func (*AzureServiceBusIntegration) XXX_Marshal 

func (m *AzureServiceBusIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AzureServiceBusIntegration) XXX_Merge 

func (m *AzureServiceBusIntegration) XXX_Merge(src proto.Message)

func (*AzureServiceBusIntegration) XXX_Size 

func (m *AzureServiceBusIntegration) XXX_Size() int

func (*AzureServiceBusIntegration) XXX_Unmarshal 

func (m *AzureServiceBusIntegration) XXX_Unmarshal(b []byte) error

type BLOCK0Request 

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

func (*BLOCK0Request) Descriptor 

func (*BLOCK0Request) Descriptor() ([]byte, []int)

func (*BLOCK0Request) GetRegion 

func (m *BLOCK0Request) GetRegion() string

func (*BLOCK0Request) GetVersion 

func (m *BLOCK0Request) GetVersion() string

func (*BLOCK0Request) ProtoMessage 

func (*BLOCK0Request) ProtoMessage()

func (*BLOCK0Request) Reset 

func (m *BLOCK0Request) Reset()

func (*BLOCK0Request) String 

func (m *BLOCK0Request) String() string

func (*BLOCK0Request) XXX_DiscardUnknown 

func (m *BLOCK0Request) XXX_DiscardUnknown()

func (*BLOCK0Request) XXX_Marshal 

func (m *BLOCK0Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BLOCK0Request) XXX_Merge 

func (m *BLOCK0Request) XXX_Merge(src proto.Message)

func (*BLOCK0Request) XXX_Size 

func (m *BLOCK0Request) XXX_Size() int

func (*BLOCK0Request) XXX_Unmarshal 

func (m *BLOCK0Request) XXX_Unmarshal(b []byte) error

type BLOCK0Response 

type BLOCK0Response struct {
	SetStatus            bool     `protobuf:"varint,3,opt,name=set_status,json=setStatus,proto3" json:"set_status,omitempty"`
	Region               string   `protobuf:"bytes,1,opt,name=region,proto3" json:"region,omitempty"`
	Version              string   `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BLOCK0Response) Descriptor 

func (*BLOCK0Response) Descriptor() ([]byte, []int)

func (*BLOCK0Response) GetRegion 

func (m *BLOCK0Response) GetRegion() string

func (*BLOCK0Response) GetSetStatus 

func (m *BLOCK0Response) GetSetStatus() bool

func (*BLOCK0Response) GetVersion 

func (m *BLOCK0Response) GetVersion() string

func (*BLOCK0Response) ProtoMessage 

func (*BLOCK0Response) ProtoMessage()

func (*BLOCK0Response) Reset 

func (m *BLOCK0Response) Reset()

func (*BLOCK0Response) String 

func (m *BLOCK0Response) String() string

func (*BLOCK0Response) XXX_DiscardUnknown 

func (m *BLOCK0Response) XXX_DiscardUnknown()

func (*BLOCK0Response) XXX_Marshal 

func (m *BLOCK0Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BLOCK0Response) XXX_Merge 

func (m *BLOCK0Response) XXX_Merge(src proto.Message)

func (*BLOCK0Response) XXX_Size 

func (m *BLOCK0Response) XXX_Size() int

func (*BLOCK0Response) XXX_Unmarshal 

func (m *BLOCK0Response) XXX_Unmarshal(b []byte) error

type BSAuth 

type BSAuth struct {
	Mode                 string   `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`
	CaCert               string   `protobuf:"bytes,2,opt,name=caCert,proto3" json:"caCert,omitempty"`
	CliCert              string   `protobuf:"bytes,3,opt,name=cliCert,proto3" json:"cliCert,omitempty"`
	CliKey               string   `protobuf:"bytes,4,opt,name=cliKey,proto3" json:"cliKey,omitempty"`
	Token                string   `protobuf:"bytes,5,opt,name=token,proto3" json:"token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BSAuth) Descriptor 

func (*BSAuth) Descriptor() ([]byte, []int)

func (*BSAuth) GetCaCert 

func (m *BSAuth) GetCaCert() string

func (*BSAuth) GetCliCert 

func (m *BSAuth) GetCliCert() string

func (*BSAuth) GetCliKey 

func (m *BSAuth) GetCliKey() string

func (*BSAuth) GetMode 

func (m *BSAuth) GetMode() string

func (*BSAuth) GetToken 

func (m *BSAuth) GetToken() string

func (*BSAuth) ProtoMessage 

func (*BSAuth) ProtoMessage()

func (*BSAuth) Reset 

func (m *BSAuth) Reset()

func (*BSAuth) String 

func (m *BSAuth) String() string

func (*BSAuth) XXX_DiscardUnknown 

func (m *BSAuth) XXX_DiscardUnknown()

func (*BSAuth) XXX_Marshal 

func (m *BSAuth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BSAuth) XXX_Merge 

func (m *BSAuth) XXX_Merge(src proto.Message)

func (*BSAuth) XXX_Size 

func (m *BSAuth) XXX_Size() int

func (*BSAuth) XXX_Unmarshal 

func (m *BSAuth) XXX_Unmarshal(b []byte) error

type BackupInformation 

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 (*BackupInformation) Descriptor 

func (*BackupInformation) Descriptor() ([]byte, []int)

func (*BackupInformation) GetDate 

func (m *BackupInformation) GetDate() string

func (*BackupInformation) GetVersion 

func (m *BackupInformation) GetVersion() string

func (*BackupInformation) ProtoMessage 

func (*BackupInformation) ProtoMessage()

func (*BackupInformation) Reset 

func (m *BackupInformation) Reset()

func (*BackupInformation) String 

func (m *BackupInformation) String() string

func (*BackupInformation) XXX_DiscardUnknown 

func (m *BackupInformation) XXX_DiscardUnknown()

func (*BackupInformation) XXX_Marshal 

func (m *BackupInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BackupInformation) XXX_Merge 

func (m *BackupInformation) XXX_Merge(src proto.Message)

func (*BackupInformation) XXX_Size 

func (m *BackupInformation) XXX_Size() int

func (*BackupInformation) XXX_Unmarshal 

func (m *BackupInformation) XXX_Unmarshal(b []byte) error

type BackupListResponse 

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 (*BackupListResponse) Descriptor 

func (*BackupListResponse) Descriptor() ([]byte, []int)

func (*BackupListResponse) GetResult 

func (m *BackupListResponse) GetResult() []*BackupInformation

func (*BackupListResponse) GetTotalCount 

func (m *BackupListResponse) GetTotalCount() int64

func (*BackupListResponse) ProtoMessage 

func (*BackupListResponse) ProtoMessage()

func (*BackupListResponse) Reset 

func (m *BackupListResponse) Reset()

func (*BackupListResponse) String 

func (m *BackupListResponse) String() string

func (*BackupListResponse) XXX_DiscardUnknown 

func (m *BackupListResponse) XXX_DiscardUnknown()

func (*BackupListResponse) XXX_Marshal 

func (m *BackupListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BackupListResponse) XXX_Merge 

func (m *BackupListResponse) XXX_Merge(src proto.Message)

func (*BackupListResponse) XXX_Size 

func (m *BackupListResponse) XXX_Size() int

func (*BackupListResponse) XXX_Unmarshal 

func (m *BackupListResponse) XXX_Unmarshal(b []byte) error

type BackupRequest 

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 (*BackupRequest) Descriptor 

func (*BackupRequest) Descriptor() ([]byte, []int)

func (*BackupRequest) GetVersion 

func (m *BackupRequest) GetVersion() string

func (*BackupRequest) ProtoMessage 

func (*BackupRequest) ProtoMessage()

func (*BackupRequest) Reset 

func (m *BackupRequest) Reset()

func (*BackupRequest) String 

func (m *BackupRequest) String() string

func (*BackupRequest) XXX_DiscardUnknown 

func (m *BackupRequest) XXX_DiscardUnknown()

func (*BackupRequest) XXX_Marshal 

func (m *BackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BackupRequest) XXX_Merge 

func (m *BackupRequest) XXX_Merge(src proto.Message)

func (*BackupRequest) XXX_Size 

func (m *BackupRequest) XXX_Size() int

func (*BackupRequest) XXX_Unmarshal 

func (m *BackupRequest) XXX_Unmarshal(b []byte) error

type BasicsStation 

type BasicsStation struct {
	Type                 string   `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Server               string   `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"`
	Port                 int64    `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	Auth                 *BSAuth  `protobuf:"bytes,4,opt,name=auth,proto3" json:"auth,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicsStation) Descriptor 

func (*BasicsStation) Descriptor() ([]byte, []int)

func (*BasicsStation) GetAuth 

func (m *BasicsStation) GetAuth() *BSAuth

func (*BasicsStation) GetPort 

func (m *BasicsStation) GetPort() int64

func (*BasicsStation) GetServer 

func (m *BasicsStation) GetServer() string

func (*BasicsStation) GetType 

func (m *BasicsStation) GetType() string

func (*BasicsStation) ProtoMessage 

func (*BasicsStation) ProtoMessage()

func (*BasicsStation) Reset 

func (m *BasicsStation) Reset()

func (*BasicsStation) String 

func (m *BasicsStation) String() string

func (*BasicsStation) XXX_DiscardUnknown 

func (m *BasicsStation) XXX_DiscardUnknown()

func (*BasicsStation) XXX_Marshal 

func (m *BasicsStation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicsStation) XXX_Merge 

func (m *BasicsStation) XXX_Merge(src proto.Message)

func (*BasicsStation) XXX_Size 

func (m *BasicsStation) XXX_Size() int

func (*BasicsStation) XXX_Unmarshal 

func (m *BasicsStation) XXX_Unmarshal(b []byte) error

type Branding 

type Branding struct {
	// Registration html.
	Registration string `protobuf:"bytes,1,opt,name=registration,proto3" json:"registration,omitempty"`
	// Footer html.
	Footer               string   `protobuf:"bytes,2,opt,name=footer,proto3" json:"footer,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*Branding) Descriptor 

func (*Branding) Descriptor() ([]byte, []int)

func (*Branding) GetFooter 

func (m *Branding) GetFooter() string

func (*Branding) GetRegistration 

func (m *Branding) GetRegistration() string

func (*Branding) ProtoMessage 

func (*Branding) ProtoMessage()

func (*Branding) Reset 

func (m *Branding) Reset()

func (*Branding) String 

func (m *Branding) String() string

func (*Branding) XXX_DiscardUnknown 

func (m *Branding) XXX_DiscardUnknown()

func (*Branding) XXX_Marshal 

func (m *Branding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Branding) XXX_Merge 

func (m *Branding) XXX_Merge(src proto.Message)

func (*Branding) XXX_Size 

func (m *Branding) XXX_Size() int

func (*Branding) XXX_Unmarshal 

func (m *Branding) XXX_Unmarshal(b []byte) error

type BuiltInNetworkServer 

type BuiltInNetworkServer struct {
	NetworkId                     string            `protobuf:"bytes,1,opt,name=networkId,proto3" json:"networkId,omitempty"`
	Adr                           *NSADR            `protobuf:"bytes,2,opt,name=adr,proto3" json:"adr,omitempty"`
	Rx1                           *NSRX1            `protobuf:"bytes,3,opt,name=rx1,proto3" json:"rx1,omitempty"`
	Rx2                           *NSRX2            `protobuf:"bytes,4,opt,name=rx2,proto3" json:"rx2,omitempty"`
	DwellTimeLimit                *NSDwellTimeLimit `protobuf:"bytes,5,opt,name=dwellTimeLimit,proto3" json:"dwellTimeLimit,omitempty"`
	DownlinkTxPower               int32             `protobuf:"varint,6,opt,name=downlinkTxPower,proto3" json:"downlinkTxPower,omitempty"`
	DisableFrameCounterValidation bool              `protobuf:"varint,7,opt,name=disableFrameCounterValidation,proto3" json:"disableFrameCounterValidation,omitempty"`
	EndDeviceStatusQueryInterval  int32             `protobuf:"varint,8,opt,name=endDeviceStatusQueryInterval,proto3" json:"endDeviceStatusQueryInterval,omitempty"`
	StatisticsPeriod              int32             `protobuf:"varint,9,opt,name=statisticsPeriod,proto3" json:"statisticsPeriod,omitempty"`
	XXX_NoUnkeyedLiteral          struct{}          `json:"-"`
	XXX_unrecognized              []byte            `json:"-"`
	XXX_sizecache                 int32             `json:"-"`
}

func (*BuiltInNetworkServer) Descriptor 

func (*BuiltInNetworkServer) Descriptor() ([]byte, []int)

func (*BuiltInNetworkServer) GetAdr 

func (m *BuiltInNetworkServer) GetAdr() *NSADR

func (*BuiltInNetworkServer) GetDisableFrameCounterValidation 

func (m *BuiltInNetworkServer) GetDisableFrameCounterValidation() bool

func (*BuiltInNetworkServer) GetDownlinkTxPower 

func (m *BuiltInNetworkServer) GetDownlinkTxPower() int32

func (*BuiltInNetworkServer) GetDwellTimeLimit 

func (m *BuiltInNetworkServer) GetDwellTimeLimit() *NSDwellTimeLimit

func (*BuiltInNetworkServer) GetEndDeviceStatusQueryInterval 

func (m *BuiltInNetworkServer) GetEndDeviceStatusQueryInterval() int32

func (*BuiltInNetworkServer) GetNetworkId 

func (m *BuiltInNetworkServer) GetNetworkId() string

func (*BuiltInNetworkServer) GetRx1 

func (m *BuiltInNetworkServer) GetRx1() *NSRX1

func (*BuiltInNetworkServer) GetRx2 

func (m *BuiltInNetworkServer) GetRx2() *NSRX2

func (*BuiltInNetworkServer) GetStatisticsPeriod 

func (m *BuiltInNetworkServer) GetStatisticsPeriod() int32

func (*BuiltInNetworkServer) ProtoMessage 

func (*BuiltInNetworkServer) ProtoMessage()

func (*BuiltInNetworkServer) Reset 

func (m *BuiltInNetworkServer) Reset()

func (*BuiltInNetworkServer) String 

func (m *BuiltInNetworkServer) String() string

func (*BuiltInNetworkServer) XXX_DiscardUnknown 

func (m *BuiltInNetworkServer) XXX_DiscardUnknown()

func (*BuiltInNetworkServer) XXX_Marshal 

func (m *BuiltInNetworkServer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BuiltInNetworkServer) XXX_Merge 

func (m *BuiltInNetworkServer) XXX_Merge(src proto.Message)

func (*BuiltInNetworkServer) XXX_Size 

func (m *BuiltInNetworkServer) XXX_Size() int

func (*BuiltInNetworkServer) XXX_Unmarshal 

func (m *BuiltInNetworkServer) XXX_Unmarshal(b []byte) error

type CN470Config 

type CN470Config struct {
	LoraWanPublic        bool        `protobuf:"varint,1,opt,name=loraWanPublic,proto3" json:"loraWanPublic,omitempty"`
	SubBandId            int32       `protobuf:"varint,2,opt,name=subBandId,proto3" json:"subBandId,omitempty"`
	TxFreq               *TXFreqItem `protobuf:"bytes,3,opt,name=txFreq,proto3" json:"txFreq,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*CN470Config) Descriptor 

func (*CN470Config) Descriptor() ([]byte, []int)

func (*CN470Config) GetLoraWanPublic 

func (m *CN470Config) GetLoraWanPublic() bool

func (*CN470Config) GetSubBandId 

func (m *CN470Config) GetSubBandId() int32

func (*CN470Config) GetTxFreq 

func (m *CN470Config) GetTxFreq() *TXFreqItem

func (*CN470Config) ProtoMessage 

func (*CN470Config) ProtoMessage()

func (*CN470Config) Reset 

func (m *CN470Config) Reset()

func (*CN470Config) String 

func (m *CN470Config) String() string

func (*CN470Config) XXX_DiscardUnknown 

func (m *CN470Config) XXX_DiscardUnknown()

func (*CN470Config) XXX_Marshal 

func (m *CN470Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CN470Config) XXX_Merge 

func (m *CN470Config) XXX_Merge(src proto.Message)

func (*CN470Config) XXX_Size 

func (m *CN470Config) XXX_Size() int

func (*CN470Config) XXX_Unmarshal 

func (m *CN470Config) XXX_Unmarshal(b []byte) error

type CSVAdd 

type CSVAdd struct {
	Payload              []*CSVDevice `protobuf:"bytes,1,rep,name=payload,proto3" json:"payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (*CSVAdd) Descriptor 

func (*CSVAdd) Descriptor() ([]byte, []int)

func (*CSVAdd) GetPayload 

func (m *CSVAdd) GetPayload() []*CSVDevice

func (*CSVAdd) ProtoMessage 

func (*CSVAdd) ProtoMessage()

func (*CSVAdd) Reset 

func (m *CSVAdd) Reset()

func (*CSVAdd) String 

func (m *CSVAdd) String() string

func (*CSVAdd) XXX_DiscardUnknown 

func (m *CSVAdd) XXX_DiscardUnknown()

func (*CSVAdd) XXX_Marshal 

func (m *CSVAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CSVAdd) XXX_Merge 

func (m *CSVAdd) XXX_Merge(src proto.Message)

func (*CSVAdd) XXX_Size 

func (m *CSVAdd) XXX_Size() int

func (*CSVAdd) XXX_Unmarshal 

func (m *CSVAdd) XXX_Unmarshal(b []byte) error

type CSVDevice 

type CSVDevice struct {
	// Types that are valid to be assigned to Dev:
	//
	//	*CSVDevice_Abp
	//	*CSVDevice_Otaa
	Dev                  isCSVDevice_Dev `protobuf_oneof:"dev"`
	Id                   string          `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	FrequencyPlanId      string          `protobuf:"bytes,4,opt,name=frequency_plan_id,proto3" json:"frequency_plan_id,omitempty"`
	LorawanPhyVersion    string          `protobuf:"bytes,5,opt,name=lorawan_phy_version,proto3" json:"lorawan_phy_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*CSVDevice) Descriptor 

func (*CSVDevice) Descriptor() ([]byte, []int)

func (*CSVDevice) GetAbp 

func (m *CSVDevice) GetAbp() *ABPDevice

func (*CSVDevice) GetDev 

func (m *CSVDevice) GetDev() isCSVDevice_Dev

func (*CSVDevice) GetFrequencyPlanId 

func (m *CSVDevice) GetFrequencyPlanId() string

func (*CSVDevice) GetId 

func (m *CSVDevice) GetId() string

func (*CSVDevice) GetLorawanPhyVersion 

func (m *CSVDevice) GetLorawanPhyVersion() string

func (*CSVDevice) GetOtaa 

func (m *CSVDevice) GetOtaa() *OTAADevice

func (*CSVDevice) ProtoMessage 

func (*CSVDevice) ProtoMessage()

func (*CSVDevice) Reset 

func (m *CSVDevice) Reset()

func (*CSVDevice) String 

func (m *CSVDevice) String() string

func (*CSVDevice) XXX_DiscardUnknown 

func (m *CSVDevice) XXX_DiscardUnknown()

func (*CSVDevice) XXX_Marshal 

func (m *CSVDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CSVDevice) XXX_Merge 

func (m *CSVDevice) XXX_Merge(src proto.Message)

func (*CSVDevice) XXX_OneofWrappers 

func (*CSVDevice) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*CSVDevice) XXX_Size 

func (m *CSVDevice) XXX_Size() int

func (*CSVDevice) XXX_Unmarshal 

func (m *CSVDevice) XXX_Unmarshal(b []byte) error

type CSVDevice_Abp 

type CSVDevice_Abp struct {
	Abp *ABPDevice `protobuf:"bytes,1,opt,name=abp,json=ABP,proto3,oneof"`
}

type CSVDevice_Otaa 

type CSVDevice_Otaa struct {
	Otaa *OTAADevice `protobuf:"bytes,2,opt,name=otaa,json=OTAA,proto3,oneof"`
}

type CameraAdd 

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

func (*CameraAdd) Descriptor 

func (*CameraAdd) Descriptor() ([]byte, []int)

func (*CameraAdd) ProtoMessage 

func (*CameraAdd) ProtoMessage()

func (*CameraAdd) Reset 

func (m *CameraAdd) Reset()

func (*CameraAdd) String 

func (m *CameraAdd) String() string

func (*CameraAdd) XXX_DiscardUnknown 

func (m *CameraAdd) XXX_DiscardUnknown()

func (*CameraAdd) XXX_Marshal 

func (m *CameraAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CameraAdd) XXX_Merge 

func (m *CameraAdd) XXX_Merge(src proto.Message)

func (*CameraAdd) XXX_Size 

func (m *CameraAdd) XXX_Size() int

func (*CameraAdd) XXX_Unmarshal 

func (m *CameraAdd) XXX_Unmarshal(b []byte) error

type Cat1Request 

type Cat1Request 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 (*Cat1Request) Descriptor 

func (*Cat1Request) Descriptor() ([]byte, []int)

func (*Cat1Request) GetEnable 

func (m *Cat1Request) GetEnable() bool

func (*Cat1Request) ProtoMessage 

func (*Cat1Request) ProtoMessage()

func (*Cat1Request) Reset 

func (m *Cat1Request) Reset()

func (*Cat1Request) String 

func (m *Cat1Request) String() string

func (*Cat1Request) XXX_DiscardUnknown 

func (m *Cat1Request) XXX_DiscardUnknown()

func (*Cat1Request) XXX_Marshal 

func (m *Cat1Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Cat1Request) XXX_Merge 

func (m *Cat1Request) XXX_Merge(src proto.Message)

func (*Cat1Request) XXX_Size 

func (m *Cat1Request) XXX_Size() int

func (*Cat1Request) XXX_Unmarshal 

func (m *Cat1Request) XXX_Unmarshal(b []byte) error

type Cat1Response 

type Cat1Response struct {
	Cat1                 *MoudleCat1 `protobuf:"bytes,3,opt,name=cat1,proto3" json:"cat1,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*Cat1Response) Descriptor 

func (*Cat1Response) Descriptor() ([]byte, []int)

func (*Cat1Response) GetCat1 

func (m *Cat1Response) GetCat1() *MoudleCat1

func (*Cat1Response) ProtoMessage 

func (*Cat1Response) ProtoMessage()

func (*Cat1Response) Reset 

func (m *Cat1Response) Reset()

func (*Cat1Response) String 

func (m *Cat1Response) String() string

func (*Cat1Response) XXX_DiscardUnknown 

func (m *Cat1Response) XXX_DiscardUnknown()

func (*Cat1Response) XXX_Marshal 

func (m *Cat1Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Cat1Response) XXX_Merge 

func (m *Cat1Response) XXX_Merge(src proto.Message)

func (*Cat1Response) XXX_Size 

func (m *Cat1Response) XXX_Size() int

func (*Cat1Response) XXX_Unmarshal 

func (m *Cat1Response) XXX_Unmarshal(b []byte) error

type CollectConfig 

type CollectConfig struct {
	Power                *DTUPowerConfig    `protobuf:"bytes,1,opt,name=power,proto3" json:"power,omitempty"`
	DigitalChannel       []*DigitalChannel  `protobuf:"bytes,2,rep,name=digital_channel,json=digitalChannel,proto3" json:"digital_channel,omitempty"`
	AnalogChannel        []*AnalogChannel   `protobuf:"bytes,3,rep,name=analog_channel,json=analogChannel,proto3" json:"analog_channel,omitempty"`
	Modbus               *RS485ModbusConfig `protobuf:"bytes,4,opt,name=modbus,proto3" json:"modbus,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*CollectConfig) Descriptor 

func (*CollectConfig) Descriptor() ([]byte, []int)

func (*CollectConfig) GetAnalogChannel 

func (m *CollectConfig) GetAnalogChannel() []*AnalogChannel

func (*CollectConfig) GetDigitalChannel 

func (m *CollectConfig) GetDigitalChannel() []*DigitalChannel

func (*CollectConfig) GetModbus 

func (m *CollectConfig) GetModbus() *RS485ModbusConfig

func (*CollectConfig) GetPower 

func (m *CollectConfig) GetPower() *DTUPowerConfig

func (*CollectConfig) ProtoMessage 

func (*CollectConfig) ProtoMessage()

func (*CollectConfig) Reset 

func (m *CollectConfig) Reset()

func (*CollectConfig) String 

func (m *CollectConfig) String() string

func (*CollectConfig) XXX_DiscardUnknown 

func (m *CollectConfig) XXX_DiscardUnknown()

func (*CollectConfig) XXX_Marshal 

func (m *CollectConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CollectConfig) XXX_Merge 

func (m *CollectConfig) XXX_Merge(src proto.Message)

func (*CollectConfig) XXX_Size 

func (m *CollectConfig) XXX_Size() int

func (*CollectConfig) XXX_Unmarshal 

func (m *CollectConfig) XXX_Unmarshal(b []byte) error

type ConfigGateWayModeRegionRequest 

type ConfigGateWayModeRegionRequest struct {
	Mode                 *GateWayMode   `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`
	Region               *GateWayRegion `protobuf:"bytes,2,opt,name=region,proto3" json:"region,omitempty"`
	Filter               *Filter        `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*ConfigGateWayModeRegionRequest) Descriptor 

func (*ConfigGateWayModeRegionRequest) Descriptor() ([]byte, []int)

func (*ConfigGateWayModeRegionRequest) GetFilter 

func (m *ConfigGateWayModeRegionRequest) GetFilter() *Filter

func (*ConfigGateWayModeRegionRequest) GetMode 

func (m *ConfigGateWayModeRegionRequest) GetMode() *GateWayMode

func (*ConfigGateWayModeRegionRequest) GetRegion 

func (m *ConfigGateWayModeRegionRequest) GetRegion() *GateWayRegion

func (*ConfigGateWayModeRegionRequest) ProtoMessage 

func (*ConfigGateWayModeRegionRequest) ProtoMessage()

func (*ConfigGateWayModeRegionRequest) Reset 

func (m *ConfigGateWayModeRegionRequest) Reset()

func (*ConfigGateWayModeRegionRequest) String 

func (m *ConfigGateWayModeRegionRequest) String() string

func (*ConfigGateWayModeRegionRequest) XXX_DiscardUnknown 

func (m *ConfigGateWayModeRegionRequest) XXX_DiscardUnknown()

func (*ConfigGateWayModeRegionRequest) XXX_Marshal 

func (m *ConfigGateWayModeRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConfigGateWayModeRegionRequest) XXX_Merge 

func (m *ConfigGateWayModeRegionRequest) XXX_Merge(src proto.Message)

func (*ConfigGateWayModeRegionRequest) XXX_Size 

func (m *ConfigGateWayModeRegionRequest) XXX_Size() int

func (*ConfigGateWayModeRegionRequest) XXX_Unmarshal 

func (m *ConfigGateWayModeRegionRequest) XXX_Unmarshal(b []byte) error

type ConfigGateWayModeRegionResponse 

type ConfigGateWayModeRegionResponse struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Status               string   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConfigGateWayModeRegionResponse) Descriptor 

func (*ConfigGateWayModeRegionResponse) Descriptor() ([]byte, []int)

func (*ConfigGateWayModeRegionResponse) GetMessage 

func (m *ConfigGateWayModeRegionResponse) GetMessage() string

func (*ConfigGateWayModeRegionResponse) GetStatus 

func (m *ConfigGateWayModeRegionResponse) GetStatus() string

func (*ConfigGateWayModeRegionResponse) ProtoMessage 

func (*ConfigGateWayModeRegionResponse) ProtoMessage()

func (*ConfigGateWayModeRegionResponse) Reset 

func (m *ConfigGateWayModeRegionResponse) Reset()

func (*ConfigGateWayModeRegionResponse) String 

func (m *ConfigGateWayModeRegionResponse) String() string

func (*ConfigGateWayModeRegionResponse) XXX_DiscardUnknown 

func (m *ConfigGateWayModeRegionResponse) XXX_DiscardUnknown()

func (*ConfigGateWayModeRegionResponse) XXX_Marshal 

func (m *ConfigGateWayModeRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConfigGateWayModeRegionResponse) XXX_Merge 

func (m *ConfigGateWayModeRegionResponse) XXX_Merge(src proto.Message)

func (*ConfigGateWayModeRegionResponse) XXX_Size 

func (m *ConfigGateWayModeRegionResponse) XXX_Size() int

func (*ConfigGateWayModeRegionResponse) XXX_Unmarshal 

func (m *ConfigGateWayModeRegionResponse) XXX_Unmarshal(b []byte) error

type CreateAPIKeyRequest 

type CreateAPIKeyRequest struct {
	// The API key to create.
	ApiKey               *APIKey  `protobuf:"bytes,1,opt,name=api_key,json=apiKey,proto3" json:"api_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateAPIKeyRequest) Descriptor 

func (*CreateAPIKeyRequest) Descriptor() ([]byte, []int)

func (*CreateAPIKeyRequest) GetApiKey 

func (m *CreateAPIKeyRequest) GetApiKey() *APIKey

func (*CreateAPIKeyRequest) ProtoMessage 

func (*CreateAPIKeyRequest) ProtoMessage()

func (*CreateAPIKeyRequest) Reset 

func (m *CreateAPIKeyRequest) Reset()

func (*CreateAPIKeyRequest) String 

func (m *CreateAPIKeyRequest) String() string

func (*CreateAPIKeyRequest) XXX_DiscardUnknown 

func (m *CreateAPIKeyRequest) XXX_DiscardUnknown()

func (*CreateAPIKeyRequest) XXX_Marshal 

func (m *CreateAPIKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateAPIKeyRequest) XXX_Merge 

func (m *CreateAPIKeyRequest) XXX_Merge(src proto.Message)

func (*CreateAPIKeyRequest) XXX_Size 

func (m *CreateAPIKeyRequest) XXX_Size() int

func (*CreateAPIKeyRequest) XXX_Unmarshal 

func (m *CreateAPIKeyRequest) XXX_Unmarshal(b []byte) error

type CreateAPIKeyResponse 

type CreateAPIKeyResponse struct {
	// API key ID.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// JWT token for this API Key.
	JwtToken             string   `protobuf:"bytes,2,opt,name=jwt_token,json=jwtToken,proto3" json:"jwt_token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateAPIKeyResponse) Descriptor 

func (*CreateAPIKeyResponse) Descriptor() ([]byte, []int)

func (*CreateAPIKeyResponse) GetId 

func (m *CreateAPIKeyResponse) GetId() string

func (*CreateAPIKeyResponse) GetJwtToken 

func (m *CreateAPIKeyResponse) GetJwtToken() string

func (*CreateAPIKeyResponse) ProtoMessage 

func (*CreateAPIKeyResponse) ProtoMessage()

func (*CreateAPIKeyResponse) Reset 

func (m *CreateAPIKeyResponse) Reset()

func (*CreateAPIKeyResponse) String 

func (m *CreateAPIKeyResponse) String() string

func (*CreateAPIKeyResponse) XXX_DiscardUnknown 

func (m *CreateAPIKeyResponse) XXX_DiscardUnknown()

func (*CreateAPIKeyResponse) XXX_Marshal 

func (m *CreateAPIKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateAPIKeyResponse) XXX_Merge 

func (m *CreateAPIKeyResponse) XXX_Merge(src proto.Message)

func (*CreateAPIKeyResponse) XXX_Size 

func (m *CreateAPIKeyResponse) XXX_Size() int

func (*CreateAPIKeyResponse) XXX_Unmarshal 

func (m *CreateAPIKeyResponse) XXX_Unmarshal(b []byte) error

type CreateAWSSNSIntegrationRequest 

type CreateAWSSNSIntegrationRequest struct {
	// Integration object to create.
	Integration          *AWSSNSIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*CreateAWSSNSIntegrationRequest) Descriptor 

func (*CreateAWSSNSIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateAWSSNSIntegrationRequest) GetIntegration 

func (m *CreateAWSSNSIntegrationRequest) GetIntegration() *AWSSNSIntegration

func (*CreateAWSSNSIntegrationRequest) ProtoMessage 

func (*CreateAWSSNSIntegrationRequest) ProtoMessage()

func (*CreateAWSSNSIntegrationRequest) Reset 

func (m *CreateAWSSNSIntegrationRequest) Reset()

func (*CreateAWSSNSIntegrationRequest) String 

func (m *CreateAWSSNSIntegrationRequest) String() string

func (*CreateAWSSNSIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateAWSSNSIntegrationRequest) XXX_DiscardUnknown()

func (*CreateAWSSNSIntegrationRequest) XXX_Marshal 

func (m *CreateAWSSNSIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateAWSSNSIntegrationRequest) XXX_Merge 

func (m *CreateAWSSNSIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateAWSSNSIntegrationRequest) XXX_Size 

func (m *CreateAWSSNSIntegrationRequest) XXX_Size() int

func (*CreateAWSSNSIntegrationRequest) XXX_Unmarshal 

func (m *CreateAWSSNSIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateAndActivateABPEnableDeviceRequest 

type CreateAndActivateABPEnableDeviceRequest struct {
	ApplicationId        int64      `protobuf:"varint,3,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	Name                 string     `protobuf:"bytes,1,opt,name=name,json=devName,proto3" json:"name,omitempty"`
	Abp                  *ABPDevice `protobuf:"bytes,2,opt,name=abp,json=ABP,proto3" json:"abp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (*CreateAndActivateABPEnableDeviceRequest) Descriptor 

func (*CreateAndActivateABPEnableDeviceRequest) Descriptor() ([]byte, []int)

func (*CreateAndActivateABPEnableDeviceRequest) GetAbp 

func (m *CreateAndActivateABPEnableDeviceRequest) GetAbp() *ABPDevice

func (*CreateAndActivateABPEnableDeviceRequest) GetApplicationId 

func (m *CreateAndActivateABPEnableDeviceRequest) GetApplicationId() int64

func (*CreateAndActivateABPEnableDeviceRequest) GetName 

func (m *CreateAndActivateABPEnableDeviceRequest) GetName() string

func (*CreateAndActivateABPEnableDeviceRequest) ProtoMessage 

func (*CreateAndActivateABPEnableDeviceRequest) ProtoMessage()

func (*CreateAndActivateABPEnableDeviceRequest) Reset 

func (m *CreateAndActivateABPEnableDeviceRequest) Reset()

func (*CreateAndActivateABPEnableDeviceRequest) String 

func (m *CreateAndActivateABPEnableDeviceRequest) String() string

func (*CreateAndActivateABPEnableDeviceRequest) XXX_DiscardUnknown 

func (m *CreateAndActivateABPEnableDeviceRequest) XXX_DiscardUnknown()

func (*CreateAndActivateABPEnableDeviceRequest) XXX_Marshal 

func (m *CreateAndActivateABPEnableDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateAndActivateABPEnableDeviceRequest) XXX_Merge 

func (m *CreateAndActivateABPEnableDeviceRequest) XXX_Merge(src proto.Message)

func (*CreateAndActivateABPEnableDeviceRequest) XXX_Size 

func (m *CreateAndActivateABPEnableDeviceRequest) XXX_Size() int

func (*CreateAndActivateABPEnableDeviceRequest) XXX_Unmarshal 

func (m *CreateAndActivateABPEnableDeviceRequest) XXX_Unmarshal(b []byte) error

type CreateAndActivateABPEnableDeviceResponse 

type CreateAndActivateABPEnableDeviceResponse struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Status               string   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateAndActivateABPEnableDeviceResponse) Descriptor 

func (*CreateAndActivateABPEnableDeviceResponse) Descriptor() ([]byte, []int)

func (*CreateAndActivateABPEnableDeviceResponse) GetMessage 

func (m *CreateAndActivateABPEnableDeviceResponse) GetMessage() string

func (*CreateAndActivateABPEnableDeviceResponse) GetStatus 

func (m *CreateAndActivateABPEnableDeviceResponse) GetStatus() string

func (*CreateAndActivateABPEnableDeviceResponse) ProtoMessage 

func (*CreateAndActivateABPEnableDeviceResponse) ProtoMessage()

func (*CreateAndActivateABPEnableDeviceResponse) Reset 

func (m *CreateAndActivateABPEnableDeviceResponse) Reset()

func (*CreateAndActivateABPEnableDeviceResponse) String 

func (m *CreateAndActivateABPEnableDeviceResponse) String() string

func (*CreateAndActivateABPEnableDeviceResponse) XXX_DiscardUnknown 

func (m *CreateAndActivateABPEnableDeviceResponse) XXX_DiscardUnknown()

func (*CreateAndActivateABPEnableDeviceResponse) XXX_Marshal 

func (m *CreateAndActivateABPEnableDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateAndActivateABPEnableDeviceResponse) XXX_Merge 

func (m *CreateAndActivateABPEnableDeviceResponse) XXX_Merge(src proto.Message)

func (*CreateAndActivateABPEnableDeviceResponse) XXX_Size 

func (m *CreateAndActivateABPEnableDeviceResponse) XXX_Size() int

func (*CreateAndActivateABPEnableDeviceResponse) XXX_Unmarshal 

func (m *CreateAndActivateABPEnableDeviceResponse) XXX_Unmarshal(b []byte) error

type CreateApplicationRequest 

type CreateApplicationRequest struct {
	// Application object to create.
	Application          *Application `protobuf:"bytes,1,opt,name=application,proto3" json:"application,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (*CreateApplicationRequest) Descriptor 

func (*CreateApplicationRequest) Descriptor() ([]byte, []int)

func (*CreateApplicationRequest) GetApplication 

func (m *CreateApplicationRequest) GetApplication() *Application

func (*CreateApplicationRequest) ProtoMessage 

func (*CreateApplicationRequest) ProtoMessage()

func (*CreateApplicationRequest) Reset 

func (m *CreateApplicationRequest) Reset()

func (*CreateApplicationRequest) String 

func (m *CreateApplicationRequest) String() string

func (*CreateApplicationRequest) XXX_DiscardUnknown 

func (m *CreateApplicationRequest) XXX_DiscardUnknown()

func (*CreateApplicationRequest) XXX_Marshal 

func (m *CreateApplicationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateApplicationRequest) XXX_Merge 

func (m *CreateApplicationRequest) XXX_Merge(src proto.Message)

func (*CreateApplicationRequest) XXX_Size 

func (m *CreateApplicationRequest) XXX_Size() int

func (*CreateApplicationRequest) XXX_Unmarshal 

func (m *CreateApplicationRequest) XXX_Unmarshal(b []byte) error

type CreateApplicationResponse 

type CreateApplicationResponse struct {
	// Application ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateApplicationResponse) Descriptor 

func (*CreateApplicationResponse) Descriptor() ([]byte, []int)

func (*CreateApplicationResponse) GetId 

func (m *CreateApplicationResponse) GetId() int64

func (*CreateApplicationResponse) ProtoMessage 

func (*CreateApplicationResponse) ProtoMessage()

func (*CreateApplicationResponse) Reset 

func (m *CreateApplicationResponse) Reset()

func (*CreateApplicationResponse) String 

func (m *CreateApplicationResponse) String() string

func (*CreateApplicationResponse) XXX_DiscardUnknown 

func (m *CreateApplicationResponse) XXX_DiscardUnknown()

func (*CreateApplicationResponse) XXX_Marshal 

func (m *CreateApplicationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateApplicationResponse) XXX_Merge 

func (m *CreateApplicationResponse) XXX_Merge(src proto.Message)

func (*CreateApplicationResponse) XXX_Size 

func (m *CreateApplicationResponse) XXX_Size() int

func (*CreateApplicationResponse) XXX_Unmarshal 

func (m *CreateApplicationResponse) XXX_Unmarshal(b []byte) error

type CreateAzureServiceBusIntegrationRequest 

type CreateAzureServiceBusIntegrationRequest struct {
	// Integration object to create.
	Integration          *AzureServiceBusIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (*CreateAzureServiceBusIntegrationRequest) Descriptor 

func (*CreateAzureServiceBusIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateAzureServiceBusIntegrationRequest) GetIntegration 

func (m *CreateAzureServiceBusIntegrationRequest) GetIntegration() *AzureServiceBusIntegration

func (*CreateAzureServiceBusIntegrationRequest) ProtoMessage 

func (*CreateAzureServiceBusIntegrationRequest) ProtoMessage()

func (*CreateAzureServiceBusIntegrationRequest) Reset 

func (m *CreateAzureServiceBusIntegrationRequest) Reset()

func (*CreateAzureServiceBusIntegrationRequest) String 

func (m *CreateAzureServiceBusIntegrationRequest) String() string

func (*CreateAzureServiceBusIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateAzureServiceBusIntegrationRequest) XXX_DiscardUnknown()

func (*CreateAzureServiceBusIntegrationRequest) XXX_Marshal 

func (m *CreateAzureServiceBusIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateAzureServiceBusIntegrationRequest) XXX_Merge 

func (m *CreateAzureServiceBusIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateAzureServiceBusIntegrationRequest) XXX_Size 

func (m *CreateAzureServiceBusIntegrationRequest) XXX_Size() int

func (*CreateAzureServiceBusIntegrationRequest) XXX_Unmarshal 

func (m *CreateAzureServiceBusIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateDeviceKeysRequest 

type CreateDeviceKeysRequest struct {
	// Device-keys object to create.
	DeviceKeys           *DeviceKeys `protobuf:"bytes,1,opt,name=device_keys,json=deviceKeys,proto3" json:"device_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*CreateDeviceKeysRequest) Descriptor 

func (*CreateDeviceKeysRequest) Descriptor() ([]byte, []int)

func (*CreateDeviceKeysRequest) GetDeviceKeys 

func (m *CreateDeviceKeysRequest) GetDeviceKeys() *DeviceKeys

func (*CreateDeviceKeysRequest) ProtoMessage 

func (*CreateDeviceKeysRequest) ProtoMessage()

func (*CreateDeviceKeysRequest) Reset 

func (m *CreateDeviceKeysRequest) Reset()

func (*CreateDeviceKeysRequest) String 

func (m *CreateDeviceKeysRequest) String() string

func (*CreateDeviceKeysRequest) XXX_DiscardUnknown 

func (m *CreateDeviceKeysRequest) XXX_DiscardUnknown()

func (*CreateDeviceKeysRequest) XXX_Marshal 

func (m *CreateDeviceKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateDeviceKeysRequest) XXX_Merge 

func (m *CreateDeviceKeysRequest) XXX_Merge(src proto.Message)

func (*CreateDeviceKeysRequest) XXX_Size 

func (m *CreateDeviceKeysRequest) XXX_Size() int

func (*CreateDeviceKeysRequest) XXX_Unmarshal 

func (m *CreateDeviceKeysRequest) XXX_Unmarshal(b []byte) error

type CreateDeviceProfileRequest 

type CreateDeviceProfileRequest struct {
	// Device-profile object to create.
	DeviceProfile        *DeviceProfile `protobuf:"bytes,1,opt,name=device_profile,json=deviceProfile,proto3" json:"device_profile,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*CreateDeviceProfileRequest) Descriptor 

func (*CreateDeviceProfileRequest) Descriptor() ([]byte, []int)

func (*CreateDeviceProfileRequest) GetDeviceProfile 

func (m *CreateDeviceProfileRequest) GetDeviceProfile() *DeviceProfile

func (*CreateDeviceProfileRequest) ProtoMessage 

func (*CreateDeviceProfileRequest) ProtoMessage()

func (*CreateDeviceProfileRequest) Reset 

func (m *CreateDeviceProfileRequest) Reset()

func (*CreateDeviceProfileRequest) String 

func (m *CreateDeviceProfileRequest) String() string

func (*CreateDeviceProfileRequest) XXX_DiscardUnknown 

func (m *CreateDeviceProfileRequest) XXX_DiscardUnknown()

func (*CreateDeviceProfileRequest) XXX_Marshal 

func (m *CreateDeviceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateDeviceProfileRequest) XXX_Merge 

func (m *CreateDeviceProfileRequest) XXX_Merge(src proto.Message)

func (*CreateDeviceProfileRequest) XXX_Size 

func (m *CreateDeviceProfileRequest) XXX_Size() int

func (*CreateDeviceProfileRequest) XXX_Unmarshal 

func (m *CreateDeviceProfileRequest) XXX_Unmarshal(b []byte) error

type CreateDeviceProfileResponse 

type CreateDeviceProfileResponse struct {
	// Device-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateDeviceProfileResponse) Descriptor 

func (*CreateDeviceProfileResponse) Descriptor() ([]byte, []int)

func (*CreateDeviceProfileResponse) GetId 

func (m *CreateDeviceProfileResponse) GetId() string

func (*CreateDeviceProfileResponse) ProtoMessage 

func (*CreateDeviceProfileResponse) ProtoMessage()

func (*CreateDeviceProfileResponse) Reset 

func (m *CreateDeviceProfileResponse) Reset()

func (*CreateDeviceProfileResponse) String 

func (m *CreateDeviceProfileResponse) String() string

func (*CreateDeviceProfileResponse) XXX_DiscardUnknown 

func (m *CreateDeviceProfileResponse) XXX_DiscardUnknown()

func (*CreateDeviceProfileResponse) XXX_Marshal 

func (m *CreateDeviceProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateDeviceProfileResponse) XXX_Merge 

func (m *CreateDeviceProfileResponse) XXX_Merge(src proto.Message)

func (*CreateDeviceProfileResponse) XXX_Size 

func (m *CreateDeviceProfileResponse) XXX_Size() int

func (*CreateDeviceProfileResponse) XXX_Unmarshal 

func (m *CreateDeviceProfileResponse) XXX_Unmarshal(b []byte) error

type CreateDeviceRequest 

type CreateDeviceRequest struct {
	// Device object to create.
	//
	// Types that are valid to be assigned to AddDevice:
	//
	//	*CreateDeviceRequest_Device
	//	*CreateDeviceRequest_Otaa
	//	*CreateDeviceRequest_Abp
	//	*CreateDeviceRequest_Csv
	//	*CreateDeviceRequest_Camera
	AddDevice            isCreateDeviceRequest_AddDevice `protobuf_oneof:"addDevice"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

func (*CreateDeviceRequest) Descriptor 

func (*CreateDeviceRequest) Descriptor() ([]byte, []int)

func (*CreateDeviceRequest) GetAbp 

func (m *CreateDeviceRequest) GetAbp() *ABPDevice

func (*CreateDeviceRequest) GetAddDevice 

func (m *CreateDeviceRequest) GetAddDevice() isCreateDeviceRequest_AddDevice

func (*CreateDeviceRequest) GetCamera 

func (m *CreateDeviceRequest) GetCamera() *CameraAdd

func (*CreateDeviceRequest) GetCsv 

func (m *CreateDeviceRequest) GetCsv() *CSVAdd

func (*CreateDeviceRequest) GetDevice 

func (m *CreateDeviceRequest) GetDevice() *Device

func (*CreateDeviceRequest) GetOtaa 

func (m *CreateDeviceRequest) GetOtaa() *OTAADevice

func (*CreateDeviceRequest) ProtoMessage 

func (*CreateDeviceRequest) ProtoMessage()

func (*CreateDeviceRequest) Reset 

func (m *CreateDeviceRequest) Reset()

func (*CreateDeviceRequest) String 

func (m *CreateDeviceRequest) String() string

func (*CreateDeviceRequest) XXX_DiscardUnknown 

func (m *CreateDeviceRequest) XXX_DiscardUnknown()

func (*CreateDeviceRequest) XXX_Marshal 

func (m *CreateDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateDeviceRequest) XXX_Merge 

func (m *CreateDeviceRequest) XXX_Merge(src proto.Message)

func (*CreateDeviceRequest) XXX_OneofWrappers 

func (*CreateDeviceRequest) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*CreateDeviceRequest) XXX_Size 

func (m *CreateDeviceRequest) XXX_Size() int

func (*CreateDeviceRequest) XXX_Unmarshal 

func (m *CreateDeviceRequest) XXX_Unmarshal(b []byte) error

type CreateDeviceRequest_Abp 

type CreateDeviceRequest_Abp struct {
	Abp *ABPDevice `protobuf:"bytes,3,opt,name=abp,json=ABP,proto3,oneof"`
}

type CreateDeviceRequest_Camera 

type CreateDeviceRequest_Camera struct {
	Camera *CameraAdd `protobuf:"bytes,5,opt,name=camera,proto3,oneof"`
}

type CreateDeviceRequest_Csv 

type CreateDeviceRequest_Csv struct {
	Csv *CSVAdd `protobuf:"bytes,4,opt,name=csv,proto3,oneof"`
}

type CreateDeviceRequest_Device 

type CreateDeviceRequest_Device struct {
	Device *Device `protobuf:"bytes,1,opt,name=device,proto3,oneof"`
}

type CreateDeviceRequest_Otaa 

type CreateDeviceRequest_Otaa struct {
	Otaa *OTAADevice `protobuf:"bytes,2,opt,name=otaa,json=OTAA,proto3,oneof"`
}

type CreateDeviceResponse 

type CreateDeviceResponse struct {
	// Device object to create.
	Empty                *emptypb.Empty `protobuf:"bytes,1,opt,name=empty,proto3" json:"empty,omitempty"`
	Message              string         `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Status               string         `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*CreateDeviceResponse) Descriptor 

func (*CreateDeviceResponse) Descriptor() ([]byte, []int)

func (*CreateDeviceResponse) GetEmpty 

func (m *CreateDeviceResponse) GetEmpty() *emptypb.Empty

func (*CreateDeviceResponse) GetMessage 

func (m *CreateDeviceResponse) GetMessage() string

func (*CreateDeviceResponse) GetStatus 

func (m *CreateDeviceResponse) GetStatus() string

func (*CreateDeviceResponse) ProtoMessage 

func (*CreateDeviceResponse) ProtoMessage()

func (*CreateDeviceResponse) Reset 

func (m *CreateDeviceResponse) Reset()

func (*CreateDeviceResponse) String 

func (m *CreateDeviceResponse) String() string

func (*CreateDeviceResponse) XXX_DiscardUnknown 

func (m *CreateDeviceResponse) XXX_DiscardUnknown()

func (*CreateDeviceResponse) XXX_Marshal 

func (m *CreateDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateDeviceResponse) XXX_Merge 

func (m *CreateDeviceResponse) XXX_Merge(src proto.Message)

func (*CreateDeviceResponse) XXX_Size 

func (m *CreateDeviceResponse) XXX_Size() int

func (*CreateDeviceResponse) XXX_Unmarshal 

func (m *CreateDeviceResponse) XXX_Unmarshal(b []byte) error

type CreateFUOTADeploymentForDeviceRequest 

type CreateFUOTADeploymentForDeviceRequest struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// FUOTA deployment.
	FuotaDeployment      *FUOTADeployment `protobuf:"bytes,2,opt,name=fuota_deployment,json=fuotaDeployment,proto3" json:"fuota_deployment,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*CreateFUOTADeploymentForDeviceRequest) Descriptor 

func (*CreateFUOTADeploymentForDeviceRequest) Descriptor() ([]byte, []int)

func (*CreateFUOTADeploymentForDeviceRequest) GetDevEui 

func (m *CreateFUOTADeploymentForDeviceRequest) GetDevEui() string

func (*CreateFUOTADeploymentForDeviceRequest) GetFuotaDeployment 

func (m *CreateFUOTADeploymentForDeviceRequest) GetFuotaDeployment() *FUOTADeployment

func (*CreateFUOTADeploymentForDeviceRequest) ProtoMessage 

func (*CreateFUOTADeploymentForDeviceRequest) ProtoMessage()

func (*CreateFUOTADeploymentForDeviceRequest) Reset 

func (m *CreateFUOTADeploymentForDeviceRequest) Reset()

func (*CreateFUOTADeploymentForDeviceRequest) String 

func (m *CreateFUOTADeploymentForDeviceRequest) String() string

func (*CreateFUOTADeploymentForDeviceRequest) XXX_DiscardUnknown 

func (m *CreateFUOTADeploymentForDeviceRequest) XXX_DiscardUnknown()

func (*CreateFUOTADeploymentForDeviceRequest) XXX_Marshal 

func (m *CreateFUOTADeploymentForDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateFUOTADeploymentForDeviceRequest) XXX_Merge 

func (m *CreateFUOTADeploymentForDeviceRequest) XXX_Merge(src proto.Message)

func (*CreateFUOTADeploymentForDeviceRequest) XXX_Size 

func (m *CreateFUOTADeploymentForDeviceRequest) XXX_Size() int

func (*CreateFUOTADeploymentForDeviceRequest) XXX_Unmarshal 

func (m *CreateFUOTADeploymentForDeviceRequest) XXX_Unmarshal(b []byte) error

type CreateFUOTADeploymentForDeviceResponse 

type CreateFUOTADeploymentForDeviceResponse struct {
	// ID of the created deployment (string formatted UUID).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateFUOTADeploymentForDeviceResponse) Descriptor 

func (*CreateFUOTADeploymentForDeviceResponse) Descriptor() ([]byte, []int)

func (*CreateFUOTADeploymentForDeviceResponse) GetId 

func (m *CreateFUOTADeploymentForDeviceResponse) GetId() string

func (*CreateFUOTADeploymentForDeviceResponse) ProtoMessage 

func (*CreateFUOTADeploymentForDeviceResponse) ProtoMessage()

func (*CreateFUOTADeploymentForDeviceResponse) Reset 

func (m *CreateFUOTADeploymentForDeviceResponse) Reset()

func (*CreateFUOTADeploymentForDeviceResponse) String 

func (m *CreateFUOTADeploymentForDeviceResponse) String() string

func (*CreateFUOTADeploymentForDeviceResponse) XXX_DiscardUnknown 

func (m *CreateFUOTADeploymentForDeviceResponse) XXX_DiscardUnknown()

func (*CreateFUOTADeploymentForDeviceResponse) XXX_Marshal 

func (m *CreateFUOTADeploymentForDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateFUOTADeploymentForDeviceResponse) XXX_Merge 

func (m *CreateFUOTADeploymentForDeviceResponse) XXX_Merge(src proto.Message)

func (*CreateFUOTADeploymentForDeviceResponse) XXX_Size 

func (m *CreateFUOTADeploymentForDeviceResponse) XXX_Size() int

func (*CreateFUOTADeploymentForDeviceResponse) XXX_Unmarshal 

func (m *CreateFUOTADeploymentForDeviceResponse) XXX_Unmarshal(b []byte) error

type CreateGCPPubSubIntegrationRequest 

type CreateGCPPubSubIntegrationRequest struct {
	// Integration object to create.
	Integration          *GCPPubSubIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*CreateGCPPubSubIntegrationRequest) Descriptor 

func (*CreateGCPPubSubIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateGCPPubSubIntegrationRequest) GetIntegration 

func (m *CreateGCPPubSubIntegrationRequest) GetIntegration() *GCPPubSubIntegration

func (*CreateGCPPubSubIntegrationRequest) ProtoMessage 

func (*CreateGCPPubSubIntegrationRequest) ProtoMessage()

func (*CreateGCPPubSubIntegrationRequest) Reset 

func (m *CreateGCPPubSubIntegrationRequest) Reset()

func (*CreateGCPPubSubIntegrationRequest) String 

func (m *CreateGCPPubSubIntegrationRequest) String() string

func (*CreateGCPPubSubIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateGCPPubSubIntegrationRequest) XXX_DiscardUnknown()

func (*CreateGCPPubSubIntegrationRequest) XXX_Marshal 

func (m *CreateGCPPubSubIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateGCPPubSubIntegrationRequest) XXX_Merge 

func (m *CreateGCPPubSubIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateGCPPubSubIntegrationRequest) XXX_Size 

func (m *CreateGCPPubSubIntegrationRequest) XXX_Size() int

func (*CreateGCPPubSubIntegrationRequest) XXX_Unmarshal 

func (m *CreateGCPPubSubIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateGatewayProfileRequest 

type CreateGatewayProfileRequest struct {
	// Gateway-profile object to create.
	GatewayProfile       *GatewayProfile `protobuf:"bytes,1,opt,name=gateway_profile,json=gatewayProfile,proto3" json:"gateway_profile,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*CreateGatewayProfileRequest) Descriptor 

func (*CreateGatewayProfileRequest) Descriptor() ([]byte, []int)

func (*CreateGatewayProfileRequest) GetGatewayProfile 

func (m *CreateGatewayProfileRequest) GetGatewayProfile() *GatewayProfile

func (*CreateGatewayProfileRequest) ProtoMessage 

func (*CreateGatewayProfileRequest) ProtoMessage()

func (*CreateGatewayProfileRequest) Reset 

func (m *CreateGatewayProfileRequest) Reset()

func (*CreateGatewayProfileRequest) String 

func (m *CreateGatewayProfileRequest) String() string

func (*CreateGatewayProfileRequest) XXX_DiscardUnknown 

func (m *CreateGatewayProfileRequest) XXX_DiscardUnknown()

func (*CreateGatewayProfileRequest) XXX_Marshal 

func (m *CreateGatewayProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateGatewayProfileRequest) XXX_Merge 

func (m *CreateGatewayProfileRequest) XXX_Merge(src proto.Message)

func (*CreateGatewayProfileRequest) XXX_Size 

func (m *CreateGatewayProfileRequest) XXX_Size() int

func (*CreateGatewayProfileRequest) XXX_Unmarshal 

func (m *CreateGatewayProfileRequest) XXX_Unmarshal(b []byte) error

type CreateGatewayProfileResponse 

type CreateGatewayProfileResponse struct {
	// Gateway-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateGatewayProfileResponse) Descriptor 

func (*CreateGatewayProfileResponse) Descriptor() ([]byte, []int)

func (*CreateGatewayProfileResponse) GetId 

func (m *CreateGatewayProfileResponse) GetId() string

func (*CreateGatewayProfileResponse) ProtoMessage 

func (*CreateGatewayProfileResponse) ProtoMessage()

func (*CreateGatewayProfileResponse) Reset 

func (m *CreateGatewayProfileResponse) Reset()

func (*CreateGatewayProfileResponse) String 

func (m *CreateGatewayProfileResponse) String() string

func (*CreateGatewayProfileResponse) XXX_DiscardUnknown 

func (m *CreateGatewayProfileResponse) XXX_DiscardUnknown()

func (*CreateGatewayProfileResponse) XXX_Marshal 

func (m *CreateGatewayProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateGatewayProfileResponse) XXX_Merge 

func (m *CreateGatewayProfileResponse) XXX_Merge(src proto.Message)

func (*CreateGatewayProfileResponse) XXX_Size 

func (m *CreateGatewayProfileResponse) XXX_Size() int

func (*CreateGatewayProfileResponse) XXX_Unmarshal 

func (m *CreateGatewayProfileResponse) XXX_Unmarshal(b []byte) error

type CreateGatewayRequest 

type CreateGatewayRequest struct {
	// Gateway object to create.
	Gateway              *Gateway `protobuf:"bytes,1,opt,name=gateway,proto3" json:"gateway,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateGatewayRequest) Descriptor 

func (*CreateGatewayRequest) Descriptor() ([]byte, []int)

func (*CreateGatewayRequest) GetGateway 

func (m *CreateGatewayRequest) GetGateway() *Gateway

func (*CreateGatewayRequest) ProtoMessage 

func (*CreateGatewayRequest) ProtoMessage()

func (*CreateGatewayRequest) Reset 

func (m *CreateGatewayRequest) Reset()

func (*CreateGatewayRequest) String 

func (m *CreateGatewayRequest) String() string

func (*CreateGatewayRequest) XXX_DiscardUnknown 

func (m *CreateGatewayRequest) XXX_DiscardUnknown()

func (*CreateGatewayRequest) XXX_Marshal 

func (m *CreateGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateGatewayRequest) XXX_Merge 

func (m *CreateGatewayRequest) XXX_Merge(src proto.Message)

func (*CreateGatewayRequest) XXX_Size 

func (m *CreateGatewayRequest) XXX_Size() int

func (*CreateGatewayRequest) XXX_Unmarshal 

func (m *CreateGatewayRequest) XXX_Unmarshal(b []byte) error

type CreateHTTPIntegrationRequest 

type CreateHTTPIntegrationRequest struct {
	// Integration object to create.
	Integration          *HTTPIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*CreateHTTPIntegrationRequest) Descriptor 

func (*CreateHTTPIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateHTTPIntegrationRequest) GetIntegration 

func (m *CreateHTTPIntegrationRequest) GetIntegration() *HTTPIntegration

func (*CreateHTTPIntegrationRequest) ProtoMessage 

func (*CreateHTTPIntegrationRequest) ProtoMessage()

func (*CreateHTTPIntegrationRequest) Reset 

func (m *CreateHTTPIntegrationRequest) Reset()

func (*CreateHTTPIntegrationRequest) String 

func (m *CreateHTTPIntegrationRequest) String() string

func (*CreateHTTPIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateHTTPIntegrationRequest) XXX_DiscardUnknown()

func (*CreateHTTPIntegrationRequest) XXX_Marshal 

func (m *CreateHTTPIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateHTTPIntegrationRequest) XXX_Merge 

func (m *CreateHTTPIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateHTTPIntegrationRequest) XXX_Size 

func (m *CreateHTTPIntegrationRequest) XXX_Size() int

func (*CreateHTTPIntegrationRequest) XXX_Unmarshal 

func (m *CreateHTTPIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateInfluxDBIntegrationRequest 

type CreateInfluxDBIntegrationRequest struct {
	// Integration object to create.
	Integration          *InfluxDBIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*CreateInfluxDBIntegrationRequest) Descriptor 

func (*CreateInfluxDBIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateInfluxDBIntegrationRequest) GetIntegration 

func (m *CreateInfluxDBIntegrationRequest) GetIntegration() *InfluxDBIntegration

func (*CreateInfluxDBIntegrationRequest) ProtoMessage 

func (*CreateInfluxDBIntegrationRequest) ProtoMessage()

func (*CreateInfluxDBIntegrationRequest) Reset 

func (m *CreateInfluxDBIntegrationRequest) Reset()

func (*CreateInfluxDBIntegrationRequest) String 

func (m *CreateInfluxDBIntegrationRequest) String() string

func (*CreateInfluxDBIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateInfluxDBIntegrationRequest) XXX_DiscardUnknown()

func (*CreateInfluxDBIntegrationRequest) XXX_Marshal 

func (m *CreateInfluxDBIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateInfluxDBIntegrationRequest) XXX_Merge 

func (m *CreateInfluxDBIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateInfluxDBIntegrationRequest) XXX_Size 

func (m *CreateInfluxDBIntegrationRequest) XXX_Size() int

func (*CreateInfluxDBIntegrationRequest) XXX_Unmarshal 

func (m *CreateInfluxDBIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateLoRaCloudIntegrationRequest 

type CreateLoRaCloudIntegrationRequest struct {
	// Integration object to create.
	Integration          *LoRaCloudIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*CreateLoRaCloudIntegrationRequest) Descriptor 

func (*CreateLoRaCloudIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateLoRaCloudIntegrationRequest) GetIntegration 

func (m *CreateLoRaCloudIntegrationRequest) GetIntegration() *LoRaCloudIntegration

func (*CreateLoRaCloudIntegrationRequest) ProtoMessage 

func (*CreateLoRaCloudIntegrationRequest) ProtoMessage()

func (*CreateLoRaCloudIntegrationRequest) Reset 

func (m *CreateLoRaCloudIntegrationRequest) Reset()

func (*CreateLoRaCloudIntegrationRequest) String 

func (m *CreateLoRaCloudIntegrationRequest) String() string

func (*CreateLoRaCloudIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateLoRaCloudIntegrationRequest) XXX_DiscardUnknown()

func (*CreateLoRaCloudIntegrationRequest) XXX_Marshal 

func (m *CreateLoRaCloudIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateLoRaCloudIntegrationRequest) XXX_Merge 

func (m *CreateLoRaCloudIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateLoRaCloudIntegrationRequest) XXX_Size 

func (m *CreateLoRaCloudIntegrationRequest) XXX_Size() int

func (*CreateLoRaCloudIntegrationRequest) XXX_Unmarshal 

func (m *CreateLoRaCloudIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateMulticastGroupRequest 

type CreateMulticastGroupRequest struct {
	// Multicast-group object to create.
	MulticastGroup       *MulticastGroup `protobuf:"bytes,1,opt,name=multicast_group,json=multicastGroup,proto3" json:"multicast_group,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*CreateMulticastGroupRequest) Descriptor 

func (*CreateMulticastGroupRequest) Descriptor() ([]byte, []int)

func (*CreateMulticastGroupRequest) GetMulticastGroup 

func (m *CreateMulticastGroupRequest) GetMulticastGroup() *MulticastGroup

func (*CreateMulticastGroupRequest) ProtoMessage 

func (*CreateMulticastGroupRequest) ProtoMessage()

func (*CreateMulticastGroupRequest) Reset 

func (m *CreateMulticastGroupRequest) Reset()

func (*CreateMulticastGroupRequest) String 

func (m *CreateMulticastGroupRequest) String() string

func (*CreateMulticastGroupRequest) XXX_DiscardUnknown 

func (m *CreateMulticastGroupRequest) XXX_DiscardUnknown()

func (*CreateMulticastGroupRequest) XXX_Marshal 

func (m *CreateMulticastGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateMulticastGroupRequest) XXX_Merge 

func (m *CreateMulticastGroupRequest) XXX_Merge(src proto.Message)

func (*CreateMulticastGroupRequest) XXX_Size 

func (m *CreateMulticastGroupRequest) XXX_Size() int

func (*CreateMulticastGroupRequest) XXX_Unmarshal 

func (m *CreateMulticastGroupRequest) XXX_Unmarshal(b []byte) error

type CreateMulticastGroupResponse 

type CreateMulticastGroupResponse struct {
	// ID of created group (string formatted UUID).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateMulticastGroupResponse) Descriptor 

func (*CreateMulticastGroupResponse) Descriptor() ([]byte, []int)

func (*CreateMulticastGroupResponse) GetId 

func (m *CreateMulticastGroupResponse) GetId() string

func (*CreateMulticastGroupResponse) ProtoMessage 

func (*CreateMulticastGroupResponse) ProtoMessage()

func (*CreateMulticastGroupResponse) Reset 

func (m *CreateMulticastGroupResponse) Reset()

func (*CreateMulticastGroupResponse) String 

func (m *CreateMulticastGroupResponse) String() string

func (*CreateMulticastGroupResponse) XXX_DiscardUnknown 

func (m *CreateMulticastGroupResponse) XXX_DiscardUnknown()

func (*CreateMulticastGroupResponse) XXX_Marshal 

func (m *CreateMulticastGroupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateMulticastGroupResponse) XXX_Merge 

func (m *CreateMulticastGroupResponse) XXX_Merge(src proto.Message)

func (*CreateMulticastGroupResponse) XXX_Size 

func (m *CreateMulticastGroupResponse) XXX_Size() int

func (*CreateMulticastGroupResponse) XXX_Unmarshal 

func (m *CreateMulticastGroupResponse) XXX_Unmarshal(b []byte) error

type CreateMyDevicesIntegrationRequest 

type CreateMyDevicesIntegrationRequest struct {
	// Integration object to create.
	Integration          *MyDevicesIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*CreateMyDevicesIntegrationRequest) Descriptor 

func (*CreateMyDevicesIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateMyDevicesIntegrationRequest) GetIntegration 

func (m *CreateMyDevicesIntegrationRequest) GetIntegration() *MyDevicesIntegration

func (*CreateMyDevicesIntegrationRequest) ProtoMessage 

func (*CreateMyDevicesIntegrationRequest) ProtoMessage()

func (*CreateMyDevicesIntegrationRequest) Reset 

func (m *CreateMyDevicesIntegrationRequest) Reset()

func (*CreateMyDevicesIntegrationRequest) String 

func (m *CreateMyDevicesIntegrationRequest) String() string

func (*CreateMyDevicesIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateMyDevicesIntegrationRequest) XXX_DiscardUnknown()

func (*CreateMyDevicesIntegrationRequest) XXX_Marshal 

func (m *CreateMyDevicesIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateMyDevicesIntegrationRequest) XXX_Merge 

func (m *CreateMyDevicesIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateMyDevicesIntegrationRequest) XXX_Size 

func (m *CreateMyDevicesIntegrationRequest) XXX_Size() int

func (*CreateMyDevicesIntegrationRequest) XXX_Unmarshal 

func (m *CreateMyDevicesIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateNetworkServerRequest 

type CreateNetworkServerRequest struct {
	// Network-server object to create.
	NetworkServer        *NetworkServer `protobuf:"bytes,1,opt,name=network_server,json=networkServer,proto3" json:"network_server,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*CreateNetworkServerRequest) Descriptor 

func (*CreateNetworkServerRequest) Descriptor() ([]byte, []int)

func (*CreateNetworkServerRequest) GetNetworkServer 

func (m *CreateNetworkServerRequest) GetNetworkServer() *NetworkServer

func (*CreateNetworkServerRequest) ProtoMessage 

func (*CreateNetworkServerRequest) ProtoMessage()

func (*CreateNetworkServerRequest) Reset 

func (m *CreateNetworkServerRequest) Reset()

func (*CreateNetworkServerRequest) String 

func (m *CreateNetworkServerRequest) String() string

func (*CreateNetworkServerRequest) XXX_DiscardUnknown 

func (m *CreateNetworkServerRequest) XXX_DiscardUnknown()

func (*CreateNetworkServerRequest) XXX_Marshal 

func (m *CreateNetworkServerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateNetworkServerRequest) XXX_Merge 

func (m *CreateNetworkServerRequest) XXX_Merge(src proto.Message)

func (*CreateNetworkServerRequest) XXX_Size 

func (m *CreateNetworkServerRequest) XXX_Size() int

func (*CreateNetworkServerRequest) XXX_Unmarshal 

func (m *CreateNetworkServerRequest) XXX_Unmarshal(b []byte) error

type CreateNetworkServerResponse 

type CreateNetworkServerResponse struct {
	// Network-server ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateNetworkServerResponse) Descriptor 

func (*CreateNetworkServerResponse) Descriptor() ([]byte, []int)

func (*CreateNetworkServerResponse) GetId 

func (m *CreateNetworkServerResponse) GetId() int64

func (*CreateNetworkServerResponse) ProtoMessage 

func (*CreateNetworkServerResponse) ProtoMessage()

func (*CreateNetworkServerResponse) Reset 

func (m *CreateNetworkServerResponse) Reset()

func (*CreateNetworkServerResponse) String 

func (m *CreateNetworkServerResponse) String() string

func (*CreateNetworkServerResponse) XXX_DiscardUnknown 

func (m *CreateNetworkServerResponse) XXX_DiscardUnknown()

func (*CreateNetworkServerResponse) XXX_Marshal 

func (m *CreateNetworkServerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateNetworkServerResponse) XXX_Merge 

func (m *CreateNetworkServerResponse) XXX_Merge(src proto.Message)

func (*CreateNetworkServerResponse) XXX_Size 

func (m *CreateNetworkServerResponse) XXX_Size() int

func (*CreateNetworkServerResponse) XXX_Unmarshal 

func (m *CreateNetworkServerResponse) XXX_Unmarshal(b []byte) error

type CreateOTAAEnableDeviceAndKeyRequest 

type CreateOTAAEnableDeviceAndKeyRequest struct {
	ApplicationId        int64       `protobuf:"varint,3,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	Name                 string      `protobuf:"bytes,1,opt,name=name,json=devName,proto3" json:"name,omitempty"`
	Otaa                 *OTAADevice `protobuf:"bytes,2,opt,name=otaa,json=OTAA,proto3" json:"otaa,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*CreateOTAAEnableDeviceAndKeyRequest) Descriptor 

func (*CreateOTAAEnableDeviceAndKeyRequest) Descriptor() ([]byte, []int)

func (*CreateOTAAEnableDeviceAndKeyRequest) GetApplicationId 

func (m *CreateOTAAEnableDeviceAndKeyRequest) GetApplicationId() int64

func (*CreateOTAAEnableDeviceAndKeyRequest) GetName 

func (m *CreateOTAAEnableDeviceAndKeyRequest) GetName() string

func (*CreateOTAAEnableDeviceAndKeyRequest) GetOtaa 

func (m *CreateOTAAEnableDeviceAndKeyRequest) GetOtaa() *OTAADevice

func (*CreateOTAAEnableDeviceAndKeyRequest) ProtoMessage 

func (*CreateOTAAEnableDeviceAndKeyRequest) ProtoMessage()

func (*CreateOTAAEnableDeviceAndKeyRequest) Reset 

func (m *CreateOTAAEnableDeviceAndKeyRequest) Reset()

func (*CreateOTAAEnableDeviceAndKeyRequest) String 

func (m *CreateOTAAEnableDeviceAndKeyRequest) String() string

func (*CreateOTAAEnableDeviceAndKeyRequest) XXX_DiscardUnknown 

func (m *CreateOTAAEnableDeviceAndKeyRequest) XXX_DiscardUnknown()

func (*CreateOTAAEnableDeviceAndKeyRequest) XXX_Marshal 

func (m *CreateOTAAEnableDeviceAndKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateOTAAEnableDeviceAndKeyRequest) XXX_Merge 

func (m *CreateOTAAEnableDeviceAndKeyRequest) XXX_Merge(src proto.Message)

func (*CreateOTAAEnableDeviceAndKeyRequest) XXX_Size 

func (m *CreateOTAAEnableDeviceAndKeyRequest) XXX_Size() int

func (*CreateOTAAEnableDeviceAndKeyRequest) XXX_Unmarshal 

func (m *CreateOTAAEnableDeviceAndKeyRequest) XXX_Unmarshal(b []byte) error

type CreateOTAAEnableDeviceAndKeyResponse 

type CreateOTAAEnableDeviceAndKeyResponse struct {
	Message              string   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Status               string   `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateOTAAEnableDeviceAndKeyResponse) Descriptor 

func (*CreateOTAAEnableDeviceAndKeyResponse) Descriptor() ([]byte, []int)

func (*CreateOTAAEnableDeviceAndKeyResponse) GetMessage 

func (m *CreateOTAAEnableDeviceAndKeyResponse) GetMessage() string

func (*CreateOTAAEnableDeviceAndKeyResponse) GetStatus 

func (m *CreateOTAAEnableDeviceAndKeyResponse) GetStatus() string

func (*CreateOTAAEnableDeviceAndKeyResponse) ProtoMessage 

func (*CreateOTAAEnableDeviceAndKeyResponse) ProtoMessage()

func (*CreateOTAAEnableDeviceAndKeyResponse) Reset 

func (m *CreateOTAAEnableDeviceAndKeyResponse) Reset()

func (*CreateOTAAEnableDeviceAndKeyResponse) String 

func (m *CreateOTAAEnableDeviceAndKeyResponse) String() string

func (*CreateOTAAEnableDeviceAndKeyResponse) XXX_DiscardUnknown 

func (m *CreateOTAAEnableDeviceAndKeyResponse) XXX_DiscardUnknown()

func (*CreateOTAAEnableDeviceAndKeyResponse) XXX_Marshal 

func (m *CreateOTAAEnableDeviceAndKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateOTAAEnableDeviceAndKeyResponse) XXX_Merge 

func (m *CreateOTAAEnableDeviceAndKeyResponse) XXX_Merge(src proto.Message)

func (*CreateOTAAEnableDeviceAndKeyResponse) XXX_Size 

func (m *CreateOTAAEnableDeviceAndKeyResponse) XXX_Size() int

func (*CreateOTAAEnableDeviceAndKeyResponse) XXX_Unmarshal 

func (m *CreateOTAAEnableDeviceAndKeyResponse) XXX_Unmarshal(b []byte) error

type CreateOrganizationRequest 

type CreateOrganizationRequest struct {
	// Organization object to create.
	Organization         *Organization `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (*CreateOrganizationRequest) Descriptor 

func (*CreateOrganizationRequest) Descriptor() ([]byte, []int)

func (*CreateOrganizationRequest) GetOrganization 

func (m *CreateOrganizationRequest) GetOrganization() *Organization

func (*CreateOrganizationRequest) ProtoMessage 

func (*CreateOrganizationRequest) ProtoMessage()

func (*CreateOrganizationRequest) Reset 

func (m *CreateOrganizationRequest) Reset()

func (*CreateOrganizationRequest) String 

func (m *CreateOrganizationRequest) String() string

func (*CreateOrganizationRequest) XXX_DiscardUnknown 

func (m *CreateOrganizationRequest) XXX_DiscardUnknown()

func (*CreateOrganizationRequest) XXX_Marshal 

func (m *CreateOrganizationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateOrganizationRequest) XXX_Merge 

func (m *CreateOrganizationRequest) XXX_Merge(src proto.Message)

func (*CreateOrganizationRequest) XXX_Size 

func (m *CreateOrganizationRequest) XXX_Size() int

func (*CreateOrganizationRequest) XXX_Unmarshal 

func (m *CreateOrganizationRequest) XXX_Unmarshal(b []byte) error

type CreateOrganizationResponse 

type CreateOrganizationResponse struct {
	// Organization ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateOrganizationResponse) Descriptor 

func (*CreateOrganizationResponse) Descriptor() ([]byte, []int)

func (*CreateOrganizationResponse) GetId 

func (m *CreateOrganizationResponse) GetId() int64

func (*CreateOrganizationResponse) ProtoMessage 

func (*CreateOrganizationResponse) ProtoMessage()

func (*CreateOrganizationResponse) Reset 

func (m *CreateOrganizationResponse) Reset()

func (*CreateOrganizationResponse) String 

func (m *CreateOrganizationResponse) String() string

func (*CreateOrganizationResponse) XXX_DiscardUnknown 

func (m *CreateOrganizationResponse) XXX_DiscardUnknown()

func (*CreateOrganizationResponse) XXX_Marshal 

func (m *CreateOrganizationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateOrganizationResponse) XXX_Merge 

func (m *CreateOrganizationResponse) XXX_Merge(src proto.Message)

func (*CreateOrganizationResponse) XXX_Size 

func (m *CreateOrganizationResponse) XXX_Size() int

func (*CreateOrganizationResponse) XXX_Unmarshal 

func (m *CreateOrganizationResponse) XXX_Unmarshal(b []byte) error

type CreatePilotThingsIntegrationRequest 

type CreatePilotThingsIntegrationRequest struct {
	// Integration object to create.
	Integration          *PilotThingsIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*CreatePilotThingsIntegrationRequest) Descriptor 

func (*CreatePilotThingsIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreatePilotThingsIntegrationRequest) GetIntegration 

func (m *CreatePilotThingsIntegrationRequest) GetIntegration() *PilotThingsIntegration

func (*CreatePilotThingsIntegrationRequest) ProtoMessage 

func (*CreatePilotThingsIntegrationRequest) ProtoMessage()

func (*CreatePilotThingsIntegrationRequest) Reset 

func (m *CreatePilotThingsIntegrationRequest) Reset()

func (*CreatePilotThingsIntegrationRequest) String 

func (m *CreatePilotThingsIntegrationRequest) String() string

func (*CreatePilotThingsIntegrationRequest) XXX_DiscardUnknown 

func (m *CreatePilotThingsIntegrationRequest) XXX_DiscardUnknown()

func (*CreatePilotThingsIntegrationRequest) XXX_Marshal 

func (m *CreatePilotThingsIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreatePilotThingsIntegrationRequest) XXX_Merge 

func (m *CreatePilotThingsIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreatePilotThingsIntegrationRequest) XXX_Size 

func (m *CreatePilotThingsIntegrationRequest) XXX_Size() int

func (*CreatePilotThingsIntegrationRequest) XXX_Unmarshal 

func (m *CreatePilotThingsIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateServiceProfileRequest 

type CreateServiceProfileRequest struct {
	// Service-profile object to create.
	ServiceProfile       *ServiceProfile `protobuf:"bytes,1,opt,name=service_profile,json=serviceProfile,proto3" json:"service_profile,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*CreateServiceProfileRequest) Descriptor 

func (*CreateServiceProfileRequest) Descriptor() ([]byte, []int)

func (*CreateServiceProfileRequest) GetServiceProfile 

func (m *CreateServiceProfileRequest) GetServiceProfile() *ServiceProfile

func (*CreateServiceProfileRequest) ProtoMessage 

func (*CreateServiceProfileRequest) ProtoMessage()

func (*CreateServiceProfileRequest) Reset 

func (m *CreateServiceProfileRequest) Reset()

func (*CreateServiceProfileRequest) String 

func (m *CreateServiceProfileRequest) String() string

func (*CreateServiceProfileRequest) XXX_DiscardUnknown 

func (m *CreateServiceProfileRequest) XXX_DiscardUnknown()

func (*CreateServiceProfileRequest) XXX_Marshal 

func (m *CreateServiceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateServiceProfileRequest) XXX_Merge 

func (m *CreateServiceProfileRequest) XXX_Merge(src proto.Message)

func (*CreateServiceProfileRequest) XXX_Size 

func (m *CreateServiceProfileRequest) XXX_Size() int

func (*CreateServiceProfileRequest) XXX_Unmarshal 

func (m *CreateServiceProfileRequest) XXX_Unmarshal(b []byte) error

type CreateServiceProfileResponse 

type CreateServiceProfileResponse struct {
	// Service-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateServiceProfileResponse) Descriptor 

func (*CreateServiceProfileResponse) Descriptor() ([]byte, []int)

func (*CreateServiceProfileResponse) GetId 

func (m *CreateServiceProfileResponse) GetId() string

func (*CreateServiceProfileResponse) ProtoMessage 

func (*CreateServiceProfileResponse) ProtoMessage()

func (*CreateServiceProfileResponse) Reset 

func (m *CreateServiceProfileResponse) Reset()

func (*CreateServiceProfileResponse) String 

func (m *CreateServiceProfileResponse) String() string

func (*CreateServiceProfileResponse) XXX_DiscardUnknown 

func (m *CreateServiceProfileResponse) XXX_DiscardUnknown()

func (*CreateServiceProfileResponse) XXX_Marshal 

func (m *CreateServiceProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateServiceProfileResponse) XXX_Merge 

func (m *CreateServiceProfileResponse) XXX_Merge(src proto.Message)

func (*CreateServiceProfileResponse) XXX_Size 

func (m *CreateServiceProfileResponse) XXX_Size() int

func (*CreateServiceProfileResponse) XXX_Unmarshal 

func (m *CreateServiceProfileResponse) XXX_Unmarshal(b []byte) error

type CreateThingsBoardIntegrationRequest 

type CreateThingsBoardIntegrationRequest struct {
	// Integration object to create.
	Integration          *ThingsBoardIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*CreateThingsBoardIntegrationRequest) Descriptor 

func (*CreateThingsBoardIntegrationRequest) Descriptor() ([]byte, []int)

func (*CreateThingsBoardIntegrationRequest) GetIntegration 

func (m *CreateThingsBoardIntegrationRequest) GetIntegration() *ThingsBoardIntegration

func (*CreateThingsBoardIntegrationRequest) ProtoMessage 

func (*CreateThingsBoardIntegrationRequest) ProtoMessage()

func (*CreateThingsBoardIntegrationRequest) Reset 

func (m *CreateThingsBoardIntegrationRequest) Reset()

func (*CreateThingsBoardIntegrationRequest) String 

func (m *CreateThingsBoardIntegrationRequest) String() string

func (*CreateThingsBoardIntegrationRequest) XXX_DiscardUnknown 

func (m *CreateThingsBoardIntegrationRequest) XXX_DiscardUnknown()

func (*CreateThingsBoardIntegrationRequest) XXX_Marshal 

func (m *CreateThingsBoardIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateThingsBoardIntegrationRequest) XXX_Merge 

func (m *CreateThingsBoardIntegrationRequest) XXX_Merge(src proto.Message)

func (*CreateThingsBoardIntegrationRequest) XXX_Size 

func (m *CreateThingsBoardIntegrationRequest) XXX_Size() int

func (*CreateThingsBoardIntegrationRequest) XXX_Unmarshal 

func (m *CreateThingsBoardIntegrationRequest) XXX_Unmarshal(b []byte) error

type CreateUserRequest 

type CreateUserRequest struct {
	// User object to create.
	User *User `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// Password of the user.
	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	// Add the user to the following organizations.
	Organizations        []*UserOrganization `protobuf:"bytes,3,rep,name=organizations,proto3" json:"organizations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (*CreateUserRequest) Descriptor 

func (*CreateUserRequest) Descriptor() ([]byte, []int)

func (*CreateUserRequest) GetOrganizations 

func (m *CreateUserRequest) GetOrganizations() []*UserOrganization

func (*CreateUserRequest) GetPassword 

func (m *CreateUserRequest) GetPassword() string

func (*CreateUserRequest) GetUser 

func (m *CreateUserRequest) GetUser() *User

func (*CreateUserRequest) ProtoMessage 

func (*CreateUserRequest) ProtoMessage()

func (*CreateUserRequest) Reset 

func (m *CreateUserRequest) Reset()

func (*CreateUserRequest) String 

func (m *CreateUserRequest) String() string

func (*CreateUserRequest) XXX_DiscardUnknown 

func (m *CreateUserRequest) XXX_DiscardUnknown()

func (*CreateUserRequest) XXX_Marshal 

func (m *CreateUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateUserRequest) XXX_Merge 

func (m *CreateUserRequest) XXX_Merge(src proto.Message)

func (*CreateUserRequest) XXX_Size 

func (m *CreateUserRequest) XXX_Size() int

func (*CreateUserRequest) XXX_Unmarshal 

func (m *CreateUserRequest) XXX_Unmarshal(b []byte) error

type CreateUserResponse 

type CreateUserResponse struct {
	// User ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*CreateUserResponse) Descriptor 

func (*CreateUserResponse) Descriptor() ([]byte, []int)

func (*CreateUserResponse) GetId 

func (m *CreateUserResponse) GetId() int64

func (*CreateUserResponse) ProtoMessage 

func (*CreateUserResponse) ProtoMessage()

func (*CreateUserResponse) Reset 

func (m *CreateUserResponse) Reset()

func (*CreateUserResponse) String 

func (m *CreateUserResponse) String() string

func (*CreateUserResponse) XXX_DiscardUnknown 

func (m *CreateUserResponse) XXX_DiscardUnknown()

func (*CreateUserResponse) XXX_Marshal 

func (m *CreateUserResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*CreateUserResponse) XXX_Merge 

func (m *CreateUserResponse) XXX_Merge(src proto.Message)

func (*CreateUserResponse) XXX_Size 

func (m *CreateUserResponse) XXX_Size() int

func (*CreateUserResponse) XXX_Unmarshal 

func (m *CreateUserResponse) XXX_Unmarshal(b []byte) error

type DTUPowerConfig 

type DTUPowerConfig struct {
	PreOutput12V         int32    `protobuf:"varint,1,opt,name=preOutput12V,proto3" json:"preOutput12V,omitempty"`
	IsStable             bool     `protobuf:"varint,2,opt,name=isStable,proto3" json:"isStable,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DTUPowerConfig) Descriptor 

func (*DTUPowerConfig) Descriptor() ([]byte, []int)

func (*DTUPowerConfig) GetIsStable 

func (m *DTUPowerConfig) GetIsStable() bool

func (*DTUPowerConfig) GetPreOutput12V 

func (m *DTUPowerConfig) GetPreOutput12V() int32

func (*DTUPowerConfig) ProtoMessage 

func (*DTUPowerConfig) ProtoMessage()

func (*DTUPowerConfig) Reset 

func (m *DTUPowerConfig) Reset()

func (*DTUPowerConfig) String 

func (m *DTUPowerConfig) String() string

func (*DTUPowerConfig) XXX_DiscardUnknown 

func (m *DTUPowerConfig) XXX_DiscardUnknown()

func (*DTUPowerConfig) XXX_Marshal 

func (m *DTUPowerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DTUPowerConfig) XXX_Merge 

func (m *DTUPowerConfig) XXX_Merge(src proto.Message)

func (*DTUPowerConfig) XXX_Size 

func (m *DTUPowerConfig) XXX_Size() int

func (*DTUPowerConfig) XXX_Unmarshal 

func (m *DTUPowerConfig) XXX_Unmarshal(b []byte) error

type DeactivateDeviceRequest 

type DeactivateDeviceRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeactivateDeviceRequest) Descriptor 

func (*DeactivateDeviceRequest) Descriptor() ([]byte, []int)

func (*DeactivateDeviceRequest) GetDevEui 

func (m *DeactivateDeviceRequest) GetDevEui() string

func (*DeactivateDeviceRequest) ProtoMessage 

func (*DeactivateDeviceRequest) ProtoMessage()

func (*DeactivateDeviceRequest) Reset 

func (m *DeactivateDeviceRequest) Reset()

func (*DeactivateDeviceRequest) String 

func (m *DeactivateDeviceRequest) String() string

func (*DeactivateDeviceRequest) XXX_DiscardUnknown 

func (m *DeactivateDeviceRequest) XXX_DiscardUnknown()

func (*DeactivateDeviceRequest) XXX_Marshal 

func (m *DeactivateDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeactivateDeviceRequest) XXX_Merge 

func (m *DeactivateDeviceRequest) XXX_Merge(src proto.Message)

func (*DeactivateDeviceRequest) XXX_Size 

func (m *DeactivateDeviceRequest) XXX_Size() int

func (*DeactivateDeviceRequest) XXX_Unmarshal 

func (m *DeactivateDeviceRequest) XXX_Unmarshal(b []byte) error

type DebugServiceClient 

type DebugServiceClient interface {
	GetLorawanTx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetLorawanTxResponse, error)
	SetLorawanTx(ctx context.Context, in *SetLorawanTxRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StreamLorawanTx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (DebugService_StreamLorawanTxClient, error)
	GetLorawanRx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetLorawanRxResponse, error)
	StreamLorawanRx(ctx context.Context, in *StreamLorawanRxRequest, opts ...grpc.CallOption) (DebugService_StreamLorawanRxClient, error)
	StreamLogs(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (DebugService_StreamLogsClient, error)
	SetLogs(ctx context.Context, in *SetLogsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetVPN(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetVPNResponse, error)
	SetVPN(ctx context.Context, in *SetVPNRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

DebugServiceClient is the client API for DebugService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewDebugServiceClient 

func NewDebugServiceClient(cc grpc.ClientConnInterface) DebugServiceClient

type DebugServiceServer 

type DebugServiceServer interface {
	GetLorawanTx(context.Context, *emptypb.Empty) (*GetLorawanTxResponse, error)
	SetLorawanTx(context.Context, *SetLorawanTxRequest) (*emptypb.Empty, error)
	StreamLorawanTx(*emptypb.Empty, DebugService_StreamLorawanTxServer) error
	GetLorawanRx(context.Context, *emptypb.Empty) (*GetLorawanRxResponse, error)
	StreamLorawanRx(*StreamLorawanRxRequest, DebugService_StreamLorawanRxServer) error
	StreamLogs(*emptypb.Empty, DebugService_StreamLogsServer) error
	SetLogs(context.Context, *SetLogsRequest) (*emptypb.Empty, error)
	GetVPN(context.Context, *emptypb.Empty) (*GetVPNResponse, error)
	SetVPN(context.Context, *SetVPNRequest) (*emptypb.Empty, error)
}

DebugServiceServer is the server API for DebugService service.

type DebugService_StreamLogsClient 

type DebugService_StreamLogsClient interface {
	Recv() (*StreamLogsResponse, error)
	grpc.ClientStream
}

type DebugService_StreamLogsServer 

type DebugService_StreamLogsServer interface {
	Send(*StreamLogsResponse) error
	grpc.ServerStream
}

type DebugService_StreamLorawanRxClient 

type DebugService_StreamLorawanRxClient interface {
	Recv() (*StreamLorawanRxResponse, error)
	grpc.ClientStream
}

type DebugService_StreamLorawanRxServer 

type DebugService_StreamLorawanRxServer interface {
	Send(*StreamLorawanRxResponse) error
	grpc.ServerStream
}

type DebugService_StreamLorawanTxClient 

type DebugService_StreamLorawanTxClient interface {
	Recv() (*StreamLorawanTxResponse, error)
	grpc.ClientStream
}

type DebugService_StreamLorawanTxServer 

type DebugService_StreamLorawanTxServer interface {
	Send(*StreamLorawanTxResponse) error
	grpc.ServerStream
}

type DeleteAPIKeyRequest 

type DeleteAPIKeyRequest struct {
	// API key ID.
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteAPIKeyRequest) Descriptor 

func (*DeleteAPIKeyRequest) Descriptor() ([]byte, []int)

func (*DeleteAPIKeyRequest) GetId 

func (m *DeleteAPIKeyRequest) GetId() string

func (*DeleteAPIKeyRequest) ProtoMessage 

func (*DeleteAPIKeyRequest) ProtoMessage()

func (*DeleteAPIKeyRequest) Reset 

func (m *DeleteAPIKeyRequest) Reset()

func (*DeleteAPIKeyRequest) String 

func (m *DeleteAPIKeyRequest) String() string

func (*DeleteAPIKeyRequest) XXX_DiscardUnknown 

func (m *DeleteAPIKeyRequest) XXX_DiscardUnknown()

func (*DeleteAPIKeyRequest) XXX_Marshal 

func (m *DeleteAPIKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteAPIKeyRequest) XXX_Merge 

func (m *DeleteAPIKeyRequest) XXX_Merge(src proto.Message)

func (*DeleteAPIKeyRequest) XXX_Size 

func (m *DeleteAPIKeyRequest) XXX_Size() int

func (*DeleteAPIKeyRequest) XXX_Unmarshal 

func (m *DeleteAPIKeyRequest) XXX_Unmarshal(b []byte) error

type DeleteAWSSNSIntegrationRequest 

type DeleteAWSSNSIntegrationRequest struct {
	// The id of the application.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteAWSSNSIntegrationRequest) Descriptor 

func (*DeleteAWSSNSIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteAWSSNSIntegrationRequest) GetApplicationId 

func (m *DeleteAWSSNSIntegrationRequest) GetApplicationId() int64

func (*DeleteAWSSNSIntegrationRequest) ProtoMessage 

func (*DeleteAWSSNSIntegrationRequest) ProtoMessage()

func (*DeleteAWSSNSIntegrationRequest) Reset 

func (m *DeleteAWSSNSIntegrationRequest) Reset()

func (*DeleteAWSSNSIntegrationRequest) String 

func (m *DeleteAWSSNSIntegrationRequest) String() string

func (*DeleteAWSSNSIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteAWSSNSIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteAWSSNSIntegrationRequest) XXX_Marshal 

func (m *DeleteAWSSNSIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteAWSSNSIntegrationRequest) XXX_Merge 

func (m *DeleteAWSSNSIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteAWSSNSIntegrationRequest) XXX_Size 

func (m *DeleteAWSSNSIntegrationRequest) XXX_Size() int

func (*DeleteAWSSNSIntegrationRequest) XXX_Unmarshal 

func (m *DeleteAWSSNSIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteApplicationRequest 

type DeleteApplicationRequest struct {
	// Application ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteApplicationRequest) Descriptor 

func (*DeleteApplicationRequest) Descriptor() ([]byte, []int)

func (*DeleteApplicationRequest) GetId 

func (m *DeleteApplicationRequest) GetId() int64

func (*DeleteApplicationRequest) ProtoMessage 

func (*DeleteApplicationRequest) ProtoMessage()

func (*DeleteApplicationRequest) Reset 

func (m *DeleteApplicationRequest) Reset()

func (*DeleteApplicationRequest) String 

func (m *DeleteApplicationRequest) String() string

func (*DeleteApplicationRequest) XXX_DiscardUnknown 

func (m *DeleteApplicationRequest) XXX_DiscardUnknown()

func (*DeleteApplicationRequest) XXX_Marshal 

func (m *DeleteApplicationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteApplicationRequest) XXX_Merge 

func (m *DeleteApplicationRequest) XXX_Merge(src proto.Message)

func (*DeleteApplicationRequest) XXX_Size 

func (m *DeleteApplicationRequest) XXX_Size() int

func (*DeleteApplicationRequest) XXX_Unmarshal 

func (m *DeleteApplicationRequest) XXX_Unmarshal(b []byte) error

type DeleteAzureServiceBusIntegrationRequest 

type DeleteAzureServiceBusIntegrationRequest struct {
	// The id of the application.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteAzureServiceBusIntegrationRequest) Descriptor 

func (*DeleteAzureServiceBusIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteAzureServiceBusIntegrationRequest) GetApplicationId 

func (m *DeleteAzureServiceBusIntegrationRequest) GetApplicationId() int64

func (*DeleteAzureServiceBusIntegrationRequest) ProtoMessage 

func (*DeleteAzureServiceBusIntegrationRequest) ProtoMessage()

func (*DeleteAzureServiceBusIntegrationRequest) Reset 

func (m *DeleteAzureServiceBusIntegrationRequest) Reset()

func (*DeleteAzureServiceBusIntegrationRequest) String 

func (m *DeleteAzureServiceBusIntegrationRequest) String() string

func (*DeleteAzureServiceBusIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteAzureServiceBusIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteAzureServiceBusIntegrationRequest) XXX_Marshal 

func (m *DeleteAzureServiceBusIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteAzureServiceBusIntegrationRequest) XXX_Merge 

func (m *DeleteAzureServiceBusIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteAzureServiceBusIntegrationRequest) XXX_Size 

func (m *DeleteAzureServiceBusIntegrationRequest) XXX_Size() int

func (*DeleteAzureServiceBusIntegrationRequest) XXX_Unmarshal 

func (m *DeleteAzureServiceBusIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteDeviceKeysRequest 

type DeleteDeviceKeysRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteDeviceKeysRequest) Descriptor 

func (*DeleteDeviceKeysRequest) Descriptor() ([]byte, []int)

func (*DeleteDeviceKeysRequest) GetDevEui 

func (m *DeleteDeviceKeysRequest) GetDevEui() string

func (*DeleteDeviceKeysRequest) ProtoMessage 

func (*DeleteDeviceKeysRequest) ProtoMessage()

func (*DeleteDeviceKeysRequest) Reset 

func (m *DeleteDeviceKeysRequest) Reset()

func (*DeleteDeviceKeysRequest) String 

func (m *DeleteDeviceKeysRequest) String() string

func (*DeleteDeviceKeysRequest) XXX_DiscardUnknown 

func (m *DeleteDeviceKeysRequest) XXX_DiscardUnknown()

func (*DeleteDeviceKeysRequest) XXX_Marshal 

func (m *DeleteDeviceKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteDeviceKeysRequest) XXX_Merge 

func (m *DeleteDeviceKeysRequest) XXX_Merge(src proto.Message)

func (*DeleteDeviceKeysRequest) XXX_Size 

func (m *DeleteDeviceKeysRequest) XXX_Size() int

func (*DeleteDeviceKeysRequest) XXX_Unmarshal 

func (m *DeleteDeviceKeysRequest) XXX_Unmarshal(b []byte) error

type DeleteDeviceProfileRequest 

type DeleteDeviceProfileRequest struct {
	// Device-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteDeviceProfileRequest) Descriptor 

func (*DeleteDeviceProfileRequest) Descriptor() ([]byte, []int)

func (*DeleteDeviceProfileRequest) GetId 

func (m *DeleteDeviceProfileRequest) GetId() string

func (*DeleteDeviceProfileRequest) ProtoMessage 

func (*DeleteDeviceProfileRequest) ProtoMessage()

func (*DeleteDeviceProfileRequest) Reset 

func (m *DeleteDeviceProfileRequest) Reset()

func (*DeleteDeviceProfileRequest) String 

func (m *DeleteDeviceProfileRequest) String() string

func (*DeleteDeviceProfileRequest) XXX_DiscardUnknown 

func (m *DeleteDeviceProfileRequest) XXX_DiscardUnknown()

func (*DeleteDeviceProfileRequest) XXX_Marshal 

func (m *DeleteDeviceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteDeviceProfileRequest) XXX_Merge 

func (m *DeleteDeviceProfileRequest) XXX_Merge(src proto.Message)

func (*DeleteDeviceProfileRequest) XXX_Size 

func (m *DeleteDeviceProfileRequest) XXX_Size() int

func (*DeleteDeviceProfileRequest) XXX_Unmarshal 

func (m *DeleteDeviceProfileRequest) XXX_Unmarshal(b []byte) error

type DeleteDeviceRequest 

type DeleteDeviceRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteDeviceRequest) Descriptor 

func (*DeleteDeviceRequest) Descriptor() ([]byte, []int)

func (*DeleteDeviceRequest) GetDevEui 

func (m *DeleteDeviceRequest) GetDevEui() string

func (*DeleteDeviceRequest) ProtoMessage 

func (*DeleteDeviceRequest) ProtoMessage()

func (*DeleteDeviceRequest) Reset 

func (m *DeleteDeviceRequest) Reset()

func (*DeleteDeviceRequest) String 

func (m *DeleteDeviceRequest) String() string

func (*DeleteDeviceRequest) XXX_DiscardUnknown 

func (m *DeleteDeviceRequest) XXX_DiscardUnknown()

func (*DeleteDeviceRequest) XXX_Marshal 

func (m *DeleteDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteDeviceRequest) XXX_Merge 

func (m *DeleteDeviceRequest) XXX_Merge(src proto.Message)

func (*DeleteDeviceRequest) XXX_Size 

func (m *DeleteDeviceRequest) XXX_Size() int

func (*DeleteDeviceRequest) XXX_Unmarshal 

func (m *DeleteDeviceRequest) XXX_Unmarshal(b []byte) error

type DeleteDeviceResponse 

type DeleteDeviceResponse struct {
	Empty                *emptypb.Empty `protobuf:"bytes,1,opt,name=empty,proto3" json:"empty,omitempty"`
	Message              string         `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Status               string         `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*DeleteDeviceResponse) Descriptor 

func (*DeleteDeviceResponse) Descriptor() ([]byte, []int)

func (*DeleteDeviceResponse) GetEmpty 

func (m *DeleteDeviceResponse) GetEmpty() *emptypb.Empty

func (*DeleteDeviceResponse) GetMessage 

func (m *DeleteDeviceResponse) GetMessage() string

func (*DeleteDeviceResponse) GetStatus 

func (m *DeleteDeviceResponse) GetStatus() string

func (*DeleteDeviceResponse) ProtoMessage 

func (*DeleteDeviceResponse) ProtoMessage()

func (*DeleteDeviceResponse) Reset 

func (m *DeleteDeviceResponse) Reset()

func (*DeleteDeviceResponse) String 

func (m *DeleteDeviceResponse) String() string

func (*DeleteDeviceResponse) XXX_DiscardUnknown 

func (m *DeleteDeviceResponse) XXX_DiscardUnknown()

func (*DeleteDeviceResponse) XXX_Marshal 

func (m *DeleteDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteDeviceResponse) XXX_Merge 

func (m *DeleteDeviceResponse) XXX_Merge(src proto.Message)

func (*DeleteDeviceResponse) XXX_Size 

func (m *DeleteDeviceResponse) XXX_Size() int

func (*DeleteDeviceResponse) XXX_Unmarshal 

func (m *DeleteDeviceResponse) XXX_Unmarshal(b []byte) error

type DeleteGCPPubSubIntegrationRequest 

type DeleteGCPPubSubIntegrationRequest struct {
	// The id of the application.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteGCPPubSubIntegrationRequest) Descriptor 

func (*DeleteGCPPubSubIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteGCPPubSubIntegrationRequest) GetApplicationId 

func (m *DeleteGCPPubSubIntegrationRequest) GetApplicationId() int64

func (*DeleteGCPPubSubIntegrationRequest) ProtoMessage 

func (*DeleteGCPPubSubIntegrationRequest) ProtoMessage()

func (*DeleteGCPPubSubIntegrationRequest) Reset 

func (m *DeleteGCPPubSubIntegrationRequest) Reset()

func (*DeleteGCPPubSubIntegrationRequest) String 

func (m *DeleteGCPPubSubIntegrationRequest) String() string

func (*DeleteGCPPubSubIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteGCPPubSubIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteGCPPubSubIntegrationRequest) XXX_Marshal 

func (m *DeleteGCPPubSubIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteGCPPubSubIntegrationRequest) XXX_Merge 

func (m *DeleteGCPPubSubIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteGCPPubSubIntegrationRequest) XXX_Size 

func (m *DeleteGCPPubSubIntegrationRequest) XXX_Size() int

func (*DeleteGCPPubSubIntegrationRequest) XXX_Unmarshal 

func (m *DeleteGCPPubSubIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteGatewayProfileRequest 

type DeleteGatewayProfileRequest struct {
	// Gateway-profile id (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteGatewayProfileRequest) Descriptor 

func (*DeleteGatewayProfileRequest) Descriptor() ([]byte, []int)

func (*DeleteGatewayProfileRequest) GetId 

func (m *DeleteGatewayProfileRequest) GetId() string

func (*DeleteGatewayProfileRequest) ProtoMessage 

func (*DeleteGatewayProfileRequest) ProtoMessage()

func (*DeleteGatewayProfileRequest) Reset 

func (m *DeleteGatewayProfileRequest) Reset()

func (*DeleteGatewayProfileRequest) String 

func (m *DeleteGatewayProfileRequest) String() string

func (*DeleteGatewayProfileRequest) XXX_DiscardUnknown 

func (m *DeleteGatewayProfileRequest) XXX_DiscardUnknown()

func (*DeleteGatewayProfileRequest) XXX_Marshal 

func (m *DeleteGatewayProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteGatewayProfileRequest) XXX_Merge 

func (m *DeleteGatewayProfileRequest) XXX_Merge(src proto.Message)

func (*DeleteGatewayProfileRequest) XXX_Size 

func (m *DeleteGatewayProfileRequest) XXX_Size() int

func (*DeleteGatewayProfileRequest) XXX_Unmarshal 

func (m *DeleteGatewayProfileRequest) XXX_Unmarshal(b []byte) error

type DeleteGatewayRequest 

type DeleteGatewayRequest struct {
	// Gateway ID (HEX encoded).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteGatewayRequest) Descriptor 

func (*DeleteGatewayRequest) Descriptor() ([]byte, []int)

func (*DeleteGatewayRequest) GetId 

func (m *DeleteGatewayRequest) GetId() string

func (*DeleteGatewayRequest) ProtoMessage 

func (*DeleteGatewayRequest) ProtoMessage()

func (*DeleteGatewayRequest) Reset 

func (m *DeleteGatewayRequest) Reset()

func (*DeleteGatewayRequest) String 

func (m *DeleteGatewayRequest) String() string

func (*DeleteGatewayRequest) XXX_DiscardUnknown 

func (m *DeleteGatewayRequest) XXX_DiscardUnknown()

func (*DeleteGatewayRequest) XXX_Marshal 

func (m *DeleteGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteGatewayRequest) XXX_Merge 

func (m *DeleteGatewayRequest) XXX_Merge(src proto.Message)

func (*DeleteGatewayRequest) XXX_Size 

func (m *DeleteGatewayRequest) XXX_Size() int

func (*DeleteGatewayRequest) XXX_Unmarshal 

func (m *DeleteGatewayRequest) XXX_Unmarshal(b []byte) error

type DeleteHTTPIntegrationRequest 

type DeleteHTTPIntegrationRequest struct {
	// The id of the application.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteHTTPIntegrationRequest) Descriptor 

func (*DeleteHTTPIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteHTTPIntegrationRequest) GetApplicationId 

func (m *DeleteHTTPIntegrationRequest) GetApplicationId() int64

func (*DeleteHTTPIntegrationRequest) ProtoMessage 

func (*DeleteHTTPIntegrationRequest) ProtoMessage()

func (*DeleteHTTPIntegrationRequest) Reset 

func (m *DeleteHTTPIntegrationRequest) Reset()

func (*DeleteHTTPIntegrationRequest) String 

func (m *DeleteHTTPIntegrationRequest) String() string

func (*DeleteHTTPIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteHTTPIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteHTTPIntegrationRequest) XXX_Marshal 

func (m *DeleteHTTPIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteHTTPIntegrationRequest) XXX_Merge 

func (m *DeleteHTTPIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteHTTPIntegrationRequest) XXX_Size 

func (m *DeleteHTTPIntegrationRequest) XXX_Size() int

func (*DeleteHTTPIntegrationRequest) XXX_Unmarshal 

func (m *DeleteHTTPIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteInfluxDBIntegrationRequest 

type DeleteInfluxDBIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteInfluxDBIntegrationRequest) Descriptor 

func (*DeleteInfluxDBIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteInfluxDBIntegrationRequest) GetApplicationId 

func (m *DeleteInfluxDBIntegrationRequest) GetApplicationId() int64

func (*DeleteInfluxDBIntegrationRequest) ProtoMessage 

func (*DeleteInfluxDBIntegrationRequest) ProtoMessage()

func (*DeleteInfluxDBIntegrationRequest) Reset 

func (m *DeleteInfluxDBIntegrationRequest) Reset()

func (*DeleteInfluxDBIntegrationRequest) String 

func (m *DeleteInfluxDBIntegrationRequest) String() string

func (*DeleteInfluxDBIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteInfluxDBIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteInfluxDBIntegrationRequest) XXX_Marshal 

func (m *DeleteInfluxDBIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteInfluxDBIntegrationRequest) XXX_Merge 

func (m *DeleteInfluxDBIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteInfluxDBIntegrationRequest) XXX_Size 

func (m *DeleteInfluxDBIntegrationRequest) XXX_Size() int

func (*DeleteInfluxDBIntegrationRequest) XXX_Unmarshal 

func (m *DeleteInfluxDBIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteLoRaCloudIntegrationRequest 

type DeleteLoRaCloudIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteLoRaCloudIntegrationRequest) Descriptor 

func (*DeleteLoRaCloudIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteLoRaCloudIntegrationRequest) GetApplicationId 

func (m *DeleteLoRaCloudIntegrationRequest) GetApplicationId() int64

func (*DeleteLoRaCloudIntegrationRequest) ProtoMessage 

func (*DeleteLoRaCloudIntegrationRequest) ProtoMessage()

func (*DeleteLoRaCloudIntegrationRequest) Reset 

func (m *DeleteLoRaCloudIntegrationRequest) Reset()

func (*DeleteLoRaCloudIntegrationRequest) String 

func (m *DeleteLoRaCloudIntegrationRequest) String() string

func (*DeleteLoRaCloudIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteLoRaCloudIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteLoRaCloudIntegrationRequest) XXX_Marshal 

func (m *DeleteLoRaCloudIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteLoRaCloudIntegrationRequest) XXX_Merge 

func (m *DeleteLoRaCloudIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteLoRaCloudIntegrationRequest) XXX_Size 

func (m *DeleteLoRaCloudIntegrationRequest) XXX_Size() int

func (*DeleteLoRaCloudIntegrationRequest) XXX_Unmarshal 

func (m *DeleteLoRaCloudIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteMulticastGroupRequest 

type DeleteMulticastGroupRequest struct {
	// ID (string formatted UUID).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteMulticastGroupRequest) Descriptor 

func (*DeleteMulticastGroupRequest) Descriptor() ([]byte, []int)

func (*DeleteMulticastGroupRequest) GetId 

func (m *DeleteMulticastGroupRequest) GetId() string

func (*DeleteMulticastGroupRequest) ProtoMessage 

func (*DeleteMulticastGroupRequest) ProtoMessage()

func (*DeleteMulticastGroupRequest) Reset 

func (m *DeleteMulticastGroupRequest) Reset()

func (*DeleteMulticastGroupRequest) String 

func (m *DeleteMulticastGroupRequest) String() string

func (*DeleteMulticastGroupRequest) XXX_DiscardUnknown 

func (m *DeleteMulticastGroupRequest) XXX_DiscardUnknown()

func (*DeleteMulticastGroupRequest) XXX_Marshal 

func (m *DeleteMulticastGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteMulticastGroupRequest) XXX_Merge 

func (m *DeleteMulticastGroupRequest) XXX_Merge(src proto.Message)

func (*DeleteMulticastGroupRequest) XXX_Size 

func (m *DeleteMulticastGroupRequest) XXX_Size() int

func (*DeleteMulticastGroupRequest) XXX_Unmarshal 

func (m *DeleteMulticastGroupRequest) XXX_Unmarshal(b []byte) error

type DeleteMyDevicesIntegrationRequest 

type DeleteMyDevicesIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteMyDevicesIntegrationRequest) Descriptor 

func (*DeleteMyDevicesIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteMyDevicesIntegrationRequest) GetApplicationId 

func (m *DeleteMyDevicesIntegrationRequest) GetApplicationId() int64

func (*DeleteMyDevicesIntegrationRequest) ProtoMessage 

func (*DeleteMyDevicesIntegrationRequest) ProtoMessage()

func (*DeleteMyDevicesIntegrationRequest) Reset 

func (m *DeleteMyDevicesIntegrationRequest) Reset()

func (*DeleteMyDevicesIntegrationRequest) String 

func (m *DeleteMyDevicesIntegrationRequest) String() string

func (*DeleteMyDevicesIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteMyDevicesIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteMyDevicesIntegrationRequest) XXX_Marshal 

func (m *DeleteMyDevicesIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteMyDevicesIntegrationRequest) XXX_Merge 

func (m *DeleteMyDevicesIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteMyDevicesIntegrationRequest) XXX_Size 

func (m *DeleteMyDevicesIntegrationRequest) XXX_Size() int

func (*DeleteMyDevicesIntegrationRequest) XXX_Unmarshal 

func (m *DeleteMyDevicesIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteNetworkServerRequest 

type DeleteNetworkServerRequest struct {
	// Network-server ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteNetworkServerRequest) Descriptor 

func (*DeleteNetworkServerRequest) Descriptor() ([]byte, []int)

func (*DeleteNetworkServerRequest) GetId 

func (m *DeleteNetworkServerRequest) GetId() int64

func (*DeleteNetworkServerRequest) ProtoMessage 

func (*DeleteNetworkServerRequest) ProtoMessage()

func (*DeleteNetworkServerRequest) Reset 

func (m *DeleteNetworkServerRequest) Reset()

func (*DeleteNetworkServerRequest) String 

func (m *DeleteNetworkServerRequest) String() string

func (*DeleteNetworkServerRequest) XXX_DiscardUnknown 

func (m *DeleteNetworkServerRequest) XXX_DiscardUnknown()

func (*DeleteNetworkServerRequest) XXX_Marshal 

func (m *DeleteNetworkServerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteNetworkServerRequest) XXX_Merge 

func (m *DeleteNetworkServerRequest) XXX_Merge(src proto.Message)

func (*DeleteNetworkServerRequest) XXX_Size 

func (m *DeleteNetworkServerRequest) XXX_Size() int

func (*DeleteNetworkServerRequest) XXX_Unmarshal 

func (m *DeleteNetworkServerRequest) XXX_Unmarshal(b []byte) error

type DeleteOrganizationRequest 

type DeleteOrganizationRequest struct {
	// Organization ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteOrganizationRequest) Descriptor 

func (*DeleteOrganizationRequest) Descriptor() ([]byte, []int)

func (*DeleteOrganizationRequest) GetId 

func (m *DeleteOrganizationRequest) GetId() int64

func (*DeleteOrganizationRequest) ProtoMessage 

func (*DeleteOrganizationRequest) ProtoMessage()

func (*DeleteOrganizationRequest) Reset 

func (m *DeleteOrganizationRequest) Reset()

func (*DeleteOrganizationRequest) String 

func (m *DeleteOrganizationRequest) String() string

func (*DeleteOrganizationRequest) XXX_DiscardUnknown 

func (m *DeleteOrganizationRequest) XXX_DiscardUnknown()

func (*DeleteOrganizationRequest) XXX_Marshal 

func (m *DeleteOrganizationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteOrganizationRequest) XXX_Merge 

func (m *DeleteOrganizationRequest) XXX_Merge(src proto.Message)

func (*DeleteOrganizationRequest) XXX_Size 

func (m *DeleteOrganizationRequest) XXX_Size() int

func (*DeleteOrganizationRequest) XXX_Unmarshal 

func (m *DeleteOrganizationRequest) XXX_Unmarshal(b []byte) error

type DeleteOrganizationUserRequest 

type DeleteOrganizationUserRequest struct {
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// User ID.
	UserId               int64    `protobuf:"varint,2,opt,name=user_id,json=userID,proto3" json:"user_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteOrganizationUserRequest) Descriptor 

func (*DeleteOrganizationUserRequest) Descriptor() ([]byte, []int)

func (*DeleteOrganizationUserRequest) GetOrganizationId 

func (m *DeleteOrganizationUserRequest) GetOrganizationId() int64

func (*DeleteOrganizationUserRequest) GetUserId 

func (m *DeleteOrganizationUserRequest) GetUserId() int64

func (*DeleteOrganizationUserRequest) ProtoMessage 

func (*DeleteOrganizationUserRequest) ProtoMessage()

func (*DeleteOrganizationUserRequest) Reset 

func (m *DeleteOrganizationUserRequest) Reset()

func (*DeleteOrganizationUserRequest) String 

func (m *DeleteOrganizationUserRequest) String() string

func (*DeleteOrganizationUserRequest) XXX_DiscardUnknown 

func (m *DeleteOrganizationUserRequest) XXX_DiscardUnknown()

func (*DeleteOrganizationUserRequest) XXX_Marshal 

func (m *DeleteOrganizationUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteOrganizationUserRequest) XXX_Merge 

func (m *DeleteOrganizationUserRequest) XXX_Merge(src proto.Message)

func (*DeleteOrganizationUserRequest) XXX_Size 

func (m *DeleteOrganizationUserRequest) XXX_Size() int

func (*DeleteOrganizationUserRequest) XXX_Unmarshal 

func (m *DeleteOrganizationUserRequest) XXX_Unmarshal(b []byte) error

type DeletePilotThingsIntegrationRequest 

type DeletePilotThingsIntegrationRequest struct {
	// The id of the application.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeletePilotThingsIntegrationRequest) Descriptor 

func (*DeletePilotThingsIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeletePilotThingsIntegrationRequest) GetApplicationId 

func (m *DeletePilotThingsIntegrationRequest) GetApplicationId() int64

func (*DeletePilotThingsIntegrationRequest) ProtoMessage 

func (*DeletePilotThingsIntegrationRequest) ProtoMessage()

func (*DeletePilotThingsIntegrationRequest) Reset 

func (m *DeletePilotThingsIntegrationRequest) Reset()

func (*DeletePilotThingsIntegrationRequest) String 

func (m *DeletePilotThingsIntegrationRequest) String() string

func (*DeletePilotThingsIntegrationRequest) XXX_DiscardUnknown 

func (m *DeletePilotThingsIntegrationRequest) XXX_DiscardUnknown()

func (*DeletePilotThingsIntegrationRequest) XXX_Marshal 

func (m *DeletePilotThingsIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeletePilotThingsIntegrationRequest) XXX_Merge 

func (m *DeletePilotThingsIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeletePilotThingsIntegrationRequest) XXX_Size 

func (m *DeletePilotThingsIntegrationRequest) XXX_Size() int

func (*DeletePilotThingsIntegrationRequest) XXX_Unmarshal 

func (m *DeletePilotThingsIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteServiceProfileRequest 

type DeleteServiceProfileRequest struct {
	// Service-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteServiceProfileRequest) Descriptor 

func (*DeleteServiceProfileRequest) Descriptor() ([]byte, []int)

func (*DeleteServiceProfileRequest) GetId 

func (m *DeleteServiceProfileRequest) GetId() string

func (*DeleteServiceProfileRequest) ProtoMessage 

func (*DeleteServiceProfileRequest) ProtoMessage()

func (*DeleteServiceProfileRequest) Reset 

func (m *DeleteServiceProfileRequest) Reset()

func (*DeleteServiceProfileRequest) String 

func (m *DeleteServiceProfileRequest) String() string

func (*DeleteServiceProfileRequest) XXX_DiscardUnknown 

func (m *DeleteServiceProfileRequest) XXX_DiscardUnknown()

func (*DeleteServiceProfileRequest) XXX_Marshal 

func (m *DeleteServiceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteServiceProfileRequest) XXX_Merge 

func (m *DeleteServiceProfileRequest) XXX_Merge(src proto.Message)

func (*DeleteServiceProfileRequest) XXX_Size 

func (m *DeleteServiceProfileRequest) XXX_Size() int

func (*DeleteServiceProfileRequest) XXX_Unmarshal 

func (m *DeleteServiceProfileRequest) XXX_Unmarshal(b []byte) error

type DeleteThingsBoardIntegrationRequest 

type DeleteThingsBoardIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteThingsBoardIntegrationRequest) Descriptor 

func (*DeleteThingsBoardIntegrationRequest) Descriptor() ([]byte, []int)

func (*DeleteThingsBoardIntegrationRequest) GetApplicationId 

func (m *DeleteThingsBoardIntegrationRequest) GetApplicationId() int64

func (*DeleteThingsBoardIntegrationRequest) ProtoMessage 

func (*DeleteThingsBoardIntegrationRequest) ProtoMessage()

func (*DeleteThingsBoardIntegrationRequest) Reset 

func (m *DeleteThingsBoardIntegrationRequest) Reset()

func (*DeleteThingsBoardIntegrationRequest) String 

func (m *DeleteThingsBoardIntegrationRequest) String() string

func (*DeleteThingsBoardIntegrationRequest) XXX_DiscardUnknown 

func (m *DeleteThingsBoardIntegrationRequest) XXX_DiscardUnknown()

func (*DeleteThingsBoardIntegrationRequest) XXX_Marshal 

func (m *DeleteThingsBoardIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteThingsBoardIntegrationRequest) XXX_Merge 

func (m *DeleteThingsBoardIntegrationRequest) XXX_Merge(src proto.Message)

func (*DeleteThingsBoardIntegrationRequest) XXX_Size 

func (m *DeleteThingsBoardIntegrationRequest) XXX_Size() int

func (*DeleteThingsBoardIntegrationRequest) XXX_Unmarshal 

func (m *DeleteThingsBoardIntegrationRequest) XXX_Unmarshal(b []byte) error

type DeleteUserRequest 

type DeleteUserRequest struct {
	// User ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeleteUserRequest) Descriptor 

func (*DeleteUserRequest) Descriptor() ([]byte, []int)

func (*DeleteUserRequest) GetId 

func (m *DeleteUserRequest) GetId() int64

func (*DeleteUserRequest) ProtoMessage 

func (*DeleteUserRequest) ProtoMessage()

func (*DeleteUserRequest) Reset 

func (m *DeleteUserRequest) Reset()

func (*DeleteUserRequest) String 

func (m *DeleteUserRequest) String() string

func (*DeleteUserRequest) XXX_DiscardUnknown 

func (m *DeleteUserRequest) XXX_DiscardUnknown()

func (*DeleteUserRequest) XXX_Marshal 

func (m *DeleteUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeleteUserRequest) XXX_Merge 

func (m *DeleteUserRequest) XXX_Merge(src proto.Message)

func (*DeleteUserRequest) XXX_Size 

func (m *DeleteUserRequest) XXX_Size() int

func (*DeleteUserRequest) XXX_Unmarshal 

func (m *DeleteUserRequest) XXX_Unmarshal(b []byte) error

type Device 

type Device struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Name of the device (if left blank, it will be set to the DevEUI).
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// ID of the application to which the device must be added.
	// It is possible to move a device to a different application on update,
	// given that both the old and the new application share the same
	// service-profile.
	ApplicationId int64 `protobuf:"varint,3,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Description of the device.
	Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
	// DeviceProfileID attached to the device.
	DeviceProfileId string `protobuf:"bytes,5,opt,name=device_profile_id,json=deviceProfileID,proto3" json:"device_profile_id,omitempty"`
	// Skip frame-counter checks (this is insecure, but could be helpful for debugging).
	SkipFCntCheck bool `protobuf:"varint,6,opt,name=skip_f_cnt_check,json=skipFCntCheck,proto3" json:"skip_f_cnt_check,omitempty"`
	// Reference altitude.
	// When using geolocation, this altitude will be used as a reference
	// (when supported by the geolocation-server) to increase geolocation
	// accuracy.
	ReferenceAltitude float64 `protobuf:"fixed64,7,opt,name=reference_altitude,json=referenceAltitude,proto3" json:"reference_altitude,omitempty"`
	// Variables (user defined).
	// These variables can be used together with integrations to store tokens /
	// secrets that must be configured per device. These variables are not
	// exposed in the event payloads.
	Variables map[string]string `` /* 159-byte string literal not displayed */
	// Tags (user defined).
	// These tags are exposed in the event payloads or to integration. Tags are
	// intended for aggregation and filtering.
	Tags map[string]string `` /* 149-byte string literal not displayed */
	// Device is disabled.
	IsDisabled           bool     `protobuf:"varint,10,opt,name=is_disabled,json=isDisabled,proto3" json:"is_disabled,omitempty"`
	Debug                string   `protobuf:"bytes,11,opt,name=debug,proto3" json:"debug,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*Device) Descriptor 

func (*Device) Descriptor() ([]byte, []int)

func (*Device) GetApplicationId 

func (m *Device) GetApplicationId() int64

func (*Device) GetDebug 

func (m *Device) GetDebug() string

func (*Device) GetDescription 

func (m *Device) GetDescription() string

func (*Device) GetDevEui 

func (m *Device) GetDevEui() string

func (*Device) GetDeviceProfileId 

func (m *Device) GetDeviceProfileId() string

func (*Device) GetIsDisabled 

func (m *Device) GetIsDisabled() bool

func (*Device) GetName 

func (m *Device) GetName() string

func (*Device) GetReferenceAltitude 

func (m *Device) GetReferenceAltitude() float64

func (*Device) GetSkipFCntCheck 

func (m *Device) GetSkipFCntCheck() bool

func (*Device) GetTags 

func (m *Device) GetTags() map[string]string

func (*Device) GetVariables 

func (m *Device) GetVariables() map[string]string

func (*Device) ProtoMessage 

func (*Device) ProtoMessage()

func (*Device) Reset 

func (m *Device) Reset()

func (*Device) String 

func (m *Device) String() string

func (*Device) XXX_DiscardUnknown 

func (m *Device) XXX_DiscardUnknown()

func (*Device) XXX_Marshal 

func (m *Device) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Device) XXX_Merge 

func (m *Device) XXX_Merge(src proto.Message)

func (*Device) XXX_Size 

func (m *Device) XXX_Size() int

func (*Device) XXX_Unmarshal 

func (m *Device) XXX_Unmarshal(b []byte) error

type DeviceActivation 

type DeviceActivation struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Device address (HEX encoded).
	DevAddr string `protobuf:"bytes,2,opt,name=dev_addr,json=devAddr,proto3" json:"dev_addr,omitempty"`
	// Application session key (HEX encoded).
	AppSKey string `protobuf:"bytes,3,opt,name=app_s_key,json=appSKey,proto3" json:"app_s_key,omitempty"`
	// Network session encryption key (HEX encoded).
	NwkSEncKey string `protobuf:"bytes,4,opt,name=nwk_s_enc_key,json=nwkSEncKey,proto3" json:"nwk_s_enc_key,omitempty"`
	// Serving network session integrity key (HEX encoded).
	SNwkSIntKey string `protobuf:"bytes,8,opt,name=s_nwk_s_int_key,json=sNwkSIntKey,proto3" json:"s_nwk_s_int_key,omitempty"`
	// Forwarding network session integrity key (HEX encoded).
	FNwkSIntKey string `protobuf:"bytes,9,opt,name=f_nwk_s_int_key,json=fNwkSIntKey,proto3" json:"f_nwk_s_int_key,omitempty"`
	// Uplink frame-counter.
	FCntUp uint32 `protobuf:"varint,5,opt,name=f_cnt_up,json=fCntUp,proto3" json:"f_cnt_up,omitempty"`
	// Downlink network frame-counter.
	NFCntDown uint32 `protobuf:"varint,6,opt,name=n_f_cnt_down,json=nFCntDown,proto3" json:"n_f_cnt_down,omitempty"`
	// Downlink application frame-counter.
	AFCntDown            uint32   `protobuf:"varint,10,opt,name=a_f_cnt_down,json=aFCntDown,proto3" json:"a_f_cnt_down,omitempty"`
	JoinEui              string   `protobuf:"bytes,11,opt,name=join_eui,json=joinEUI,proto3" json:"join_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceActivation) Descriptor 

func (*DeviceActivation) Descriptor() ([]byte, []int)

func (*DeviceActivation) GetAFCntDown 

func (m *DeviceActivation) GetAFCntDown() uint32

func (*DeviceActivation) GetAppSKey 

func (m *DeviceActivation) GetAppSKey() string

func (*DeviceActivation) GetDevAddr 

func (m *DeviceActivation) GetDevAddr() string

func (*DeviceActivation) GetDevEui 

func (m *DeviceActivation) GetDevEui() string

func (*DeviceActivation) GetFCntUp 

func (m *DeviceActivation) GetFCntUp() uint32

func (*DeviceActivation) GetFNwkSIntKey 

func (m *DeviceActivation) GetFNwkSIntKey() string

func (*DeviceActivation) GetJoinEui 

func (m *DeviceActivation) GetJoinEui() string

func (*DeviceActivation) GetNFCntDown 

func (m *DeviceActivation) GetNFCntDown() uint32

func (*DeviceActivation) GetNwkSEncKey 

func (m *DeviceActivation) GetNwkSEncKey() string

func (*DeviceActivation) GetSNwkSIntKey 

func (m *DeviceActivation) GetSNwkSIntKey() string

func (*DeviceActivation) ProtoMessage 

func (*DeviceActivation) ProtoMessage()

func (*DeviceActivation) Reset 

func (m *DeviceActivation) Reset()

func (*DeviceActivation) String 

func (m *DeviceActivation) String() string

func (*DeviceActivation) XXX_DiscardUnknown 

func (m *DeviceActivation) XXX_DiscardUnknown()

func (*DeviceActivation) XXX_Marshal 

func (m *DeviceActivation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceActivation) XXX_Merge 

func (m *DeviceActivation) XXX_Merge(src proto.Message)

func (*DeviceActivation) XXX_Size 

func (m *DeviceActivation) XXX_Size() int

func (*DeviceActivation) XXX_Unmarshal 

func (m *DeviceActivation) XXX_Unmarshal(b []byte) error

type DeviceKeys 

type DeviceKeys struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Network root key (HEX encoded).
	// Note: For LoRaWAN 1.0.x, use this field for the LoRaWAN 1.0.x 'AppKey`!
	NwkKey string `protobuf:"bytes,2,opt,name=nwk_key,json=nwkKey,proto3" json:"nwk_key,omitempty"`
	// Application root key (HEX encoded).
	// Note: This field only needs to be set for LoRaWAN 1.1.x devices!
	AppKey string `protobuf:"bytes,3,opt,name=app_key,json=appKey,proto3" json:"app_key,omitempty"`
	// Gen application key (HEX encoded).
	// This is an optional key that only must be set for LORaWAN 1.0.x devices
	// that implement the remote multicast setup specification.
	GenAppKey            string   `protobuf:"bytes,4,opt,name=gen_app_key,json=genAppKey,proto3" json:"gen_app_key,omitempty"`
	JoinEui              string   `protobuf:"bytes,5,opt,name=join_eui,json=joinEUI,proto3" json:"join_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceKeys) Descriptor 

func (*DeviceKeys) Descriptor() ([]byte, []int)

func (*DeviceKeys) GetAppKey 

func (m *DeviceKeys) GetAppKey() string

func (*DeviceKeys) GetDevEui 

func (m *DeviceKeys) GetDevEui() string

func (*DeviceKeys) GetGenAppKey 

func (m *DeviceKeys) GetGenAppKey() string

func (*DeviceKeys) GetJoinEui 

func (m *DeviceKeys) GetJoinEui() string

func (*DeviceKeys) GetNwkKey 

func (m *DeviceKeys) GetNwkKey() string

func (*DeviceKeys) ProtoMessage 

func (*DeviceKeys) ProtoMessage()

func (*DeviceKeys) Reset 

func (m *DeviceKeys) Reset()

func (*DeviceKeys) String 

func (m *DeviceKeys) String() string

func (*DeviceKeys) XXX_DiscardUnknown 

func (m *DeviceKeys) XXX_DiscardUnknown()

func (*DeviceKeys) XXX_Marshal 

func (m *DeviceKeys) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceKeys) XXX_Merge 

func (m *DeviceKeys) XXX_Merge(src proto.Message)

func (*DeviceKeys) XXX_Size 

func (m *DeviceKeys) XXX_Size() int

func (*DeviceKeys) XXX_Unmarshal 

func (m *DeviceKeys) XXX_Unmarshal(b []byte) error

type DeviceListItem 

type DeviceListItem struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Name of the device.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Application ID.
	ApplicationId int64 `protobuf:"varint,3,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Description of the device.
	Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
	// Device-profile ID attached to the device.
	DeviceProfileId string `protobuf:"bytes,5,opt,name=device_profile_id,json=deviceProfileID,proto3" json:"device_profile_id,omitempty"`
	// Device-profile name.
	DeviceProfileName string `protobuf:"bytes,6,opt,name=device_profile_name,json=deviceProfileName,proto3" json:"device_profile_name,omitempty"`
	// The device battery status (deprecated, use device_status_battery_level).
	// 0:      The end-device is connected to an external power source
	// 1..254: The battery level, 1 being at minimum and 254 being at maximum
	// 255:    The end-device was not able to measure the battery level
	// 256:    The device-status is not available.
	DeviceStatusBattery uint32 `protobuf:"varint,7,opt,name=device_status_battery,json=deviceStatusBattery,proto3" json:"device_status_battery,omitempty"`
	// The device margin status
	// -32..32: The demodulation SNR ration in dB
	// 256:     The device-status is not available.
	DeviceStatusMargin int32 `protobuf:"varint,8,opt,name=device_status_margin,json=deviceStatusMargin,proto3" json:"device_status_margin,omitempty"`
	// Device is connected to an external power source.
	DeviceStatusExternalPowerSource bool `` /* 162-byte string literal not displayed */
	// Device battery status is unavailable.
	DeviceStatusBatteryLevelUnavailable bool `` /* 174-byte string literal not displayed */
	// Device battery level as a percentage.
	DeviceStatusBatteryLevel float32 `` /* 140-byte string literal not displayed */
	// The last time the application-server received any data from the device,
	// or an empty string when the device never sent any data.
	LastSeenAt *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=last_seen_at,json=lastSeenAt,proto3" json:"last_seen_at,omitempty"`
	// Skip frame-counter checks (this is insecure, but could be helpful for debugging).
	SkipFCntCheck bool `protobuf:"varint,13,opt,name=skip_f_cnt_check,json=skipFCntCheck,proto3" json:"skip_f_cnt_check,omitempty"`
	// Device is disabled.
	IsDisabled           bool     `protobuf:"varint,14,opt,name=is_disabled,json=isDisabled,proto3" json:"is_disabled,omitempty"`
	Debug                string   `protobuf:"bytes,15,opt,name=debug,proto3" json:"debug,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceListItem) Descriptor 

func (*DeviceListItem) Descriptor() ([]byte, []int)

func (*DeviceListItem) GetApplicationId 

func (m *DeviceListItem) GetApplicationId() int64

func (*DeviceListItem) GetDebug 

func (m *DeviceListItem) GetDebug() string

func (*DeviceListItem) GetDescription 

func (m *DeviceListItem) GetDescription() string

func (*DeviceListItem) GetDevEui 

func (m *DeviceListItem) GetDevEui() string

func (*DeviceListItem) GetDeviceProfileId 

func (m *DeviceListItem) GetDeviceProfileId() string

func (*DeviceListItem) GetDeviceProfileName 

func (m *DeviceListItem) GetDeviceProfileName() string

func (*DeviceListItem) GetDeviceStatusBattery 

func (m *DeviceListItem) GetDeviceStatusBattery() uint32

func (*DeviceListItem) GetDeviceStatusBatteryLevel 

func (m *DeviceListItem) GetDeviceStatusBatteryLevel() float32

func (*DeviceListItem) GetDeviceStatusBatteryLevelUnavailable 

func (m *DeviceListItem) GetDeviceStatusBatteryLevelUnavailable() bool

func (*DeviceListItem) GetDeviceStatusExternalPowerSource 

func (m *DeviceListItem) GetDeviceStatusExternalPowerSource() bool

func (*DeviceListItem) GetDeviceStatusMargin 

func (m *DeviceListItem) GetDeviceStatusMargin() int32

func (*DeviceListItem) GetIsDisabled 

func (m *DeviceListItem) GetIsDisabled() bool

func (*DeviceListItem) GetLastSeenAt 

func (m *DeviceListItem) GetLastSeenAt() *timestamppb.Timestamp

func (*DeviceListItem) GetName 

func (m *DeviceListItem) GetName() string

func (*DeviceListItem) GetSkipFCntCheck 

func (m *DeviceListItem) GetSkipFCntCheck() bool

func (*DeviceListItem) ProtoMessage 

func (*DeviceListItem) ProtoMessage()

func (*DeviceListItem) Reset 

func (m *DeviceListItem) Reset()

func (*DeviceListItem) String 

func (m *DeviceListItem) String() string

func (*DeviceListItem) XXX_DiscardUnknown 

func (m *DeviceListItem) XXX_DiscardUnknown()

func (*DeviceListItem) XXX_Marshal 

func (m *DeviceListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceListItem) XXX_Merge 

func (m *DeviceListItem) XXX_Merge(src proto.Message)

func (*DeviceListItem) XXX_Size 

func (m *DeviceListItem) XXX_Size() int

func (*DeviceListItem) XXX_Unmarshal 

func (m *DeviceListItem) XXX_Unmarshal(b []byte) error

type DeviceProfile 

type DeviceProfile struct {
	// Device-profile ID (UUID string).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Device-profile name.
	Name string `protobuf:"bytes,21,opt,name=name,proto3" json:"name,omitempty"`
	// Organization ID to which the service-profile is assigned.
	OrganizationId int64 `protobuf:"varint,22,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Network-server ID on which the service-profile is provisioned.
	NetworkServerId int64 `protobuf:"varint,23,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	// End-Device supports Class B.
	SupportsClassB bool `protobuf:"varint,2,opt,name=supports_class_b,json=supportsClassB,proto3" json:"supports_class_b,omitempty"`
	// Maximum delay for the End-Device to answer a MAC request or a confirmed DL frame (mandatory if class B mode supported).
	ClassBTimeout uint32 `protobuf:"varint,3,opt,name=class_b_timeout,json=classBTimeout,proto3" json:"class_b_timeout,omitempty"`
	// Mandatory if class B mode supported.
	PingSlotPeriod uint32 `protobuf:"varint,4,opt,name=ping_slot_period,json=pingSlotPeriod,proto3" json:"ping_slot_period,omitempty"`
	// Mandatory if class B mode supported.
	PingSlotDr uint32 `protobuf:"varint,5,opt,name=ping_slot_dr,json=pingSlotDR,proto3" json:"ping_slot_dr,omitempty"`
	// Mandatory if class B mode supported.
	PingSlotFreq uint32 `protobuf:"varint,6,opt,name=ping_slot_freq,json=pingSlotFreq,proto3" json:"ping_slot_freq,omitempty"`
	// End-Device supports Class C.
	SupportsClassC bool `protobuf:"varint,7,opt,name=supports_class_c,json=supportsClassC,proto3" json:"supports_class_c,omitempty"`
	// Maximum delay for the End-Device to answer a MAC request or a confirmed DL frame (mandatory if class C mode supported).
	ClassCTimeout uint32 `protobuf:"varint,8,opt,name=class_c_timeout,json=classCTimeout,proto3" json:"class_c_timeout,omitempty"`
	// Version of the LoRaWAN supported by the End-Device.
	MacVersion string `protobuf:"bytes,9,opt,name=mac_version,json=macVersion,proto3" json:"mac_version,omitempty"`
	// Revision of the Regional Parameters document supported by the End-Device.
	RegParamsRevision string `protobuf:"bytes,10,opt,name=reg_params_revision,json=regParamsRevision,proto3" json:"reg_params_revision,omitempty"`
	// Class A RX1 delay (mandatory for ABP).
	RxDelay_1 uint32 `protobuf:"varint,11,opt,name=rx_delay_1,json=rxDelay1,proto3" json:"rx_delay_1,omitempty"`
	// RX1 data rate offset (mandatory for ABP).
	RxDrOffset_1 uint32 `protobuf:"varint,12,opt,name=rx_dr_offset_1,json=rxDROffset1,proto3" json:"rx_dr_offset_1,omitempty"`
	// RX2 data rate (mandatory for ABP).
	RxDatarate_2 uint32 `protobuf:"varint,13,opt,name=rx_datarate_2,json=rxDataRate2,proto3" json:"rx_datarate_2,omitempty"`
	// RX2 channel frequency (mandatory for ABP).
	RxFreq_2 uint32 `protobuf:"varint,14,opt,name=rx_freq_2,json=rxFreq2,proto3" json:"rx_freq_2,omitempty"`
	// List of factory-preset frequencies (mandatory for ABP).
	FactoryPresetFreqs []uint32 `` /* 126-byte string literal not displayed */
	// Maximum EIRP supported by the End-Device.
	MaxEirp uint32 `protobuf:"varint,16,opt,name=max_eirp,json=maxEIRP,proto3" json:"max_eirp,omitempty"`
	// Maximum duty cycle supported by the End-Device.
	MaxDutyCycle uint32 `protobuf:"varint,17,opt,name=max_duty_cycle,json=maxDutyCycle,proto3" json:"max_duty_cycle,omitempty"`
	// End-Device supports Join (OTAA) or not (ABP).
	SupportsJoin bool `protobuf:"varint,18,opt,name=supports_join,json=supportsJoin,proto3" json:"supports_join,omitempty"`
	// RF region name.
	RfRegion string `protobuf:"bytes,19,opt,name=rf_region,json=rfRegion,proto3" json:"rf_region,omitempty"`
	// End-Device uses 32bit FCnt (mandatory for LoRaWAN 1.0 End-Device).
	Supports_32BitFCnt bool `protobuf:"varint,20,opt,name=supports_32bit_f_cnt,json=supports32BitFCnt,proto3" json:"supports_32bit_f_cnt,omitempty"`
	// Payload codec.
	// Leave blank to disable the codec feature.
	PayloadCodec string `protobuf:"bytes,24,opt,name=payload_codec,json=payloadCodec,proto3" json:"payload_codec,omitempty"`
	// Payload encoder script.
	// Depending the codec, it is possible to provide a script which implements
	// the encoder function.
	PayloadEncoderScript string `protobuf:"bytes,25,opt,name=payload_encoder_script,json=payloadEncoderScript,proto3" json:"payload_encoder_script,omitempty"`
	// Payload decoder script.
	// Depending the codec, it is possible to provide a script which implements
	// the decoder function.
	PayloadDecoderScript string `protobuf:"bytes,26,opt,name=payload_decoder_script,json=payloadDecoderScript,proto3" json:"payload_decoder_script,omitempty"`
	// Geolocation buffer TTL (in seconds).
	// When > 0, uplink RX meta-data will be stored in a buffer so that
	// the meta-data of multiple uplinks can be used for geolocation.
	GeolocBufferTtl uint32 `protobuf:"varint,27,opt,name=geoloc_buffer_ttl,json=geolocBufferTTL,proto3" json:"geoloc_buffer_ttl,omitempty"`
	// Geolocation minimum buffer size.
	// When > 0, geolocation will only be performed when the buffer has
	// at least the given size.
	GeolocMinBufferSize uint32 `protobuf:"varint,28,opt,name=geoloc_min_buffer_size,json=geolocMinBufferSize,proto3" json:"geoloc_min_buffer_size,omitempty"`
	// User defined tags.
	Tags map[string]string `` /* 150-byte string literal not displayed */
	// Uplink interval.
	// This defines the expected uplink interval which the device uses for
	// communication. When the uplink interval has expired and no uplink has
	// been received, the device is considered inactive.
	UplinkInterval       *durationpb.Duration `protobuf:"bytes,30,opt,name=uplink_interval,json=uplinkInterval,proto3" json:"uplink_interval,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*DeviceProfile) Descriptor 

func (*DeviceProfile) Descriptor() ([]byte, []int)

func (*DeviceProfile) GetClassBTimeout 

func (m *DeviceProfile) GetClassBTimeout() uint32

func (*DeviceProfile) GetClassCTimeout 

func (m *DeviceProfile) GetClassCTimeout() uint32

func (*DeviceProfile) GetFactoryPresetFreqs 

func (m *DeviceProfile) GetFactoryPresetFreqs() []uint32

func (*DeviceProfile) GetGeolocBufferTtl 

func (m *DeviceProfile) GetGeolocBufferTtl() uint32

func (*DeviceProfile) GetGeolocMinBufferSize 

func (m *DeviceProfile) GetGeolocMinBufferSize() uint32

func (*DeviceProfile) GetId 

func (m *DeviceProfile) GetId() string

func (*DeviceProfile) GetMacVersion 

func (m *DeviceProfile) GetMacVersion() string

func (*DeviceProfile) GetMaxDutyCycle 

func (m *DeviceProfile) GetMaxDutyCycle() uint32

func (*DeviceProfile) GetMaxEirp 

func (m *DeviceProfile) GetMaxEirp() uint32

func (*DeviceProfile) GetName 

func (m *DeviceProfile) GetName() string

func (*DeviceProfile) GetNetworkServerId 

func (m *DeviceProfile) GetNetworkServerId() int64

func (*DeviceProfile) GetOrganizationId 

func (m *DeviceProfile) GetOrganizationId() int64

func (*DeviceProfile) GetPayloadCodec 

func (m *DeviceProfile) GetPayloadCodec() string

func (*DeviceProfile) GetPayloadDecoderScript 

func (m *DeviceProfile) GetPayloadDecoderScript() string

func (*DeviceProfile) GetPayloadEncoderScript 

func (m *DeviceProfile) GetPayloadEncoderScript() string

func (*DeviceProfile) GetPingSlotDr 

func (m *DeviceProfile) GetPingSlotDr() uint32

func (*DeviceProfile) GetPingSlotFreq 

func (m *DeviceProfile) GetPingSlotFreq() uint32

func (*DeviceProfile) GetPingSlotPeriod 

func (m *DeviceProfile) GetPingSlotPeriod() uint32

func (*DeviceProfile) GetRegParamsRevision 

func (m *DeviceProfile) GetRegParamsRevision() string

func (*DeviceProfile) GetRfRegion 

func (m *DeviceProfile) GetRfRegion() string

func (*DeviceProfile) GetRxDatarate_2 

func (m *DeviceProfile) GetRxDatarate_2() uint32

func (*DeviceProfile) GetRxDelay_1 

func (m *DeviceProfile) GetRxDelay_1() uint32

func (*DeviceProfile) GetRxDrOffset_1 

func (m *DeviceProfile) GetRxDrOffset_1() uint32

func (*DeviceProfile) GetRxFreq_2 

func (m *DeviceProfile) GetRxFreq_2() uint32

func (*DeviceProfile) GetSupportsClassB 

func (m *DeviceProfile) GetSupportsClassB() bool

func (*DeviceProfile) GetSupportsClassC 

func (m *DeviceProfile) GetSupportsClassC() bool

func (*DeviceProfile) GetSupportsJoin 

func (m *DeviceProfile) GetSupportsJoin() bool

func (*DeviceProfile) GetSupports_32BitFCnt 

func (m *DeviceProfile) GetSupports_32BitFCnt() bool

func (*DeviceProfile) GetTags 

func (m *DeviceProfile) GetTags() map[string]string

func (*DeviceProfile) GetUplinkInterval 

func (m *DeviceProfile) GetUplinkInterval() *durationpb.Duration

func (*DeviceProfile) ProtoMessage 

func (*DeviceProfile) ProtoMessage()

func (*DeviceProfile) Reset 

func (m *DeviceProfile) Reset()

func (*DeviceProfile) String 

func (m *DeviceProfile) String() string

func (*DeviceProfile) XXX_DiscardUnknown 

func (m *DeviceProfile) XXX_DiscardUnknown()

func (*DeviceProfile) XXX_Marshal 

func (m *DeviceProfile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceProfile) XXX_Merge 

func (m *DeviceProfile) XXX_Merge(src proto.Message)

func (*DeviceProfile) XXX_Size 

func (m *DeviceProfile) XXX_Size() int

func (*DeviceProfile) XXX_Unmarshal 

func (m *DeviceProfile) XXX_Unmarshal(b []byte) error

type DeviceProfileListItem 

type DeviceProfileListItem struct {
	// Device-profile ID (UUID string).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Device-profile name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Network-server ID.
	NetworkServerId int64 `protobuf:"varint,4,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Network-server name.
	NetworkServerName    string   `protobuf:"bytes,7,opt,name=network_server_name,json=networkServerName,proto3" json:"network_server_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceProfileListItem) Descriptor 

func (*DeviceProfileListItem) Descriptor() ([]byte, []int)

func (*DeviceProfileListItem) GetCreatedAt 

func (m *DeviceProfileListItem) GetCreatedAt() *timestamppb.Timestamp

func (*DeviceProfileListItem) GetId 

func (m *DeviceProfileListItem) GetId() string

func (*DeviceProfileListItem) GetName 

func (m *DeviceProfileListItem) GetName() string

func (*DeviceProfileListItem) GetNetworkServerId 

func (m *DeviceProfileListItem) GetNetworkServerId() int64

func (*DeviceProfileListItem) GetNetworkServerName 

func (m *DeviceProfileListItem) GetNetworkServerName() string

func (*DeviceProfileListItem) GetOrganizationId 

func (m *DeviceProfileListItem) GetOrganizationId() int64

func (*DeviceProfileListItem) GetUpdatedAt 

func (m *DeviceProfileListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*DeviceProfileListItem) ProtoMessage 

func (*DeviceProfileListItem) ProtoMessage()

func (*DeviceProfileListItem) Reset 

func (m *DeviceProfileListItem) Reset()

func (*DeviceProfileListItem) String 

func (m *DeviceProfileListItem) String() string

func (*DeviceProfileListItem) XXX_DiscardUnknown 

func (m *DeviceProfileListItem) XXX_DiscardUnknown()

func (*DeviceProfileListItem) XXX_Marshal 

func (m *DeviceProfileListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceProfileListItem) XXX_Merge 

func (m *DeviceProfileListItem) XXX_Merge(src proto.Message)

func (*DeviceProfileListItem) XXX_Size 

func (m *DeviceProfileListItem) XXX_Size() int

func (*DeviceProfileListItem) XXX_Unmarshal 

func (m *DeviceProfileListItem) XXX_Unmarshal(b []byte) error

type DeviceProfileServiceClient 

type DeviceProfileServiceClient interface {
	// Create creates the given device-profile.
	Create(ctx context.Context, in *CreateDeviceProfileRequest, opts ...grpc.CallOption) (*CreateDeviceProfileResponse, error)
	// Get returns the device-profile matching the given id.
	Get(ctx context.Context, in *GetDeviceProfileRequest, opts ...grpc.CallOption) (*GetDeviceProfileResponse, error)
	// Update updates the given device-profile.
	Update(ctx context.Context, in *UpdateDeviceProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete deletes the device-profile matching the given id.
	Delete(ctx context.Context, in *DeleteDeviceProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List lists the available device-profiles.
	List(ctx context.Context, in *ListDeviceProfileRequest, opts ...grpc.CallOption) (*ListDeviceProfileResponse, error)
}

DeviceProfileServiceClient is the client API for DeviceProfileService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewDeviceProfileServiceClient 

func NewDeviceProfileServiceClient(cc grpc.ClientConnInterface) DeviceProfileServiceClient

type DeviceProfileServiceServer 

type DeviceProfileServiceServer interface {
	// Create creates the given device-profile.
	Create(context.Context, *CreateDeviceProfileRequest) (*CreateDeviceProfileResponse, error)
	// Get returns the device-profile matching the given id.
	Get(context.Context, *GetDeviceProfileRequest) (*GetDeviceProfileResponse, error)
	// Update updates the given device-profile.
	Update(context.Context, *UpdateDeviceProfileRequest) (*emptypb.Empty, error)
	// Delete deletes the device-profile matching the given id.
	Delete(context.Context, *DeleteDeviceProfileRequest) (*emptypb.Empty, error)
	// List lists the available device-profiles.
	List(context.Context, *ListDeviceProfileRequest) (*ListDeviceProfileResponse, error)
}

DeviceProfileServiceServer is the server API for DeviceProfileService service.

type DeviceQueueItem 

type DeviceQueueItem struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Set this to true when an acknowledgement from the device is required.
	// Please note that this must not be used to guarantee a delivery.
	Confirmed bool `protobuf:"varint,2,opt,name=confirmed,proto3" json:"confirmed,omitempty"`
	// Downlink frame-counter.
	// This will be automatically set on enquue.
	FCnt uint32 `protobuf:"varint,6,opt,name=f_cnt,json=fCnt,proto3" json:"f_cnt,omitempty"`
	// FPort used (must be > 0)
	FPort uint32 `protobuf:"varint,3,opt,name=f_port,json=fPort,proto3" json:"f_port,omitempty"`
	// Base64 encoded data.
	// Or use the json_object field when an application codec has been configured.
	Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	// JSON object (string).
	// Only use this when an application codec has been configured that can convert
	// this object into binary form.
	JsonObject           string   `protobuf:"bytes,5,opt,name=json_object,json=jsonObject,proto3" json:"json_object,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceQueueItem) Descriptor 

func (*DeviceQueueItem) Descriptor() ([]byte, []int)

func (*DeviceQueueItem) GetConfirmed 

func (m *DeviceQueueItem) GetConfirmed() bool

func (*DeviceQueueItem) GetData 

func (m *DeviceQueueItem) GetData() []byte

func (*DeviceQueueItem) GetDevEui 

func (m *DeviceQueueItem) GetDevEui() string

func (*DeviceQueueItem) GetFCnt 

func (m *DeviceQueueItem) GetFCnt() uint32

func (*DeviceQueueItem) GetFPort 

func (m *DeviceQueueItem) GetFPort() uint32

func (*DeviceQueueItem) GetJsonObject 

func (m *DeviceQueueItem) GetJsonObject() string

func (*DeviceQueueItem) ProtoMessage 

func (*DeviceQueueItem) ProtoMessage()

func (*DeviceQueueItem) Reset 

func (m *DeviceQueueItem) Reset()

func (*DeviceQueueItem) String 

func (m *DeviceQueueItem) String() string

func (*DeviceQueueItem) XXX_DiscardUnknown 

func (m *DeviceQueueItem) XXX_DiscardUnknown()

func (*DeviceQueueItem) XXX_Marshal 

func (m *DeviceQueueItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceQueueItem) XXX_Merge 

func (m *DeviceQueueItem) XXX_Merge(src proto.Message)

func (*DeviceQueueItem) XXX_Size 

func (m *DeviceQueueItem) XXX_Size() int

func (*DeviceQueueItem) XXX_Unmarshal 

func (m *DeviceQueueItem) XXX_Unmarshal(b []byte) error

type DeviceQueueServiceClient 

type DeviceQueueServiceClient interface {
	// Enqueue adds the given item to the device-queue.
	Enqueue(ctx context.Context, in *EnqueueDeviceQueueItemRequest, opts ...grpc.CallOption) (*EnqueueDeviceQueueItemResponse, error)
	// Flush flushes the downlink device-queue.
	Flush(ctx context.Context, in *FlushDeviceQueueRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List lists the items in the device-queue.
	List(ctx context.Context, in *ListDeviceQueueItemsRequest, opts ...grpc.CallOption) (*ListDeviceQueueItemsResponse, error)
	FlushAll(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListALL(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListDeviceQueueItemsResponse, error)
}

DeviceQueueServiceClient is the client API for DeviceQueueService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewDeviceQueueServiceClient 

func NewDeviceQueueServiceClient(cc grpc.ClientConnInterface) DeviceQueueServiceClient

type DeviceQueueServiceServer 

type DeviceQueueServiceServer interface {
	// Enqueue adds the given item to the device-queue.
	Enqueue(context.Context, *EnqueueDeviceQueueItemRequest) (*EnqueueDeviceQueueItemResponse, error)
	// Flush flushes the downlink device-queue.
	Flush(context.Context, *FlushDeviceQueueRequest) (*emptypb.Empty, error)
	// List lists the items in the device-queue.
	List(context.Context, *ListDeviceQueueItemsRequest) (*ListDeviceQueueItemsResponse, error)
	FlushAll(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
	ListALL(context.Context, *emptypb.Empty) (*ListDeviceQueueItemsResponse, error)
}

DeviceQueueServiceServer is the server API for DeviceQueueService service.

type DeviceServiceClient 

type DeviceServiceClient interface {
	// Create creates the given device.
	Create(ctx context.Context, in *CreateDeviceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreateAndActivateABPEnableDevice(ctx context.Context, in *CreateAndActivateABPEnableDeviceRequest, opts ...grpc.CallOption) (*CreateAndActivateABPEnableDeviceResponse, error)
	CreateOTAAEnableDeviceAndKey(ctx context.Context, in *CreateOTAAEnableDeviceAndKeyRequest, opts ...grpc.CallOption) (*CreateOTAAEnableDeviceAndKeyResponse, error)
	GetDeviceDetails(ctx context.Context, in *GetDeviceDetailsRequest, opts ...grpc.CallOption) (*GetDeviceDetailsResponse, error)
	QtcodeScanCreate(ctx context.Context, in *QtcodeCreateDeviceRequest, opts ...grpc.CallOption) (*QtcodeCreateDeviceResponse, error)
	StreamNFC(ctx context.Context, opts ...grpc.CallOption) (DeviceService_StreamNFCClient, error)
	// Get returns the device matching the given DevEUI.
	Get(ctx context.Context, in *GetDeviceRequest, opts ...grpc.CallOption) (*GetDeviceResponse, error)
	// List returns the available devices.
	List(ctx context.Context, in *ListDeviceRequest, opts ...grpc.CallOption) (*ListDeviceResponse, error)
	// Delete deletes the device matching the given DevEUI.
	Delete(ctx context.Context, in *DeleteDeviceRequest, opts ...grpc.CallOption) (*DeleteDeviceResponse, error)
	// Update updates the device matching the given DevEUI.
	Update(ctx context.Context, in *UpdateDeviceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// CreateKeys creates the given device-keys.
	CreateKeys(ctx context.Context, in *CreateDeviceKeysRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetKeys returns the device-keys for the given DevEUI.
	GetKeys(ctx context.Context, in *GetDeviceKeysRequest, opts ...grpc.CallOption) (*GetDeviceKeysResponse, error)
	// UpdateKeys updates the device-keys.
	UpdateKeys(ctx context.Context, in *UpdateDeviceKeysRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteKeys deletes the device-keys for the given DevEUI.
	DeleteKeys(ctx context.Context, in *DeleteDeviceKeysRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Activate (re)activates the device with the given parameters (for ABP or for importing OTAA activations).
	Activate(ctx context.Context, in *ActivateDeviceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Deactivate de-activates the device.
	Deactivate(ctx context.Context, in *DeactivateDeviceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetActivation returns the current activation details of the device (OTAA and ABP).
	GetActivation(ctx context.Context, in *GetDeviceActivationRequest, opts ...grpc.CallOption) (*GetDeviceActivationResponse, error)
	// GetRandomDevAddr returns a random DevAddr taking the NwkID prefix into account.
	GetRandomDevAddr(ctx context.Context, in *GetRandomDevAddrRequest, opts ...grpc.CallOption) (*GetRandomDevAddrResponse, error)
	// StreamFrameLogs streams the uplink and downlink frame-logs for the given DevEUI.
	//   - These are the raw LoRaWAN frames and this endpoint is intended for debugging only.
	//   - This endpoint does not work from a web-browser.
	StreamFrameLogs(ctx context.Context, in *StreamDeviceFrameLogsRequest, opts ...grpc.CallOption) (DeviceService_StreamFrameLogsClient, error)
	// StreamEventLogs stream the device events (uplink payloads, ACKs, joins, errors).
	//   - This endpoint is intended for debugging only.
	//   - This endpoint does not work from a web-browser.
	StreamEventLogs(ctx context.Context, in *StreamDeviceEventLogsRequest, opts ...grpc.CallOption) (DeviceService_StreamEventLogsClient, error)
	StreamDeviceScanning(ctx context.Context, in *StreamDeviceScanningRequest, opts ...grpc.CallOption) (DeviceService_StreamDeviceScanningClient, error)
}

DeviceServiceClient is the client API for DeviceService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewDeviceServiceClient 

func NewDeviceServiceClient(cc grpc.ClientConnInterface) DeviceServiceClient

type DeviceServiceServer 

type DeviceServiceServer interface {
	// Create creates the given device.
	Create(context.Context, *CreateDeviceRequest) (*emptypb.Empty, error)
	CreateAndActivateABPEnableDevice(context.Context, *CreateAndActivateABPEnableDeviceRequest) (*CreateAndActivateABPEnableDeviceResponse, error)
	CreateOTAAEnableDeviceAndKey(context.Context, *CreateOTAAEnableDeviceAndKeyRequest) (*CreateOTAAEnableDeviceAndKeyResponse, error)
	GetDeviceDetails(context.Context, *GetDeviceDetailsRequest) (*GetDeviceDetailsResponse, error)
	QtcodeScanCreate(context.Context, *QtcodeCreateDeviceRequest) (*QtcodeCreateDeviceResponse, error)
	StreamNFC(DeviceService_StreamNFCServer) error
	// Get returns the device matching the given DevEUI.
	Get(context.Context, *GetDeviceRequest) (*GetDeviceResponse, error)
	// List returns the available devices.
	List(context.Context, *ListDeviceRequest) (*ListDeviceResponse, error)
	// Delete deletes the device matching the given DevEUI.
	Delete(context.Context, *DeleteDeviceRequest) (*DeleteDeviceResponse, error)
	// Update updates the device matching the given DevEUI.
	Update(context.Context, *UpdateDeviceRequest) (*emptypb.Empty, error)
	// CreateKeys creates the given device-keys.
	CreateKeys(context.Context, *CreateDeviceKeysRequest) (*emptypb.Empty, error)
	// GetKeys returns the device-keys for the given DevEUI.
	GetKeys(context.Context, *GetDeviceKeysRequest) (*GetDeviceKeysResponse, error)
	// UpdateKeys updates the device-keys.
	UpdateKeys(context.Context, *UpdateDeviceKeysRequest) (*emptypb.Empty, error)
	// DeleteKeys deletes the device-keys for the given DevEUI.
	DeleteKeys(context.Context, *DeleteDeviceKeysRequest) (*emptypb.Empty, error)
	// Activate (re)activates the device with the given parameters (for ABP or for importing OTAA activations).
	Activate(context.Context, *ActivateDeviceRequest) (*emptypb.Empty, error)
	// Deactivate de-activates the device.
	Deactivate(context.Context, *DeactivateDeviceRequest) (*emptypb.Empty, error)
	// GetActivation returns the current activation details of the device (OTAA and ABP).
	GetActivation(context.Context, *GetDeviceActivationRequest) (*GetDeviceActivationResponse, error)
	// GetRandomDevAddr returns a random DevAddr taking the NwkID prefix into account.
	GetRandomDevAddr(context.Context, *GetRandomDevAddrRequest) (*GetRandomDevAddrResponse, error)
	// StreamFrameLogs streams the uplink and downlink frame-logs for the given DevEUI.
	//   - These are the raw LoRaWAN frames and this endpoint is intended for debugging only.
	//   - This endpoint does not work from a web-browser.
	StreamFrameLogs(*StreamDeviceFrameLogsRequest, DeviceService_StreamFrameLogsServer) error
	// StreamEventLogs stream the device events (uplink payloads, ACKs, joins, errors).
	//   - This endpoint is intended for debugging only.
	//   - This endpoint does not work from a web-browser.
	StreamEventLogs(*StreamDeviceEventLogsRequest, DeviceService_StreamEventLogsServer) error
	StreamDeviceScanning(*StreamDeviceScanningRequest, DeviceService_StreamDeviceScanningServer) error
}

DeviceServiceServer is the server API for DeviceService service.

type DeviceService_StreamDeviceScanningClient 

type DeviceService_StreamDeviceScanningClient interface {
	Recv() (*StreamDeviceScanningReponse, error)
	grpc.ClientStream
}

type DeviceService_StreamDeviceScanningServer 

type DeviceService_StreamDeviceScanningServer interface {
	Send(*StreamDeviceScanningReponse) error
	grpc.ServerStream
}

type DeviceService_StreamEventLogsClient 

type DeviceService_StreamEventLogsClient interface {
	Recv() (*StreamDeviceEventLogsResponse, error)
	grpc.ClientStream
}

type DeviceService_StreamEventLogsServer 

type DeviceService_StreamEventLogsServer interface {
	Send(*StreamDeviceEventLogsResponse) error
	grpc.ServerStream
}

type DeviceService_StreamFrameLogsClient 

type DeviceService_StreamFrameLogsClient interface {
	Recv() (*StreamDeviceFrameLogsResponse, error)
	grpc.ClientStream
}

type DeviceService_StreamFrameLogsServer 

type DeviceService_StreamFrameLogsServer interface {
	Send(*StreamDeviceFrameLogsResponse) error
	grpc.ServerStream
}

type DeviceService_StreamNFCClient 

type DeviceService_StreamNFCClient interface {
	Send(*StreamNFCRequest) error
	Recv() (*StreamNFCResponse, error)
	grpc.ClientStream
}

type DeviceService_StreamNFCServer 

type DeviceService_StreamNFCServer interface {
	Send(*StreamNFCResponse) error
	Recv() (*StreamNFCRequest, error)
	grpc.ServerStream
}

type DeviceStatsRequest 

type DeviceStatsRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceStatsRequest) Descriptor 

func (*DeviceStatsRequest) Descriptor() ([]byte, []int)

func (*DeviceStatsRequest) GetDevEui 

func (m *DeviceStatsRequest) GetDevEui() string

func (*DeviceStatsRequest) ProtoMessage 

func (*DeviceStatsRequest) ProtoMessage()

func (*DeviceStatsRequest) Reset 

func (m *DeviceStatsRequest) Reset()

func (*DeviceStatsRequest) String 

func (m *DeviceStatsRequest) String() string

func (*DeviceStatsRequest) XXX_DiscardUnknown 

func (m *DeviceStatsRequest) XXX_DiscardUnknown()

func (*DeviceStatsRequest) XXX_Marshal 

func (m *DeviceStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceStatsRequest) XXX_Merge 

func (m *DeviceStatsRequest) XXX_Merge(src proto.Message)

func (*DeviceStatsRequest) XXX_Size 

func (m *DeviceStatsRequest) XXX_Size() int

func (*DeviceStatsRequest) XXX_Unmarshal 

func (m *DeviceStatsRequest) XXX_Unmarshal(b []byte) error

type DeviceStatsResponse 

type DeviceStatsResponse struct {
	Stats                *gw.DeviceStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*DeviceStatsResponse) Descriptor 

func (*DeviceStatsResponse) Descriptor() ([]byte, []int)

func (*DeviceStatsResponse) GetStats 

func (m *DeviceStatsResponse) GetStats() *gw.DeviceStats

func (*DeviceStatsResponse) ProtoMessage 

func (*DeviceStatsResponse) ProtoMessage()

func (*DeviceStatsResponse) Reset 

func (m *DeviceStatsResponse) Reset()

func (*DeviceStatsResponse) String 

func (m *DeviceStatsResponse) String() string

func (*DeviceStatsResponse) XXX_DiscardUnknown 

func (m *DeviceStatsResponse) XXX_DiscardUnknown()

func (*DeviceStatsResponse) XXX_Marshal 

func (m *DeviceStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DeviceStatsResponse) XXX_Merge 

func (m *DeviceStatsResponse) XXX_Merge(src proto.Message)

func (*DeviceStatsResponse) XXX_Size 

func (m *DeviceStatsResponse) XXX_Size() int

func (*DeviceStatsResponse) XXX_Unmarshal 

func (m *DeviceStatsResponse) XXX_Unmarshal(b []byte) error

type DigitalChannel 

type DigitalChannel struct {
	Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Types that are valid to be assigned to Config:
	//
	//	*DigitalChannel_Output
	//	*DigitalChannel_Input
	Config               isDigitalChannel_Config `protobuf_oneof:"config"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*DigitalChannel) Descriptor 

func (*DigitalChannel) Descriptor() ([]byte, []int)

func (*DigitalChannel) GetConfig 

func (m *DigitalChannel) GetConfig() isDigitalChannel_Config

func (*DigitalChannel) GetId 

func (m *DigitalChannel) GetId() int32

func (*DigitalChannel) GetInput 

func (m *DigitalChannel) GetInput() *DigitalInputConfig

func (*DigitalChannel) GetOutput 

func (m *DigitalChannel) GetOutput() *DigitalOutputConfig

func (*DigitalChannel) ProtoMessage 

func (*DigitalChannel) ProtoMessage()

func (*DigitalChannel) Reset 

func (m *DigitalChannel) Reset()

func (*DigitalChannel) String 

func (m *DigitalChannel) String() string

func (*DigitalChannel) XXX_DiscardUnknown 

func (m *DigitalChannel) XXX_DiscardUnknown()

func (*DigitalChannel) XXX_Marshal 

func (m *DigitalChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DigitalChannel) XXX_Merge 

func (m *DigitalChannel) XXX_Merge(src proto.Message)

func (*DigitalChannel) XXX_OneofWrappers 

func (*DigitalChannel) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*DigitalChannel) XXX_Size 

func (m *DigitalChannel) XXX_Size() int

func (*DigitalChannel) XXX_Unmarshal 

func (m *DigitalChannel) XXX_Unmarshal(b []byte) error

type DigitalChannel_Input 

type DigitalChannel_Input struct {
	Input *DigitalInputConfig `protobuf:"bytes,3,opt,name=input,proto3,oneof"`
}

type DigitalChannel_Output 

type DigitalChannel_Output struct {
	Output *DigitalOutputConfig `protobuf:"bytes,2,opt,name=output,proto3,oneof"`
}

type DigitalInputConfig 

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

func (*DigitalInputConfig) Descriptor 

func (*DigitalInputConfig) Descriptor() ([]byte, []int)

func (*DigitalInputConfig) GetEnable 

func (m *DigitalInputConfig) GetEnable() bool

func (*DigitalInputConfig) GetEvent 

func (m *DigitalInputConfig) GetEvent() int32

func (*DigitalInputConfig) ProtoMessage 

func (*DigitalInputConfig) ProtoMessage()

func (*DigitalInputConfig) Reset 

func (m *DigitalInputConfig) Reset()

func (*DigitalInputConfig) String 

func (m *DigitalInputConfig) String() string

func (*DigitalInputConfig) XXX_DiscardUnknown 

func (m *DigitalInputConfig) XXX_DiscardUnknown()

func (*DigitalInputConfig) XXX_Marshal 

func (m *DigitalInputConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DigitalInputConfig) XXX_Merge 

func (m *DigitalInputConfig) XXX_Merge(src proto.Message)

func (*DigitalInputConfig) XXX_Size 

func (m *DigitalInputConfig) XXX_Size() int

func (*DigitalInputConfig) XXX_Unmarshal 

func (m *DigitalInputConfig) XXX_Unmarshal(b []byte) error

type DigitalOutputConfig 

type DigitalOutputConfig 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 (*DigitalOutputConfig) Descriptor 

func (*DigitalOutputConfig) Descriptor() ([]byte, []int)

func (*DigitalOutputConfig) GetEnable 

func (m *DigitalOutputConfig) GetEnable() bool

func (*DigitalOutputConfig) ProtoMessage 

func (*DigitalOutputConfig) ProtoMessage()

func (*DigitalOutputConfig) Reset 

func (m *DigitalOutputConfig) Reset()

func (*DigitalOutputConfig) String 

func (m *DigitalOutputConfig) String() string

func (*DigitalOutputConfig) XXX_DiscardUnknown 

func (m *DigitalOutputConfig) XXX_DiscardUnknown()

func (*DigitalOutputConfig) XXX_Marshal 

func (m *DigitalOutputConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DigitalOutputConfig) XXX_Merge 

func (m *DigitalOutputConfig) XXX_Merge(src proto.Message)

func (*DigitalOutputConfig) XXX_Size 

func (m *DigitalOutputConfig) XXX_Size() int

func (*DigitalOutputConfig) XXX_Unmarshal 

func (m *DigitalOutputConfig) XXX_Unmarshal(b []byte) error

type DownlinkFrameLog 

type DownlinkFrameLog struct {
	// string gateway_id = 10 [json_name = "gatewayID"];
	GatewayEUI string `protobuf:"bytes,10,opt,name=gatewayEUI,proto3" json:"gatewayEUI,omitempty"`
	DevEUI     string `protobuf:"bytes,11,opt,name=devEUI,proto3" json:"devEUI,omitempty"`
	JoinEUI    string `protobuf:"bytes,12,opt,name=joinEUI,proto3" json:"joinEUI,omitempty"`
	DevAddr    string `protobuf:"bytes,13,opt,name=devAddr,proto3" json:"devAddr,omitempty"`
	Name       string `protobuf:"bytes,14,opt,name=name,proto3" json:"name,omitempty"`
	// TX information of the downlink.
	TxInfo *gw.DownlinkTXInfo `protobuf:"bytes,1,opt,name=tx_info,json=txInfo,proto3" json:"tx_info,omitempty"`
	// LoRaWAN PHYPayload.
	PhyPayloadJson string `protobuf:"bytes,2,opt,name=phy_payload_json,json=phyPayloadJSON,proto3" json:"phy_payload_json,omitempty"`
	// Gateway ID.
	GatewayId            string   `protobuf:"bytes,3,opt,name=gateway_id,json=gatewayID,proto3" json:"gateway_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DownlinkFrameLog) Descriptor 

func (*DownlinkFrameLog) Descriptor() ([]byte, []int)

func (*DownlinkFrameLog) GetDevAddr 

func (m *DownlinkFrameLog) GetDevAddr() string

func (*DownlinkFrameLog) GetDevEUI 

func (m *DownlinkFrameLog) GetDevEUI() string

func (*DownlinkFrameLog) GetGatewayEUI 

func (m *DownlinkFrameLog) GetGatewayEUI() string

func (*DownlinkFrameLog) GetGatewayId 

func (m *DownlinkFrameLog) GetGatewayId() string

func (*DownlinkFrameLog) GetJoinEUI 

func (m *DownlinkFrameLog) GetJoinEUI() string

func (*DownlinkFrameLog) GetName 

func (m *DownlinkFrameLog) GetName() string

func (*DownlinkFrameLog) GetPhyPayloadJson 

func (m *DownlinkFrameLog) GetPhyPayloadJson() string

func (*DownlinkFrameLog) GetTxInfo 

func (m *DownlinkFrameLog) GetTxInfo() *gw.DownlinkTXInfo

func (*DownlinkFrameLog) ProtoMessage 

func (*DownlinkFrameLog) ProtoMessage()

func (*DownlinkFrameLog) Reset 

func (m *DownlinkFrameLog) Reset()

func (*DownlinkFrameLog) String 

func (m *DownlinkFrameLog) String() string

func (*DownlinkFrameLog) XXX_DiscardUnknown 

func (m *DownlinkFrameLog) XXX_DiscardUnknown()

func (*DownlinkFrameLog) XXX_Marshal 

func (m *DownlinkFrameLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DownlinkFrameLog) XXX_Merge 

func (m *DownlinkFrameLog) XXX_Merge(src proto.Message)

func (*DownlinkFrameLog) XXX_Size 

func (m *DownlinkFrameLog) XXX_Size() int

func (*DownlinkFrameLog) XXX_Unmarshal 

func (m *DownlinkFrameLog) XXX_Unmarshal(b []byte) error

type DownlinkFrameLogForDevice 

type DownlinkFrameLogForDevice struct {
	// TX information of the downlink.
	TxInfo *gw.DownlinkTXInfo `protobuf:"bytes,1,opt,name=tx_info,json=txInfo,proto3" json:"tx_info,omitempty"`
	// LoRaWAN PHYPayload.
	PhyPayloadJson string `protobuf:"bytes,2,opt,name=phy_payload_json,json=phyPayloadJSON,proto3" json:"phy_payload_json,omitempty"`
	// Gateway ID.
	GatewayId            string   `protobuf:"bytes,3,opt,name=gateway_id,json=gatewayID,proto3" json:"gateway_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DownlinkFrameLogForDevice) Descriptor 

func (*DownlinkFrameLogForDevice) Descriptor() ([]byte, []int)

func (*DownlinkFrameLogForDevice) GetGatewayId 

func (m *DownlinkFrameLogForDevice) GetGatewayId() string

func (*DownlinkFrameLogForDevice) GetPhyPayloadJson 

func (m *DownlinkFrameLogForDevice) GetPhyPayloadJson() string

func (*DownlinkFrameLogForDevice) GetTxInfo 

func (m *DownlinkFrameLogForDevice) GetTxInfo() *gw.DownlinkTXInfo

func (*DownlinkFrameLogForDevice) ProtoMessage 

func (*DownlinkFrameLogForDevice) ProtoMessage()

func (*DownlinkFrameLogForDevice) Reset 

func (m *DownlinkFrameLogForDevice) Reset()

func (*DownlinkFrameLogForDevice) String 

func (m *DownlinkFrameLogForDevice) String() string

func (*DownlinkFrameLogForDevice) XXX_DiscardUnknown 

func (m *DownlinkFrameLogForDevice) XXX_DiscardUnknown()

func (*DownlinkFrameLogForDevice) XXX_Marshal 

func (m *DownlinkFrameLogForDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DownlinkFrameLogForDevice) XXX_Merge 

func (m *DownlinkFrameLogForDevice) XXX_Merge(src proto.Message)

func (*DownlinkFrameLogForDevice) XXX_Size 

func (m *DownlinkFrameLogForDevice) XXX_Size() int

func (*DownlinkFrameLogForDevice) XXX_Unmarshal 

func (m *DownlinkFrameLogForDevice) XXX_Unmarshal(b []byte) error

type EU868ChannelLoraStandard 

type EU868ChannelLoraStandard struct {
	// 有改变
	Enable                bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	Radio                 int32    `protobuf:"varint,2,opt,name=radio,proto3" json:"radio,omitempty"`
	If                    int32    `protobuf:"varint,3,opt,name=if,proto3" json:"if,omitempty"`
	Bandwidth             int32    `protobuf:"varint,4,opt,name=bandwidth,proto3" json:"bandwidth,omitempty"`
	SpreadFactor          int32    `protobuf:"varint,5,opt,name=spread_factor,proto3" json:"spread_factor,omitempty"`
	ImplicitHdr           bool     `protobuf:"varint,6,opt,name=implicitHdr,json=implicit_hdr,proto3" json:"implicitHdr,omitempty"`
	Implicitpayloadlength int32    `protobuf:"varint,7,opt,name=implicitpayloadlength,json=implicit_payload_length,proto3" json:"implicitpayloadlength,omitempty"`
	ImplicitcrcEn         bool     `protobuf:"varint,8,opt,name=implicitcrcEn,json=implicit_crc_en,proto3" json:"implicitcrcEn,omitempty"`
	Implicitcoderate      int32    `protobuf:"varint,9,opt,name=implicitcoderate,json=implicit_coderate,proto3" json:"implicitcoderate,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

func (*EU868ChannelLoraStandard) Descriptor 

func (*EU868ChannelLoraStandard) Descriptor() ([]byte, []int)

func (*EU868ChannelLoraStandard) GetBandwidth 

func (m *EU868ChannelLoraStandard) GetBandwidth() int32

func (*EU868ChannelLoraStandard) GetEnable 

func (m *EU868ChannelLoraStandard) GetEnable() bool

func (*EU868ChannelLoraStandard) GetIf 

func (m *EU868ChannelLoraStandard) GetIf() int32

func (*EU868ChannelLoraStandard) GetImplicitHdr 

func (m *EU868ChannelLoraStandard) GetImplicitHdr() bool

func (*EU868ChannelLoraStandard) GetImplicitcoderate 

func (m *EU868ChannelLoraStandard) GetImplicitcoderate() int32

func (*EU868ChannelLoraStandard) GetImplicitcrcEn 

func (m *EU868ChannelLoraStandard) GetImplicitcrcEn() bool

func (*EU868ChannelLoraStandard) GetImplicitpayloadlength 

func (m *EU868ChannelLoraStandard) GetImplicitpayloadlength() int32

func (*EU868ChannelLoraStandard) GetRadio 

func (m *EU868ChannelLoraStandard) GetRadio() int32

func (*EU868ChannelLoraStandard) GetSpreadFactor 

func (m *EU868ChannelLoraStandard) GetSpreadFactor() int32

func (*EU868ChannelLoraStandard) ProtoMessage 

func (*EU868ChannelLoraStandard) ProtoMessage()

func (*EU868ChannelLoraStandard) Reset 

func (m *EU868ChannelLoraStandard) Reset()

func (*EU868ChannelLoraStandard) String 

func (m *EU868ChannelLoraStandard) String() string

func (*EU868ChannelLoraStandard) XXX_DiscardUnknown 

func (m *EU868ChannelLoraStandard) XXX_DiscardUnknown()

func (*EU868ChannelLoraStandard) XXX_Marshal 

func (m *EU868ChannelLoraStandard) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EU868ChannelLoraStandard) XXX_Merge 

func (m *EU868ChannelLoraStandard) XXX_Merge(src proto.Message)

func (*EU868ChannelLoraStandard) XXX_Size 

func (m *EU868ChannelLoraStandard) XXX_Size() int

func (*EU868ChannelLoraStandard) XXX_Unmarshal 

func (m *EU868ChannelLoraStandard) XXX_Unmarshal(b []byte) error

type EU868ChannelMultiSF 

type EU868ChannelMultiSF struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	Radio                int32    `protobuf:"varint,2,opt,name=radio,proto3" json:"radio,omitempty"`
	Offset               int32    `protobuf:"varint,3,opt,name=offset,json=if,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*EU868ChannelMultiSF) Descriptor 

func (*EU868ChannelMultiSF) Descriptor() ([]byte, []int)

func (*EU868ChannelMultiSF) GetEnable 

func (m *EU868ChannelMultiSF) GetEnable() bool

func (*EU868ChannelMultiSF) GetOffset 

func (m *EU868ChannelMultiSF) GetOffset() int32

func (*EU868ChannelMultiSF) GetRadio 

func (m *EU868ChannelMultiSF) GetRadio() int32

func (*EU868ChannelMultiSF) ProtoMessage 

func (*EU868ChannelMultiSF) ProtoMessage()

func (*EU868ChannelMultiSF) Reset 

func (m *EU868ChannelMultiSF) Reset()

func (*EU868ChannelMultiSF) String 

func (m *EU868ChannelMultiSF) String() string

func (*EU868ChannelMultiSF) XXX_DiscardUnknown 

func (m *EU868ChannelMultiSF) XXX_DiscardUnknown()

func (*EU868ChannelMultiSF) XXX_Marshal 

func (m *EU868ChannelMultiSF) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EU868ChannelMultiSF) XXX_Merge 

func (m *EU868ChannelMultiSF) XXX_Merge(src proto.Message)

func (*EU868ChannelMultiSF) XXX_Size 

func (m *EU868ChannelMultiSF) XXX_Size() int

func (*EU868ChannelMultiSF) XXX_Unmarshal 

func (m *EU868ChannelMultiSF) XXX_Unmarshal(b []byte) error

type EU868Config 

type EU868Config struct {
	LoraWanPublic        bool                      `protobuf:"varint,1,opt,name=loraWanPublic,proto3" json:"loraWanPublic,omitempty"`
	SubBandId            int32                     `protobuf:"varint,14,opt,name=subBandId,proto3" json:"subBandId,omitempty"`
	TxFreq               *TXFreqItem               `protobuf:"bytes,15,opt,name=txFreq,proto3" json:"txFreq,omitempty"`
	SyncWord             int64                     `protobuf:"varint,2,opt,name=syncWord,proto3" json:"syncWord,omitempty"`
	Radio_0              *EU868Radio0              `protobuf:"bytes,3,opt,name=radio_0,proto3" json:"radio_0,omitempty"`
	Radio_1              *EU868Radio1              `protobuf:"bytes,4,opt,name=radio_1,proto3" json:"radio_1,omitempty"`
	Chan_LoraStd         *EU868ChannelLoraStandard `protobuf:"bytes,5,opt,name=chan_Lora_std,proto3" json:"chan_Lora_std,omitempty"`
	ChanMultiSF_0        *EU868ChannelMultiSF      `protobuf:"bytes,6,opt,name=chan_multiSF_0,proto3" json:"chan_multiSF_0,omitempty"`
	ChanMultiSF_1        *EU868ChannelMultiSF      `protobuf:"bytes,7,opt,name=chan_multiSF_1,proto3" json:"chan_multiSF_1,omitempty"`
	ChanMultiSF_2        *EU868ChannelMultiSF      `protobuf:"bytes,8,opt,name=chan_multiSF_2,proto3" json:"chan_multiSF_2,omitempty"`
	ChanMultiSF_3        *EU868ChannelMultiSF      `protobuf:"bytes,9,opt,name=chan_multiSF_3,proto3" json:"chan_multiSF_3,omitempty"`
	ChanMultiSF_4        *EU868ChannelMultiSF      `protobuf:"bytes,10,opt,name=chan_multiSF_4,proto3" json:"chan_multiSF_4,omitempty"`
	ChanMultiSF_5        *EU868ChannelMultiSF      `protobuf:"bytes,11,opt,name=chan_multiSF_5,proto3" json:"chan_multiSF_5,omitempty"`
	ChanMultiSF_6        *EU868ChannelMultiSF      `protobuf:"bytes,12,opt,name=chan_multiSF_6,proto3" json:"chan_multiSF_6,omitempty"`
	ChanMultiSF_7        *EU868ChannelMultiSF      `protobuf:"bytes,13,opt,name=chan_multiSF_7,proto3" json:"chan_multiSF_7,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (*EU868Config) Descriptor 

func (*EU868Config) Descriptor() ([]byte, []int)

func (*EU868Config) GetChanMultiSF_0 

func (m *EU868Config) GetChanMultiSF_0() *EU868ChannelMultiSF

func (*EU868Config) GetChanMultiSF_1 

func (m *EU868Config) GetChanMultiSF_1() *EU868ChannelMultiSF

func (*EU868Config) GetChanMultiSF_2 

func (m *EU868Config) GetChanMultiSF_2() *EU868ChannelMultiSF

func (*EU868Config) GetChanMultiSF_3 

func (m *EU868Config) GetChanMultiSF_3() *EU868ChannelMultiSF

func (*EU868Config) GetChanMultiSF_4 

func (m *EU868Config) GetChanMultiSF_4() *EU868ChannelMultiSF

func (*EU868Config) GetChanMultiSF_5 

func (m *EU868Config) GetChanMultiSF_5() *EU868ChannelMultiSF

func (*EU868Config) GetChanMultiSF_6 

func (m *EU868Config) GetChanMultiSF_6() *EU868ChannelMultiSF

func (*EU868Config) GetChanMultiSF_7 

func (m *EU868Config) GetChanMultiSF_7() *EU868ChannelMultiSF

func (*EU868Config) GetChan_LoraStd 

func (m *EU868Config) GetChan_LoraStd() *EU868ChannelLoraStandard

func (*EU868Config) GetLoraWanPublic 

func (m *EU868Config) GetLoraWanPublic() bool

func (*EU868Config) GetRadio_0 

func (m *EU868Config) GetRadio_0() *EU868Radio0

func (*EU868Config) GetRadio_1 

func (m *EU868Config) GetRadio_1() *EU868Radio1

func (*EU868Config) GetSubBandId 

func (m *EU868Config) GetSubBandId() int32

func (*EU868Config) GetSyncWord 

func (m *EU868Config) GetSyncWord() int64

func (*EU868Config) GetTxFreq 

func (m *EU868Config) GetTxFreq() *TXFreqItem

func (*EU868Config) ProtoMessage 

func (*EU868Config) ProtoMessage()

func (*EU868Config) Reset 

func (m *EU868Config) Reset()

func (*EU868Config) String 

func (m *EU868Config) String() string

func (*EU868Config) XXX_DiscardUnknown 

func (m *EU868Config) XXX_DiscardUnknown()

func (*EU868Config) XXX_Marshal 

func (m *EU868Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EU868Config) XXX_Merge 

func (m *EU868Config) XXX_Merge(src proto.Message)

func (*EU868Config) XXX_Size 

func (m *EU868Config) XXX_Size() int

func (*EU868Config) XXX_Unmarshal 

func (m *EU868Config) XXX_Unmarshal(b []byte) error

type EU868Radio0 

type EU868Radio0 struct {
	Enable               bool             `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	Type                 string           `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	SingleInputMode      bool             `protobuf:"varint,3,opt,name=singleInputMode,json=single_input_mode,proto3" json:"singleInputMode,omitempty"`
	Freq                 int32            `protobuf:"varint,4,opt,name=freq,proto3" json:"freq,omitempty"`
	RssiOffset           float32          `protobuf:"fixed32,5,opt,name=rssiOffset,json=rssi_offset,proto3" json:"rssiOffset,omitempty"`
	Rssicomp             *RssiTcomp       `protobuf:"bytes,6,opt,name=rssicomp,json=rssi_tcomp,proto3" json:"rssicomp,omitempty"`
	TxEnable             bool             `protobuf:"varint,7,opt,name=TxEnable,json=tx_enable,proto3" json:"TxEnable,omitempty"`
	TxFreqMin            int32            `protobuf:"varint,8,opt,name=txFreqMin,json=tx_freq_min,proto3" json:"txFreqMin,omitempty"`
	TxFreqMax            int32            `protobuf:"varint,9,opt,name=txFreqMax,json=tx_freq_max,proto3" json:"txFreqMax,omitempty"`
	Txgainlut            []*TxGainLutItem `protobuf:"bytes,10,rep,name=txgainlut,json=tx_gain_lut,proto3" json:"txgainlut,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*EU868Radio0) Descriptor 

func (*EU868Radio0) Descriptor() ([]byte, []int)

func (*EU868Radio0) GetEnable 

func (m *EU868Radio0) GetEnable() bool

func (*EU868Radio0) GetFreq 

func (m *EU868Radio0) GetFreq() int32

func (*EU868Radio0) GetRssiOffset 

func (m *EU868Radio0) GetRssiOffset() float32

func (*EU868Radio0) GetRssicomp 

func (m *EU868Radio0) GetRssicomp() *RssiTcomp

func (*EU868Radio0) GetSingleInputMode 

func (m *EU868Radio0) GetSingleInputMode() bool

func (*EU868Radio0) GetTxEnable 

func (m *EU868Radio0) GetTxEnable() bool

func (*EU868Radio0) GetTxFreqMax 

func (m *EU868Radio0) GetTxFreqMax() int32

func (*EU868Radio0) GetTxFreqMin 

func (m *EU868Radio0) GetTxFreqMin() int32

func (*EU868Radio0) GetTxgainlut 

func (m *EU868Radio0) GetTxgainlut() []*TxGainLutItem

func (*EU868Radio0) GetType 

func (m *EU868Radio0) GetType() string

func (*EU868Radio0) ProtoMessage 

func (*EU868Radio0) ProtoMessage()

func (*EU868Radio0) Reset 

func (m *EU868Radio0) Reset()

func (*EU868Radio0) String 

func (m *EU868Radio0) String() string

func (*EU868Radio0) XXX_DiscardUnknown 

func (m *EU868Radio0) XXX_DiscardUnknown()

func (*EU868Radio0) XXX_Marshal 

func (m *EU868Radio0) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EU868Radio0) XXX_Merge 

func (m *EU868Radio0) XXX_Merge(src proto.Message)

func (*EU868Radio0) XXX_Size 

func (m *EU868Radio0) XXX_Size() int

func (*EU868Radio0) XXX_Unmarshal 

func (m *EU868Radio0) XXX_Unmarshal(b []byte) error

type EU868Radio1 

type EU868Radio1 struct {
	Enable               bool       `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	Type                 string     `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	SingleInputMode      bool       `protobuf:"varint,3,opt,name=singleInputMode,json=single_input_mode,proto3" json:"singleInputMode,omitempty"`
	Freq                 int32      `protobuf:"varint,4,opt,name=freq,proto3" json:"freq,omitempty"`
	RssiOffset           float32    `protobuf:"fixed32,5,opt,name=rssiOffset,json=rssi_offset,proto3" json:"rssiOffset,omitempty"`
	Rssicomp             *RssiTcomp `protobuf:"bytes,6,opt,name=rssicomp,json=rssi_tcomp,proto3" json:"rssicomp,omitempty"`
	TxEnable             bool       `protobuf:"varint,7,opt,name=TxEnable,json=tx_enable,proto3" json:"TxEnable,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (*EU868Radio1) Descriptor 

func (*EU868Radio1) Descriptor() ([]byte, []int)

func (*EU868Radio1) GetEnable 

func (m *EU868Radio1) GetEnable() bool

func (*EU868Radio1) GetFreq 

func (m *EU868Radio1) GetFreq() int32

func (*EU868Radio1) GetRssiOffset 

func (m *EU868Radio1) GetRssiOffset() float32

func (*EU868Radio1) GetRssicomp 

func (m *EU868Radio1) GetRssicomp() *RssiTcomp

func (*EU868Radio1) GetSingleInputMode 

func (m *EU868Radio1) GetSingleInputMode() bool

func (*EU868Radio1) GetTxEnable 

func (m *EU868Radio1) GetTxEnable() bool

func (*EU868Radio1) GetType 

func (m *EU868Radio1) GetType() string

func (*EU868Radio1) ProtoMessage 

func (*EU868Radio1) ProtoMessage()

func (*EU868Radio1) Reset 

func (m *EU868Radio1) Reset()

func (*EU868Radio1) String 

func (m *EU868Radio1) String() string

func (*EU868Radio1) XXX_DiscardUnknown 

func (m *EU868Radio1) XXX_DiscardUnknown()

func (*EU868Radio1) XXX_Marshal 

func (m *EU868Radio1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EU868Radio1) XXX_Merge 

func (m *EU868Radio1) XXX_Merge(src proto.Message)

func (*EU868Radio1) XXX_Size 

func (m *EU868Radio1) XXX_Size() int

func (*EU868Radio1) XXX_Unmarshal 

func (m *EU868Radio1) XXX_Unmarshal(b []byte) error

type EncryptListResponse 

type EncryptListResponse struct {
	Encrypt              []string `protobuf:"bytes,1,rep,name=encrypt,proto3" json:"encrypt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*EncryptListResponse) Descriptor 

func (*EncryptListResponse) Descriptor() ([]byte, []int)

func (*EncryptListResponse) GetEncrypt 

func (m *EncryptListResponse) GetEncrypt() []string

func (*EncryptListResponse) ProtoMessage 

func (*EncryptListResponse) ProtoMessage()

func (*EncryptListResponse) Reset 

func (m *EncryptListResponse) Reset()

func (*EncryptListResponse) String 

func (m *EncryptListResponse) String() string

func (*EncryptListResponse) XXX_DiscardUnknown 

func (m *EncryptListResponse) XXX_DiscardUnknown()

func (*EncryptListResponse) XXX_Marshal 

func (m *EncryptListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EncryptListResponse) XXX_Merge 

func (m *EncryptListResponse) XXX_Merge(src proto.Message)

func (*EncryptListResponse) XXX_Size 

func (m *EncryptListResponse) XXX_Size() int

func (*EncryptListResponse) XXX_Unmarshal 

func (m *EncryptListResponse) XXX_Unmarshal(b []byte) error

type EncryptSNRequest 

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

func (*EncryptSNRequest) Descriptor 

func (*EncryptSNRequest) Descriptor() ([]byte, []int)

func (*EncryptSNRequest) GetSn 

func (m *EncryptSNRequest) GetSn() string

func (*EncryptSNRequest) ProtoMessage 

func (*EncryptSNRequest) ProtoMessage()

func (*EncryptSNRequest) Reset 

func (m *EncryptSNRequest) Reset()

func (*EncryptSNRequest) String 

func (m *EncryptSNRequest) String() string

func (*EncryptSNRequest) XXX_DiscardUnknown 

func (m *EncryptSNRequest) XXX_DiscardUnknown()

func (*EncryptSNRequest) XXX_Marshal 

func (m *EncryptSNRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EncryptSNRequest) XXX_Merge 

func (m *EncryptSNRequest) XXX_Merge(src proto.Message)

func (*EncryptSNRequest) XXX_Size 

func (m *EncryptSNRequest) XXX_Size() int

func (*EncryptSNRequest) XXX_Unmarshal 

func (m *EncryptSNRequest) XXX_Unmarshal(b []byte) error

type EncryptSNResponse 

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

func (*EncryptSNResponse) Descriptor 

func (*EncryptSNResponse) Descriptor() ([]byte, []int)

func (*EncryptSNResponse) GetHash 

func (m *EncryptSNResponse) GetHash() string

func (*EncryptSNResponse) ProtoMessage 

func (*EncryptSNResponse) ProtoMessage()

func (*EncryptSNResponse) Reset 

func (m *EncryptSNResponse) Reset()

func (*EncryptSNResponse) String 

func (m *EncryptSNResponse) String() string

func (*EncryptSNResponse) XXX_DiscardUnknown 

func (m *EncryptSNResponse) XXX_DiscardUnknown()

func (*EncryptSNResponse) XXX_Marshal 

func (m *EncryptSNResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EncryptSNResponse) XXX_Merge 

func (m *EncryptSNResponse) XXX_Merge(src proto.Message)

func (*EncryptSNResponse) XXX_Size 

func (m *EncryptSNResponse) XXX_Size() int

func (*EncryptSNResponse) XXX_Unmarshal 

func (m *EncryptSNResponse) XXX_Unmarshal(b []byte) error

type EnqueueDeviceQueueItemRequest 

type EnqueueDeviceQueueItemRequest struct {
	// Queue-item object to enqueue.
	DeviceQueueItem      *DeviceQueueItem `protobuf:"bytes,1,opt,name=device_queue_item,json=deviceQueueItem,proto3" json:"device_queue_item,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*EnqueueDeviceQueueItemRequest) Descriptor 

func (*EnqueueDeviceQueueItemRequest) Descriptor() ([]byte, []int)

func (*EnqueueDeviceQueueItemRequest) GetDeviceQueueItem 

func (m *EnqueueDeviceQueueItemRequest) GetDeviceQueueItem() *DeviceQueueItem

func (*EnqueueDeviceQueueItemRequest) ProtoMessage 

func (*EnqueueDeviceQueueItemRequest) ProtoMessage()

func (*EnqueueDeviceQueueItemRequest) Reset 

func (m *EnqueueDeviceQueueItemRequest) Reset()

func (*EnqueueDeviceQueueItemRequest) String 

func (m *EnqueueDeviceQueueItemRequest) String() string

func (*EnqueueDeviceQueueItemRequest) XXX_DiscardUnknown 

func (m *EnqueueDeviceQueueItemRequest) XXX_DiscardUnknown()

func (*EnqueueDeviceQueueItemRequest) XXX_Marshal 

func (m *EnqueueDeviceQueueItemRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EnqueueDeviceQueueItemRequest) XXX_Merge 

func (m *EnqueueDeviceQueueItemRequest) XXX_Merge(src proto.Message)

func (*EnqueueDeviceQueueItemRequest) XXX_Size 

func (m *EnqueueDeviceQueueItemRequest) XXX_Size() int

func (*EnqueueDeviceQueueItemRequest) XXX_Unmarshal 

func (m *EnqueueDeviceQueueItemRequest) XXX_Unmarshal(b []byte) error

type EnqueueDeviceQueueItemResponse 

type EnqueueDeviceQueueItemResponse struct {
	// Frame-counter for the enqueued payload.
	FCnt                 uint32   `protobuf:"varint,1,opt,name=f_cnt,json=fCnt,proto3" json:"f_cnt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*EnqueueDeviceQueueItemResponse) Descriptor 

func (*EnqueueDeviceQueueItemResponse) Descriptor() ([]byte, []int)

func (*EnqueueDeviceQueueItemResponse) GetFCnt 

func (m *EnqueueDeviceQueueItemResponse) GetFCnt() uint32

func (*EnqueueDeviceQueueItemResponse) ProtoMessage 

func (*EnqueueDeviceQueueItemResponse) ProtoMessage()

func (*EnqueueDeviceQueueItemResponse) Reset 

func (m *EnqueueDeviceQueueItemResponse) Reset()

func (*EnqueueDeviceQueueItemResponse) String 

func (m *EnqueueDeviceQueueItemResponse) String() string

func (*EnqueueDeviceQueueItemResponse) XXX_DiscardUnknown 

func (m *EnqueueDeviceQueueItemResponse) XXX_DiscardUnknown()

func (*EnqueueDeviceQueueItemResponse) XXX_Marshal 

func (m *EnqueueDeviceQueueItemResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EnqueueDeviceQueueItemResponse) XXX_Merge 

func (m *EnqueueDeviceQueueItemResponse) XXX_Merge(src proto.Message)

func (*EnqueueDeviceQueueItemResponse) XXX_Size 

func (m *EnqueueDeviceQueueItemResponse) XXX_Size() int

func (*EnqueueDeviceQueueItemResponse) XXX_Unmarshal 

func (m *EnqueueDeviceQueueItemResponse) XXX_Unmarshal(b []byte) error

type EnqueueMulticastQueueItemRequest 

type EnqueueMulticastQueueItemRequest struct {
	// Multicast queue-item object to enqueue.
	MulticastQueueItem   *MulticastQueueItem `protobuf:"bytes,1,opt,name=multicast_queue_item,json=multicastQueueItem,proto3" json:"multicast_queue_item,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (*EnqueueMulticastQueueItemRequest) Descriptor 

func (*EnqueueMulticastQueueItemRequest) Descriptor() ([]byte, []int)

func (*EnqueueMulticastQueueItemRequest) GetMulticastQueueItem 

func (m *EnqueueMulticastQueueItemRequest) GetMulticastQueueItem() *MulticastQueueItem

func (*EnqueueMulticastQueueItemRequest) ProtoMessage 

func (*EnqueueMulticastQueueItemRequest) ProtoMessage()

func (*EnqueueMulticastQueueItemRequest) Reset 

func (m *EnqueueMulticastQueueItemRequest) Reset()

func (*EnqueueMulticastQueueItemRequest) String 

func (m *EnqueueMulticastQueueItemRequest) String() string

func (*EnqueueMulticastQueueItemRequest) XXX_DiscardUnknown 

func (m *EnqueueMulticastQueueItemRequest) XXX_DiscardUnknown()

func (*EnqueueMulticastQueueItemRequest) XXX_Marshal 

func (m *EnqueueMulticastQueueItemRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EnqueueMulticastQueueItemRequest) XXX_Merge 

func (m *EnqueueMulticastQueueItemRequest) XXX_Merge(src proto.Message)

func (*EnqueueMulticastQueueItemRequest) XXX_Size 

func (m *EnqueueMulticastQueueItemRequest) XXX_Size() int

func (*EnqueueMulticastQueueItemRequest) XXX_Unmarshal 

func (m *EnqueueMulticastQueueItemRequest) XXX_Unmarshal(b []byte) error

type EnqueueMulticastQueueItemResponse 

type EnqueueMulticastQueueItemResponse struct {
	// Frame-counter for the enqueued payload.
	FCnt                 uint32   `protobuf:"varint,1,opt,name=f_cnt,json=fCnt,proto3" json:"f_cnt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*EnqueueMulticastQueueItemResponse) Descriptor 

func (*EnqueueMulticastQueueItemResponse) Descriptor() ([]byte, []int)

func (*EnqueueMulticastQueueItemResponse) GetFCnt 

func (m *EnqueueMulticastQueueItemResponse) GetFCnt() uint32

func (*EnqueueMulticastQueueItemResponse) ProtoMessage 

func (*EnqueueMulticastQueueItemResponse) ProtoMessage()

func (*EnqueueMulticastQueueItemResponse) Reset 

func (m *EnqueueMulticastQueueItemResponse) Reset()

func (*EnqueueMulticastQueueItemResponse) String 

func (m *EnqueueMulticastQueueItemResponse) String() string

func (*EnqueueMulticastQueueItemResponse) XXX_DiscardUnknown 

func (m *EnqueueMulticastQueueItemResponse) XXX_DiscardUnknown()

func (*EnqueueMulticastQueueItemResponse) XXX_Marshal 

func (m *EnqueueMulticastQueueItemResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EnqueueMulticastQueueItemResponse) XXX_Merge 

func (m *EnqueueMulticastQueueItemResponse) XXX_Merge(src proto.Message)

func (*EnqueueMulticastQueueItemResponse) XXX_Size 

func (m *EnqueueMulticastQueueItemResponse) XXX_Size() int

func (*EnqueueMulticastQueueItemResponse) XXX_Unmarshal 

func (m *EnqueueMulticastQueueItemResponse) XXX_Unmarshal(b []byte) error

type Ethernet 

type Ethernet struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	Dhcp                 bool     `protobuf:"varint,2,opt,name=dhcp,proto3" json:"dhcp,omitempty"`
	Ip                   string   `protobuf:"bytes,3,opt,name=ip,proto3" json:"ip,omitempty"`
	Netmask              string   `protobuf:"bytes,4,opt,name=netmask,proto3" json:"netmask,omitempty"`
	Gateway              string   `protobuf:"bytes,6,opt,name=gateway,proto3" json:"gateway,omitempty"`
	Mac                  string   `protobuf:"bytes,7,opt,name=mac,proto3" json:"mac,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*Ethernet) Descriptor 

func (*Ethernet) Descriptor() ([]byte, []int)

func (*Ethernet) GetDhcp 

func (m *Ethernet) GetDhcp() bool

func (*Ethernet) GetEnable 

func (m *Ethernet) GetEnable() bool

func (*Ethernet) GetGateway 

func (m *Ethernet) GetGateway() string

func (*Ethernet) GetIp 

func (m *Ethernet) GetIp() string

func (*Ethernet) GetMac 

func (m *Ethernet) GetMac() string

func (*Ethernet) GetNetmask 

func (m *Ethernet) GetNetmask() string

func (*Ethernet) ProtoMessage 

func (*Ethernet) ProtoMessage()

func (*Ethernet) Reset 

func (m *Ethernet) Reset()

func (*Ethernet) String 

func (m *Ethernet) String() string

func (*Ethernet) XXX_DiscardUnknown 

func (m *Ethernet) XXX_DiscardUnknown()

func (*Ethernet) XXX_Marshal 

func (m *Ethernet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Ethernet) XXX_Merge 

func (m *Ethernet) XXX_Merge(src proto.Message)

func (*Ethernet) XXX_Size 

func (m *Ethernet) XXX_Size() int

func (*Ethernet) XXX_Unmarshal 

func (m *Ethernet) XXX_Unmarshal(b []byte) error

type EthernetRequest 

type EthernetRequest struct {
	Eth                  *Ethernet `protobuf:"bytes,1,opt,name=eth,proto3" json:"eth,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (*EthernetRequest) Descriptor 

func (*EthernetRequest) Descriptor() ([]byte, []int)

func (*EthernetRequest) GetEth 

func (m *EthernetRequest) GetEth() *Ethernet

func (*EthernetRequest) ProtoMessage 

func (*EthernetRequest) ProtoMessage()

func (*EthernetRequest) Reset 

func (m *EthernetRequest) Reset()

func (*EthernetRequest) String 

func (m *EthernetRequest) String() string

func (*EthernetRequest) XXX_DiscardUnknown 

func (m *EthernetRequest) XXX_DiscardUnknown()

func (*EthernetRequest) XXX_Marshal 

func (m *EthernetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EthernetRequest) XXX_Merge 

func (m *EthernetRequest) XXX_Merge(src proto.Message)

func (*EthernetRequest) XXX_Size 

func (m *EthernetRequest) XXX_Size() int

func (*EthernetRequest) XXX_Unmarshal 

func (m *EthernetRequest) XXX_Unmarshal(b []byte) error

type EthernetResponse 

type EthernetResponse struct {
	Eth                  *Ethernet `protobuf:"bytes,1,opt,name=eth,proto3" json:"eth,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (*EthernetResponse) Descriptor 

func (*EthernetResponse) Descriptor() ([]byte, []int)

func (*EthernetResponse) GetEth 

func (m *EthernetResponse) GetEth() *Ethernet

func (*EthernetResponse) ProtoMessage 

func (*EthernetResponse) ProtoMessage()

func (*EthernetResponse) Reset 

func (m *EthernetResponse) Reset()

func (*EthernetResponse) String 

func (m *EthernetResponse) String() string

func (*EthernetResponse) XXX_DiscardUnknown 

func (m *EthernetResponse) XXX_DiscardUnknown()

func (*EthernetResponse) XXX_Marshal 

func (m *EthernetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EthernetResponse) XXX_Merge 

func (m *EthernetResponse) XXX_Merge(src proto.Message)

func (*EthernetResponse) XXX_Size 

func (m *EthernetResponse) XXX_Size() int

func (*EthernetResponse) XXX_Unmarshal 

func (m *EthernetResponse) XXX_Unmarshal(b []byte) error

type FUOTADeployment 

type FUOTADeployment struct {
	// ID of the deployment (string formatted UUID).
	// This value will be automatically assigned on create.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Name of the deployment.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Multicast type.
	// Currently only Class-C is supported!
	GroupType MulticastGroupType `protobuf:"varint,3,opt,name=group_type,json=groupType,proto3,enum=api.MulticastGroupType" json:"group_type,omitempty"`
	// Data-rate.
	Dr uint32 `protobuf:"varint,4,opt,name=dr,proto3" json:"dr,omitempty"`
	// Frequency (Hz).
	Frequency uint32 `protobuf:"varint,5,opt,name=frequency,proto3" json:"frequency,omitempty"`
	// Payload.
	Payload []byte `protobuf:"bytes,6,opt,name=payload,proto3" json:"payload,omitempty"`
	// Redundancy (number of packages).
	Redundancy uint32 `protobuf:"varint,7,opt,name=redundancy,proto3" json:"redundancy,omitempty"`
	// Multicast time-out.
	// Please refer to the Remote Multicast Setup specification as this field
	// has a different meaning for Class-B and Class-C groups.
	MulticastTimeout uint32 `protobuf:"varint,8,opt,name=multicast_timeout,json=multicastTimeout,proto3" json:"multicast_timeout,omitempty"`
	// Unicast time-out.
	// Set this to the value in which you at least expect an uplink frame from the
	// device. The FUOTA deployment engine will wait at least for the given time
	// before proceeding with the next steps.
	UnicastTimeout *durationpb.Duration `protobuf:"bytes,9,opt,name=unicast_timeout,json=unicastTimeout,proto3" json:"unicast_timeout,omitempty"`
	// Deployment state.
	// This value will be automatically set on create.
	State string `protobuf:"bytes,10,opt,name=state,proto3" json:"state,omitempty"`
	// Next step after.
	// This value will be automatically set on create.
	NextStepAfter        *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=next_step_after,json=nextStepAfter,proto3" json:"next_step_after,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*FUOTADeployment) Descriptor 

func (*FUOTADeployment) Descriptor() ([]byte, []int)

func (*FUOTADeployment) GetDr 

func (m *FUOTADeployment) GetDr() uint32

func (*FUOTADeployment) GetFrequency 

func (m *FUOTADeployment) GetFrequency() uint32

func (*FUOTADeployment) GetGroupType 

func (m *FUOTADeployment) GetGroupType() MulticastGroupType

func (*FUOTADeployment) GetId 

func (m *FUOTADeployment) GetId() string

func (*FUOTADeployment) GetMulticastTimeout 

func (m *FUOTADeployment) GetMulticastTimeout() uint32

func (*FUOTADeployment) GetName 

func (m *FUOTADeployment) GetName() string

func (*FUOTADeployment) GetNextStepAfter 

func (m *FUOTADeployment) GetNextStepAfter() *timestamppb.Timestamp

func (*FUOTADeployment) GetPayload 

func (m *FUOTADeployment) GetPayload() []byte

func (*FUOTADeployment) GetRedundancy 

func (m *FUOTADeployment) GetRedundancy() uint32

func (*FUOTADeployment) GetState 

func (m *FUOTADeployment) GetState() string

func (*FUOTADeployment) GetUnicastTimeout 

func (m *FUOTADeployment) GetUnicastTimeout() *durationpb.Duration

func (*FUOTADeployment) ProtoMessage 

func (*FUOTADeployment) ProtoMessage()

func (*FUOTADeployment) Reset 

func (m *FUOTADeployment) Reset()

func (*FUOTADeployment) String 

func (m *FUOTADeployment) String() string

func (*FUOTADeployment) XXX_DiscardUnknown 

func (m *FUOTADeployment) XXX_DiscardUnknown()

func (*FUOTADeployment) XXX_Marshal 

func (m *FUOTADeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FUOTADeployment) XXX_Merge 

func (m *FUOTADeployment) XXX_Merge(src proto.Message)

func (*FUOTADeployment) XXX_Size 

func (m *FUOTADeployment) XXX_Size() int

func (*FUOTADeployment) XXX_Unmarshal 

func (m *FUOTADeployment) XXX_Unmarshal(b []byte) error

type FUOTADeploymentDeviceListItem 

type FUOTADeploymentDeviceListItem struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Device name.
	DeviceName string `protobuf:"bytes,2,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
	// Device state.
	State FUOTADeploymentDeviceState `protobuf:"varint,3,opt,name=state,proto3,enum=api.FUOTADeploymentDeviceState" json:"state,omitempty"`
	// Error message (in case of error state).
	ErrorMessage string `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Updated at timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*FUOTADeploymentDeviceListItem) Descriptor 

func (*FUOTADeploymentDeviceListItem) Descriptor() ([]byte, []int)

func (*FUOTADeploymentDeviceListItem) GetCreatedAt 

func (m *FUOTADeploymentDeviceListItem) GetCreatedAt() *timestamppb.Timestamp

func (*FUOTADeploymentDeviceListItem) GetDevEui 

func (m *FUOTADeploymentDeviceListItem) GetDevEui() string

func (*FUOTADeploymentDeviceListItem) GetDeviceName 

func (m *FUOTADeploymentDeviceListItem) GetDeviceName() string

func (*FUOTADeploymentDeviceListItem) GetErrorMessage 

func (m *FUOTADeploymentDeviceListItem) GetErrorMessage() string

func (*FUOTADeploymentDeviceListItem) GetState 

func (m *FUOTADeploymentDeviceListItem) GetState() FUOTADeploymentDeviceState

func (*FUOTADeploymentDeviceListItem) GetUpdatedAt 

func (m *FUOTADeploymentDeviceListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*FUOTADeploymentDeviceListItem) ProtoMessage 

func (*FUOTADeploymentDeviceListItem) ProtoMessage()

func (*FUOTADeploymentDeviceListItem) Reset 

func (m *FUOTADeploymentDeviceListItem) Reset()

func (*FUOTADeploymentDeviceListItem) String 

func (m *FUOTADeploymentDeviceListItem) String() string

func (*FUOTADeploymentDeviceListItem) XXX_DiscardUnknown 

func (m *FUOTADeploymentDeviceListItem) XXX_DiscardUnknown()

func (*FUOTADeploymentDeviceListItem) XXX_Marshal 

func (m *FUOTADeploymentDeviceListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FUOTADeploymentDeviceListItem) XXX_Merge 

func (m *FUOTADeploymentDeviceListItem) XXX_Merge(src proto.Message)

func (*FUOTADeploymentDeviceListItem) XXX_Size 

func (m *FUOTADeploymentDeviceListItem) XXX_Size() int

func (*FUOTADeploymentDeviceListItem) XXX_Unmarshal 

func (m *FUOTADeploymentDeviceListItem) XXX_Unmarshal(b []byte) error

type FUOTADeploymentDeviceState 

type FUOTADeploymentDeviceState int32
const (
	// Pending.
	FUOTADeploymentDeviceState_PENDING FUOTADeploymentDeviceState = 0
	// Success.
	FUOTADeploymentDeviceState_SUCCESS FUOTADeploymentDeviceState = 1
	// Error.
	FUOTADeploymentDeviceState_ERROR FUOTADeploymentDeviceState = 2
)

func (FUOTADeploymentDeviceState) EnumDescriptor 

func (FUOTADeploymentDeviceState) EnumDescriptor() ([]byte, []int)

func (FUOTADeploymentDeviceState) String 

func (x FUOTADeploymentDeviceState) String() string

type FUOTADeploymentListItem 

type FUOTADeploymentListItem struct {
	// ID of the deployment (string formatted UUID).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Name of the deployment.
	Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	// Deployment state.
	State string `protobuf:"bytes,5,opt,name=state,proto3" json:"state,omitempty"`
	// Next step after.
	NextStepAfter        *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=next_step_after,json=nextStepAfter,proto3" json:"next_step_after,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*FUOTADeploymentListItem) Descriptor 

func (*FUOTADeploymentListItem) Descriptor() ([]byte, []int)

func (*FUOTADeploymentListItem) GetCreatedAt 

func (m *FUOTADeploymentListItem) GetCreatedAt() *timestamppb.Timestamp

func (*FUOTADeploymentListItem) GetId 

func (m *FUOTADeploymentListItem) GetId() string

func (*FUOTADeploymentListItem) GetName 

func (m *FUOTADeploymentListItem) GetName() string

func (*FUOTADeploymentListItem) GetNextStepAfter 

func (m *FUOTADeploymentListItem) GetNextStepAfter() *timestamppb.Timestamp

func (*FUOTADeploymentListItem) GetState 

func (m *FUOTADeploymentListItem) GetState() string

func (*FUOTADeploymentListItem) GetUpdatedAt 

func (m *FUOTADeploymentListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*FUOTADeploymentListItem) ProtoMessage 

func (*FUOTADeploymentListItem) ProtoMessage()

func (*FUOTADeploymentListItem) Reset 

func (m *FUOTADeploymentListItem) Reset()

func (*FUOTADeploymentListItem) String 

func (m *FUOTADeploymentListItem) String() string

func (*FUOTADeploymentListItem) XXX_DiscardUnknown 

func (m *FUOTADeploymentListItem) XXX_DiscardUnknown()

func (*FUOTADeploymentListItem) XXX_Marshal 

func (m *FUOTADeploymentListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FUOTADeploymentListItem) XXX_Merge 

func (m *FUOTADeploymentListItem) XXX_Merge(src proto.Message)

func (*FUOTADeploymentListItem) XXX_Size 

func (m *FUOTADeploymentListItem) XXX_Size() int

func (*FUOTADeploymentListItem) XXX_Unmarshal 

func (m *FUOTADeploymentListItem) XXX_Unmarshal(b []byte) error

type FUOTADeploymentServiceClient 

type FUOTADeploymentServiceClient interface {
	// CreateForDevice creates a deployment for the given DevEUI.
	CreateForDevice(ctx context.Context, in *CreateFUOTADeploymentForDeviceRequest, opts ...grpc.CallOption) (*CreateFUOTADeploymentForDeviceResponse, error)
	// Get returns the fuota deployment for the given id.
	Get(ctx context.Context, in *GetFUOTADeploymentRequest, opts ...grpc.CallOption) (*GetFUOTADeploymentResponse, error)
	// List lists the fuota deployments.
	List(ctx context.Context, in *ListFUOTADeploymentRequest, opts ...grpc.CallOption) (*ListFUOTADeploymentResponse, error)
	// GetDeploymentDevice returns the deployment device.
	GetDeploymentDevice(ctx context.Context, in *GetFUOTADeploymentDeviceRequest, opts ...grpc.CallOption) (*GetFUOTADeploymentDeviceResponse, error)
	// ListDeploymentDevices lists the devices (and status) for the given fuota deployment ID.
	ListDeploymentDevices(ctx context.Context, in *ListFUOTADeploymentDevicesRequest, opts ...grpc.CallOption) (*ListFUOTADeploymentDevicesResponse, error)
}

FUOTADeploymentServiceClient is the client API for FUOTADeploymentService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewFUOTADeploymentServiceClient 

func NewFUOTADeploymentServiceClient(cc grpc.ClientConnInterface) FUOTADeploymentServiceClient

type FUOTADeploymentServiceServer 

type FUOTADeploymentServiceServer interface {
	// CreateForDevice creates a deployment for the given DevEUI.
	CreateForDevice(context.Context, *CreateFUOTADeploymentForDeviceRequest) (*CreateFUOTADeploymentForDeviceResponse, error)
	// Get returns the fuota deployment for the given id.
	Get(context.Context, *GetFUOTADeploymentRequest) (*GetFUOTADeploymentResponse, error)
	// List lists the fuota deployments.
	List(context.Context, *ListFUOTADeploymentRequest) (*ListFUOTADeploymentResponse, error)
	// GetDeploymentDevice returns the deployment device.
	GetDeploymentDevice(context.Context, *GetFUOTADeploymentDeviceRequest) (*GetFUOTADeploymentDeviceResponse, error)
	// ListDeploymentDevices lists the devices (and status) for the given fuota deployment ID.
	ListDeploymentDevices(context.Context, *ListFUOTADeploymentDevicesRequest) (*ListFUOTADeploymentDevicesResponse, error)
}

FUOTADeploymentServiceServer is the server API for FUOTADeploymentService service.

type FactoryRestoreResquest 

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 (*FactoryRestoreResquest) Descriptor 

func (*FactoryRestoreResquest) Descriptor() ([]byte, []int)

func (*FactoryRestoreResquest) GetPassword 

func (m *FactoryRestoreResquest) GetPassword() string

func (*FactoryRestoreResquest) ProtoMessage 

func (*FactoryRestoreResquest) ProtoMessage()

func (*FactoryRestoreResquest) Reset 

func (m *FactoryRestoreResquest) Reset()

func (*FactoryRestoreResquest) String 

func (m *FactoryRestoreResquest) String() string

func (*FactoryRestoreResquest) XXX_DiscardUnknown 

func (m *FactoryRestoreResquest) XXX_DiscardUnknown()

func (*FactoryRestoreResquest) XXX_Marshal 

func (m *FactoryRestoreResquest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FactoryRestoreResquest) XXX_Merge 

func (m *FactoryRestoreResquest) XXX_Merge(src proto.Message)

func (*FactoryRestoreResquest) XXX_Size 

func (m *FactoryRestoreResquest) XXX_Size() int

func (*FactoryRestoreResquest) XXX_Unmarshal 

func (m *FactoryRestoreResquest) XXX_Unmarshal(b []byte) error

type FileUpload 

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 (*FileUpload) Descriptor 

func (*FileUpload) Descriptor() ([]byte, []int)

func (*FileUpload) GetData 

func (m *FileUpload) GetData() string

func (*FileUpload) GetOffset 

func (m *FileUpload) GetOffset() int64

func (*FileUpload) GetSha256 

func (m *FileUpload) GetSha256() string

func (*FileUpload) GetTotal 

func (m *FileUpload) GetTotal() int64

func (*FileUpload) GetTransfer 

func (m *FileUpload) GetTransfer() int64

func (*FileUpload) GetVersion 

func (m *FileUpload) GetVersion() string

func (*FileUpload) ProtoMessage 

func (*FileUpload) ProtoMessage()

func (*FileUpload) Reset 

func (m *FileUpload) Reset()

func (*FileUpload) String 

func (m *FileUpload) String() string

func (*FileUpload) XXX_DiscardUnknown 

func (m *FileUpload) XXX_DiscardUnknown()

func (*FileUpload) XXX_Marshal 

func (m *FileUpload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FileUpload) XXX_Merge 

func (m *FileUpload) XXX_Merge(src proto.Message)

func (*FileUpload) XXX_Size 

func (m *FileUpload) XXX_Size() int

func (*FileUpload) XXX_Unmarshal 

func (m *FileUpload) XXX_Unmarshal(b []byte) error

type FileUploadRequest 

type FileUploadRequest struct {
	Type                 string   `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Context              string   `protobuf:"bytes,2,opt,name=context,proto3" json:"context,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*FileUploadRequest) Descriptor 

func (*FileUploadRequest) Descriptor() ([]byte, []int)

func (*FileUploadRequest) GetContext 

func (m *FileUploadRequest) GetContext() string

func (*FileUploadRequest) GetType 

func (m *FileUploadRequest) GetType() string

func (*FileUploadRequest) ProtoMessage 

func (*FileUploadRequest) ProtoMessage()

func (*FileUploadRequest) Reset 

func (m *FileUploadRequest) Reset()

func (*FileUploadRequest) String 

func (m *FileUploadRequest) String() string

func (*FileUploadRequest) XXX_DiscardUnknown 

func (m *FileUploadRequest) XXX_DiscardUnknown()

func (*FileUploadRequest) XXX_Marshal 

func (m *FileUploadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FileUploadRequest) XXX_Merge 

func (m *FileUploadRequest) XXX_Merge(src proto.Message)

func (*FileUploadRequest) XXX_Size 

func (m *FileUploadRequest) XXX_Size() int

func (*FileUploadRequest) XXX_Unmarshal 

func (m *FileUploadRequest) XXX_Unmarshal(b []byte) error

type FileUploadResponse 

type FileUploadResponse 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 (*FileUploadResponse) Descriptor 

func (*FileUploadResponse) Descriptor() ([]byte, []int)

func (*FileUploadResponse) GetPath 

func (m *FileUploadResponse) GetPath() string

func (*FileUploadResponse) ProtoMessage 

func (*FileUploadResponse) ProtoMessage()

func (*FileUploadResponse) Reset 

func (m *FileUploadResponse) Reset()

func (*FileUploadResponse) String 

func (m *FileUploadResponse) String() string

func (*FileUploadResponse) XXX_DiscardUnknown 

func (m *FileUploadResponse) XXX_DiscardUnknown()

func (*FileUploadResponse) XXX_Marshal 

func (m *FileUploadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FileUploadResponse) XXX_Merge 

func (m *FileUploadResponse) XXX_Merge(src proto.Message)

func (*FileUploadResponse) XXX_Size 

func (m *FileUploadResponse) XXX_Size() int

func (*FileUploadResponse) XXX_Unmarshal 

func (m *FileUploadResponse) XXX_Unmarshal(b []byte) error

type Filter 

type Filter struct {
	WhiteList            *WhiteList  `protobuf:"bytes,1,opt,name=whiteList,proto3" json:"whiteList,omitempty"`
	AutoFilter           *AutoFilter `protobuf:"bytes,2,opt,name=autoFilter,proto3" json:"autoFilter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*Filter) Descriptor 

func (*Filter) Descriptor() ([]byte, []int)

func (*Filter) GetAutoFilter 

func (m *Filter) GetAutoFilter() *AutoFilter

func (*Filter) GetWhiteList 

func (m *Filter) GetWhiteList() *WhiteList

func (*Filter) ProtoMessage 

func (*Filter) ProtoMessage()

func (*Filter) Reset 

func (m *Filter) Reset()

func (*Filter) String 

func (m *Filter) String() string

func (*Filter) XXX_DiscardUnknown 

func (m *Filter) XXX_DiscardUnknown()

func (*Filter) XXX_Marshal 

func (m *Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Filter) XXX_Merge 

func (m *Filter) XXX_Merge(src proto.Message)

func (*Filter) XXX_Size 

func (m *Filter) XXX_Size() int

func (*Filter) XXX_Unmarshal 

func (m *Filter) XXX_Unmarshal(b []byte) error

type FlushDeviceQueueRequest 

type FlushDeviceQueueRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*FlushDeviceQueueRequest) Descriptor 

func (*FlushDeviceQueueRequest) Descriptor() ([]byte, []int)

func (*FlushDeviceQueueRequest) GetDevEui 

func (m *FlushDeviceQueueRequest) GetDevEui() string

func (*FlushDeviceQueueRequest) ProtoMessage 

func (*FlushDeviceQueueRequest) ProtoMessage()

func (*FlushDeviceQueueRequest) Reset 

func (m *FlushDeviceQueueRequest) Reset()

func (*FlushDeviceQueueRequest) String 

func (m *FlushDeviceQueueRequest) String() string

func (*FlushDeviceQueueRequest) XXX_DiscardUnknown 

func (m *FlushDeviceQueueRequest) XXX_DiscardUnknown()

func (*FlushDeviceQueueRequest) XXX_Marshal 

func (m *FlushDeviceQueueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FlushDeviceQueueRequest) XXX_Merge 

func (m *FlushDeviceQueueRequest) XXX_Merge(src proto.Message)

func (*FlushDeviceQueueRequest) XXX_Size 

func (m *FlushDeviceQueueRequest) XXX_Size() int

func (*FlushDeviceQueueRequest) XXX_Unmarshal 

func (m *FlushDeviceQueueRequest) XXX_Unmarshal(b []byte) error

type FlushMulticastGroupQueueItemsRequest 

type FlushMulticastGroupQueueItemsRequest struct {
	// Multicast-group ID (string formatted UUID).
	MulticastGroupId     string   `protobuf:"bytes,1,opt,name=multicast_group_id,json=multicastGroupID,proto3" json:"multicast_group_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*FlushMulticastGroupQueueItemsRequest) Descriptor 

func (*FlushMulticastGroupQueueItemsRequest) Descriptor() ([]byte, []int)

func (*FlushMulticastGroupQueueItemsRequest) GetMulticastGroupId 

func (m *FlushMulticastGroupQueueItemsRequest) GetMulticastGroupId() string

func (*FlushMulticastGroupQueueItemsRequest) ProtoMessage 

func (*FlushMulticastGroupQueueItemsRequest) ProtoMessage()

func (*FlushMulticastGroupQueueItemsRequest) Reset 

func (m *FlushMulticastGroupQueueItemsRequest) Reset()

func (*FlushMulticastGroupQueueItemsRequest) String 

func (m *FlushMulticastGroupQueueItemsRequest) String() string

func (*FlushMulticastGroupQueueItemsRequest) XXX_DiscardUnknown 

func (m *FlushMulticastGroupQueueItemsRequest) XXX_DiscardUnknown()

func (*FlushMulticastGroupQueueItemsRequest) XXX_Marshal 

func (m *FlushMulticastGroupQueueItemsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FlushMulticastGroupQueueItemsRequest) XXX_Merge 

func (m *FlushMulticastGroupQueueItemsRequest) XXX_Merge(src proto.Message)

func (*FlushMulticastGroupQueueItemsRequest) XXX_Size 

func (m *FlushMulticastGroupQueueItemsRequest) XXX_Size() int

func (*FlushMulticastGroupQueueItemsRequest) XXX_Unmarshal 

func (m *FlushMulticastGroupQueueItemsRequest) XXX_Unmarshal(b []byte) error

type GCPPubSubIntegration 

type GCPPubSubIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Marshaler.
	// This defines the marshaler that is used to encode the event payload.
	Marshaler Marshaler `protobuf:"varint,2,opt,name=marshaler,proto3,enum=api.Marshaler" json:"marshaler,omitempty"`
	// Credentials file.
	// This IAM service-account credentials file (JSON) must have the following Pub/Sub roles:
	// * Pub/Sub Publisher
	CredentialsFile string `protobuf:"bytes,3,opt,name=credentials_file,json=credentialsFile,proto3" json:"credentials_file,omitempty"`
	// Project ID.
	ProjectId string `protobuf:"bytes,4,opt,name=project_id,json=projectID,proto3" json:"project_id,omitempty"`
	// Topic name.
	// This is the name of the Pub/Sub topic.
	TopicName            string   `protobuf:"bytes,5,opt,name=topic_name,json=topicName,proto3" json:"topic_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GCPPubSubIntegration) Descriptor 

func (*GCPPubSubIntegration) Descriptor() ([]byte, []int)

func (*GCPPubSubIntegration) GetApplicationId 

func (m *GCPPubSubIntegration) GetApplicationId() int64

func (*GCPPubSubIntegration) GetCredentialsFile 

func (m *GCPPubSubIntegration) GetCredentialsFile() string

func (*GCPPubSubIntegration) GetMarshaler 

func (m *GCPPubSubIntegration) GetMarshaler() Marshaler

func (*GCPPubSubIntegration) GetProjectId 

func (m *GCPPubSubIntegration) GetProjectId() string

func (*GCPPubSubIntegration) GetTopicName 

func (m *GCPPubSubIntegration) GetTopicName() string

func (*GCPPubSubIntegration) ProtoMessage 

func (*GCPPubSubIntegration) ProtoMessage()

func (*GCPPubSubIntegration) Reset 

func (m *GCPPubSubIntegration) Reset()

func (*GCPPubSubIntegration) String 

func (m *GCPPubSubIntegration) String() string

func (*GCPPubSubIntegration) XXX_DiscardUnknown 

func (m *GCPPubSubIntegration) XXX_DiscardUnknown()

func (*GCPPubSubIntegration) XXX_Marshal 

func (m *GCPPubSubIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GCPPubSubIntegration) XXX_Merge 

func (m *GCPPubSubIntegration) XXX_Merge(src proto.Message)

func (*GCPPubSubIntegration) XXX_Size 

func (m *GCPPubSubIntegration) XXX_Size() int

func (*GCPPubSubIntegration) XXX_Unmarshal 

func (m *GCPPubSubIntegration) XXX_Unmarshal(b []byte) error

type GWMPPort 

type GWMPPort struct {
	Uplink               int32    `protobuf:"varint,1,opt,name=uplink,proto3" json:"uplink,omitempty"`
	Downlink             int32    `protobuf:"varint,2,opt,name=downlink,proto3" json:"downlink,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GWMPPort) Descriptor 

func (*GWMPPort) Descriptor() ([]byte, []int)
func (m *GWMPPort) GetDownlink() int32
func (m *GWMPPort) GetUplink() int32

func (*GWMPPort) ProtoMessage 

func (*GWMPPort) ProtoMessage()

func (*GWMPPort) Reset 

func (m *GWMPPort) Reset()

func (*GWMPPort) String 

func (m *GWMPPort) String() string

func (*GWMPPort) XXX_DiscardUnknown 

func (m *GWMPPort) XXX_DiscardUnknown()

func (*GWMPPort) XXX_Marshal 

func (m *GWMPPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GWMPPort) XXX_Merge 

func (m *GWMPPort) XXX_Merge(src proto.Message)

func (*GWMPPort) XXX_Size 

func (m *GWMPPort) XXX_Size() int

func (*GWMPPort) XXX_Unmarshal 

func (m *GWMPPort) XXX_Unmarshal(b []byte) error

type GWMPSSettings 

type GWMPSSettings struct {
	Port                 *GWMPPort `protobuf:"bytes,1,opt,name=port,proto3" json:"port,omitempty"`
	PushTimeout          int32     `protobuf:"varint,2,opt,name=pushTimeout,proto3" json:"pushTimeout,omitempty"`
	AutoRestartThreshold int32     `protobuf:"varint,3,opt,name=autoRestartThreshold,proto3" json:"autoRestartThreshold,omitempty"`
	Server               string    `protobuf:"bytes,4,opt,name=server,proto3" json:"server,omitempty"`
	KeepaliveInterval    int32     `protobuf:"varint,5,opt,name=keepaliveInterval,proto3" json:"keepaliveInterval,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (*GWMPSSettings) Descriptor 

func (*GWMPSSettings) Descriptor() ([]byte, []int)

func (*GWMPSSettings) GetAutoRestartThreshold 

func (m *GWMPSSettings) GetAutoRestartThreshold() int32

func (*GWMPSSettings) GetKeepaliveInterval 

func (m *GWMPSSettings) GetKeepaliveInterval() int32

func (*GWMPSSettings) GetPort 

func (m *GWMPSSettings) GetPort() *GWMPPort

func (*GWMPSSettings) GetPushTimeout 

func (m *GWMPSSettings) GetPushTimeout() int32

func (*GWMPSSettings) GetServer 

func (m *GWMPSSettings) GetServer() string

func (*GWMPSSettings) ProtoMessage 

func (*GWMPSSettings) ProtoMessage()

func (*GWMPSSettings) Reset 

func (m *GWMPSSettings) Reset()

func (*GWMPSSettings) String 

func (m *GWMPSSettings) String() string

func (*GWMPSSettings) XXX_DiscardUnknown 

func (m *GWMPSSettings) XXX_DiscardUnknown()

func (*GWMPSSettings) XXX_Marshal 

func (m *GWMPSSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GWMPSSettings) XXX_Merge 

func (m *GWMPSSettings) XXX_Merge(src proto.Message)

func (*GWMPSSettings) XXX_Size 

func (m *GWMPSSettings) XXX_Size() int

func (*GWMPSSettings) XXX_Unmarshal 

func (m *GWMPSSettings) XXX_Unmarshal(b []byte) error

type GateWayMode 

type GateWayMode struct {
	Mode string `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`
	// Types that are valid to be assigned to ModeConfig:
	//
	//	*GateWayMode_Pf
	//	*GateWayMode_Bs
	//	*GateWayMode_Ns
	ModeConfig           isGateWayMode_ModeConfig `protobuf_oneof:"modeConfig"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (*GateWayMode) Descriptor 

func (*GateWayMode) Descriptor() ([]byte, []int)

func (*GateWayMode) GetBs 

func (m *GateWayMode) GetBs() *BasicsStation

func (*GateWayMode) GetMode 

func (m *GateWayMode) GetMode() string

func (*GateWayMode) GetModeConfig 

func (m *GateWayMode) GetModeConfig() isGateWayMode_ModeConfig

func (*GateWayMode) GetNs 

func (m *GateWayMode) GetNs() *BuiltInNetworkServer

func (*GateWayMode) GetPf 

func (m *GateWayMode) GetPf() *PacketForwarder

func (*GateWayMode) ProtoMessage 

func (*GateWayMode) ProtoMessage()

func (*GateWayMode) Reset 

func (m *GateWayMode) Reset()

func (*GateWayMode) String 

func (m *GateWayMode) String() string

func (*GateWayMode) XXX_DiscardUnknown 

func (m *GateWayMode) XXX_DiscardUnknown()

func (*GateWayMode) XXX_Marshal 

func (m *GateWayMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GateWayMode) XXX_Merge 

func (m *GateWayMode) XXX_Merge(src proto.Message)

func (*GateWayMode) XXX_OneofWrappers 

func (*GateWayMode) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*GateWayMode) XXX_Size 

func (m *GateWayMode) XXX_Size() int

func (*GateWayMode) XXX_Unmarshal 

func (m *GateWayMode) XXX_Unmarshal(b []byte) error

type GateWayMode_Bs 

type GateWayMode_Bs struct {
	Bs *BasicsStation `protobuf:"bytes,3,opt,name=bs,json=BS,proto3,oneof"`
}

type GateWayMode_Ns 

type GateWayMode_Ns struct {
	Ns *BuiltInNetworkServer `protobuf:"bytes,4,opt,name=ns,json=NS,proto3,oneof"`
}

type GateWayMode_Pf 

type GateWayMode_Pf struct {
	Pf *PacketForwarder `protobuf:"bytes,2,opt,name=pf,json=PF,proto3,oneof"`
}

type GateWayRegion 

type GateWayRegion struct {
	RegionId string `protobuf:"bytes,1,opt,name=regionId,proto3" json:"regionId,omitempty"`
	// Types that are valid to be assigned to RegionConfig:
	//
	//	*GateWayRegion_Cn470
	//	*GateWayRegion_Eu868
	//	*GateWayRegion_Us915
	RegionConfig         isGateWayRegion_RegionConfig `protobuf_oneof:"regionConfig"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (*GateWayRegion) Descriptor 

func (*GateWayRegion) Descriptor() ([]byte, []int)

func (*GateWayRegion) GetCn470 

func (m *GateWayRegion) GetCn470() *CN470Config

func (*GateWayRegion) GetEu868 

func (m *GateWayRegion) GetEu868() *EU868Config

func (*GateWayRegion) GetRegionConfig 

func (m *GateWayRegion) GetRegionConfig() isGateWayRegion_RegionConfig

func (*GateWayRegion) GetRegionId 

func (m *GateWayRegion) GetRegionId() string

func (*GateWayRegion) GetUs915 

func (m *GateWayRegion) GetUs915() *US915Config

func (*GateWayRegion) ProtoMessage 

func (*GateWayRegion) ProtoMessage()

func (*GateWayRegion) Reset 

func (m *GateWayRegion) Reset()

func (*GateWayRegion) String 

func (m *GateWayRegion) String() string

func (*GateWayRegion) XXX_DiscardUnknown 

func (m *GateWayRegion) XXX_DiscardUnknown()

func (*GateWayRegion) XXX_Marshal 

func (m *GateWayRegion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GateWayRegion) XXX_Merge 

func (m *GateWayRegion) XXX_Merge(src proto.Message)

func (*GateWayRegion) XXX_OneofWrappers 

func (*GateWayRegion) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*GateWayRegion) XXX_Size 

func (m *GateWayRegion) XXX_Size() int

func (*GateWayRegion) XXX_Unmarshal 

func (m *GateWayRegion) XXX_Unmarshal(b []byte) error

type GateWayRegion_Cn470 

type GateWayRegion_Cn470 struct {
	Cn470 *CN470Config `protobuf:"bytes,2,opt,name=cn470,json=CN470,proto3,oneof"`
}

type GateWayRegion_Eu868 

type GateWayRegion_Eu868 struct {
	Eu868 *EU868Config `protobuf:"bytes,3,opt,name=eu868,json=EU868,proto3,oneof"`
}

type GateWayRegion_Us915 

type GateWayRegion_Us915 struct {
	Us915 *US915Config `protobuf:"bytes,4,opt,name=us915,json=US915,proto3,oneof"`
}

type Gateway 

type Gateway struct {
	// Gateway ID (HEX encoded).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Gateway name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Gateway description.
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Gateway location.
	Location *common.Location `protobuf:"bytes,4,opt,name=location,proto3" json:"location,omitempty"`
	// Organization ID to which the gateway belongs.
	// This can't be changed after creating the gateway.
	OrganizationId int64 `protobuf:"varint,5,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Set to true to enable gateway discovery.
	DiscoveryEnabled bool `protobuf:"varint,6,opt,name=discovery_enabled,json=discoveryEnabled,proto3" json:"discovery_enabled,omitempty"`
	// Network-server ID on which the gateway is provisioned.
	NetworkServerId int64                `protobuf:"varint,7,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	Channels        []uint32             `protobuf:"varint,12,rep,packed,name=channels,proto3" json:"channels,omitempty"`
	StatsInterval   *durationpb.Duration `protobuf:"bytes,13,opt,name=stats_interval,json=statsInterval,proto3" json:"stats_interval,omitempty"`
	// Gateway-profile ID (UUID string, optional).
	GatewayProfileId string `protobuf:"bytes,8,opt,name=gateway_profile_id,json=gatewayProfileID,proto3" json:"gateway_profile_id,omitempty"`
	// Gateway boards configuration (optional).
	// This is (currently) only needed when the gateway supports the fine-timestamp
	// and you you would like to add the FPGA ID to the gateway meta-data or would
	// like ChirpStack Network Server to decrypt the fine-timestamp.
	Boards []*GatewayBoard `protobuf:"bytes,9,rep,name=boards,proto3" json:"boards,omitempty"`
	// Tags (user defined).
	Tags map[string]string `` /* 150-byte string literal not displayed */
	// Metadata (provided by the gateway).
	Metadata             map[string]string `` /* 158-byte string literal not displayed */
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*Gateway) Descriptor 

func (*Gateway) Descriptor() ([]byte, []int)

func (*Gateway) GetBoards 

func (m *Gateway) GetBoards() []*GatewayBoard

func (*Gateway) GetChannels 

func (m *Gateway) GetChannels() []uint32

func (*Gateway) GetDescription 

func (m *Gateway) GetDescription() string

func (*Gateway) GetDiscoveryEnabled 

func (m *Gateway) GetDiscoveryEnabled() bool

func (*Gateway) GetGatewayProfileId 

func (m *Gateway) GetGatewayProfileId() string

func (*Gateway) GetId 

func (m *Gateway) GetId() string

func (*Gateway) GetLocation 

func (m *Gateway) GetLocation() *common.Location

func (*Gateway) GetMetadata 

func (m *Gateway) GetMetadata() map[string]string

func (*Gateway) GetName 

func (m *Gateway) GetName() string

func (*Gateway) GetNetworkServerId 

func (m *Gateway) GetNetworkServerId() int64

func (*Gateway) GetOrganizationId 

func (m *Gateway) GetOrganizationId() int64

func (*Gateway) GetStatsInterval 

func (m *Gateway) GetStatsInterval() *durationpb.Duration

func (*Gateway) GetTags 

func (m *Gateway) GetTags() map[string]string

func (*Gateway) ProtoMessage 

func (*Gateway) ProtoMessage()

func (*Gateway) Reset 

func (m *Gateway) Reset()

func (*Gateway) String 

func (m *Gateway) String() string

func (*Gateway) XXX_DiscardUnknown 

func (m *Gateway) XXX_DiscardUnknown()

func (*Gateway) XXX_Marshal 

func (m *Gateway) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Gateway) XXX_Merge 

func (m *Gateway) XXX_Merge(src proto.Message)

func (*Gateway) XXX_Size 

func (m *Gateway) XXX_Size() int

func (*Gateway) XXX_Unmarshal 

func (m *Gateway) XXX_Unmarshal(b []byte) error

type GatewayBoard 

type GatewayBoard struct {
	// FPGA ID of the gateway (HEX encoded) (optional).
	FpgaId string `protobuf:"bytes,1,opt,name=fpga_id,json=fpgaID,proto3" json:"fpga_id,omitempty"`
	// Fine-timestamp AES decryption key (HEX encoded) (optional).
	FineTimestampKey     string   `protobuf:"bytes,2,opt,name=fine_timestamp_key,json=fineTimestampKey,proto3" json:"fine_timestamp_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GatewayBoard) Descriptor 

func (*GatewayBoard) Descriptor() ([]byte, []int)

func (*GatewayBoard) GetFineTimestampKey 

func (m *GatewayBoard) GetFineTimestampKey() string

func (*GatewayBoard) GetFpgaId 

func (m *GatewayBoard) GetFpgaId() string

func (*GatewayBoard) ProtoMessage 

func (*GatewayBoard) ProtoMessage()

func (*GatewayBoard) Reset 

func (m *GatewayBoard) Reset()

func (*GatewayBoard) String 

func (m *GatewayBoard) String() string

func (*GatewayBoard) XXX_DiscardUnknown 

func (m *GatewayBoard) XXX_DiscardUnknown()

func (*GatewayBoard) XXX_Marshal 

func (m *GatewayBoard) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayBoard) XXX_Merge 

func (m *GatewayBoard) XXX_Merge(src proto.Message)

func (*GatewayBoard) XXX_Size 

func (m *GatewayBoard) XXX_Size() int

func (*GatewayBoard) XXX_Unmarshal 

func (m *GatewayBoard) XXX_Unmarshal(b []byte) error

type GatewayListItem 

type GatewayListItem struct {
	// Gateway ID (HEX encoded).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// A name for the gateway
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// A description for the gateway
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Create timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// First seen timestamp.
	FirstSeenAt *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=first_seen_at,json=firstSeenAt,proto3" json:"first_seen_at,omitempty"`
	// Last seen timestamp.
	LastSeenAt *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=last_seen_at,json=lastSeenAt,proto3" json:"last_seen_at,omitempty"`
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,6,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Network-server ID.
	NetworkServerId int64 `protobuf:"varint,7,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	// Location.
	Location *common.Location `protobuf:"bytes,10,opt,name=location,proto3" json:"location,omitempty"`
	// Network-server name.
	NetworkServerName    string               `protobuf:"bytes,11,opt,name=network_server_name,json=networkServerName,proto3" json:"network_server_name,omitempty"`
	Channels             []uint32             `protobuf:"varint,12,rep,packed,name=channels,proto3" json:"channels,omitempty"`
	StatsInterval        *durationpb.Duration `protobuf:"bytes,13,opt,name=stats_interval,json=statsInterval,proto3" json:"stats_interval,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*GatewayListItem) Descriptor 

func (*GatewayListItem) Descriptor() ([]byte, []int)

func (*GatewayListItem) GetChannels 

func (m *GatewayListItem) GetChannels() []uint32

func (*GatewayListItem) GetCreatedAt 

func (m *GatewayListItem) GetCreatedAt() *timestamppb.Timestamp

func (*GatewayListItem) GetDescription 

func (m *GatewayListItem) GetDescription() string

func (*GatewayListItem) GetFirstSeenAt 

func (m *GatewayListItem) GetFirstSeenAt() *timestamppb.Timestamp

func (*GatewayListItem) GetId 

func (m *GatewayListItem) GetId() string

func (*GatewayListItem) GetLastSeenAt 

func (m *GatewayListItem) GetLastSeenAt() *timestamppb.Timestamp

func (*GatewayListItem) GetLocation 

func (m *GatewayListItem) GetLocation() *common.Location

func (*GatewayListItem) GetName 

func (m *GatewayListItem) GetName() string

func (*GatewayListItem) GetNetworkServerId 

func (m *GatewayListItem) GetNetworkServerId() int64

func (*GatewayListItem) GetNetworkServerName 

func (m *GatewayListItem) GetNetworkServerName() string

func (*GatewayListItem) GetOrganizationId 

func (m *GatewayListItem) GetOrganizationId() int64

func (*GatewayListItem) GetStatsInterval 

func (m *GatewayListItem) GetStatsInterval() *durationpb.Duration

func (*GatewayListItem) GetUpdatedAt 

func (m *GatewayListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*GatewayListItem) ProtoMessage 

func (*GatewayListItem) ProtoMessage()

func (*GatewayListItem) Reset 

func (m *GatewayListItem) Reset()

func (*GatewayListItem) String 

func (m *GatewayListItem) String() string

func (*GatewayListItem) XXX_DiscardUnknown 

func (m *GatewayListItem) XXX_DiscardUnknown()

func (*GatewayListItem) XXX_Marshal 

func (m *GatewayListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayListItem) XXX_Merge 

func (m *GatewayListItem) XXX_Merge(src proto.Message)

func (*GatewayListItem) XXX_Size 

func (m *GatewayListItem) XXX_Size() int

func (*GatewayListItem) XXX_Unmarshal 

func (m *GatewayListItem) XXX_Unmarshal(b []byte) error

type GatewayLoraInfo 

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 (*GatewayLoraInfo) Descriptor 

func (*GatewayLoraInfo) Descriptor() ([]byte, []int)

func (*GatewayLoraInfo) GetFb 

func (m *GatewayLoraInfo) GetFb() string

func (*GatewayLoraInfo) GetFullDuplex 

func (m *GatewayLoraInfo) GetFullDuplex() bool

func (*GatewayLoraInfo) GetNumberOfChannels 

func (m *GatewayLoraInfo) GetNumberOfChannels() int32

func (*GatewayLoraInfo) GetStatus 

func (m *GatewayLoraInfo) GetStatus() string

func (*GatewayLoraInfo) ProtoMessage 

func (*GatewayLoraInfo) ProtoMessage()

func (*GatewayLoraInfo) Reset 

func (m *GatewayLoraInfo) Reset()

func (*GatewayLoraInfo) String 

func (m *GatewayLoraInfo) String() string

func (*GatewayLoraInfo) XXX_DiscardUnknown 

func (m *GatewayLoraInfo) XXX_DiscardUnknown()

func (*GatewayLoraInfo) XXX_Marshal 

func (m *GatewayLoraInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayLoraInfo) XXX_Merge 

func (m *GatewayLoraInfo) XXX_Merge(src proto.Message)

func (*GatewayLoraInfo) XXX_Size 

func (m *GatewayLoraInfo) XXX_Size() int

func (*GatewayLoraInfo) XXX_Unmarshal 

func (m *GatewayLoraInfo) XXX_Unmarshal(b []byte) error

type GatewayProfile 

type GatewayProfile struct {
	// Gateway-profile ID (UUID string).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Name of the gateway-profile.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Network-server ID of the gateway-profile.
	NetworkServerId int64 `protobuf:"varint,3,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	// Default channels (channels specified by the LoRaWAN Regional Parameters
	// specification) enabled for this configuration.
	Channels []uint32 `protobuf:"varint,4,rep,packed,name=channels,proto3" json:"channels,omitempty"`
	// Extra channels added to the channel-configuration (in case the LoRaWAN
	// region supports adding custom channels).
	ExtraChannels []*GatewayProfileExtraChannel `protobuf:"bytes,5,rep,name=extra_channels,json=extraChannels,proto3" json:"extra_channels,omitempty"`
	// Stats interval.
	// This defines the (expected) stats interval which the gateways using this
	// gateway-profile are using.
	StatsInterval        *durationpb.Duration `protobuf:"bytes,6,opt,name=stats_interval,json=statsInterval,proto3" json:"stats_interval,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*GatewayProfile) Descriptor 

func (*GatewayProfile) Descriptor() ([]byte, []int)

func (*GatewayProfile) GetChannels 

func (m *GatewayProfile) GetChannels() []uint32

func (*GatewayProfile) GetExtraChannels 

func (m *GatewayProfile) GetExtraChannels() []*GatewayProfileExtraChannel

func (*GatewayProfile) GetId 

func (m *GatewayProfile) GetId() string

func (*GatewayProfile) GetName 

func (m *GatewayProfile) GetName() string

func (*GatewayProfile) GetNetworkServerId 

func (m *GatewayProfile) GetNetworkServerId() int64

func (*GatewayProfile) GetStatsInterval 

func (m *GatewayProfile) GetStatsInterval() *durationpb.Duration

func (*GatewayProfile) ProtoMessage 

func (*GatewayProfile) ProtoMessage()

func (*GatewayProfile) Reset 

func (m *GatewayProfile) Reset()

func (*GatewayProfile) String 

func (m *GatewayProfile) String() string

func (*GatewayProfile) XXX_DiscardUnknown 

func (m *GatewayProfile) XXX_DiscardUnknown()

func (*GatewayProfile) XXX_Marshal 

func (m *GatewayProfile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayProfile) XXX_Merge 

func (m *GatewayProfile) XXX_Merge(src proto.Message)

func (*GatewayProfile) XXX_Size 

func (m *GatewayProfile) XXX_Size() int

func (*GatewayProfile) XXX_Unmarshal 

func (m *GatewayProfile) XXX_Unmarshal(b []byte) error

type GatewayProfileExtraChannel 

type GatewayProfileExtraChannel struct {
	// Modulation.
	Modulation common.Modulation `protobuf:"varint,1,opt,name=modulation,proto3,enum=common.Modulation" json:"modulation,omitempty"`
	// Frequency.
	Frequency uint32 `protobuf:"varint,2,opt,name=frequency,proto3" json:"frequency,omitempty"`
	// Bandwidth.
	Bandwidth uint32 `protobuf:"varint,3,opt,name=bandwidth,proto3" json:"bandwidth,omitempty"`
	// Bitrate (in case of FSK modulation).
	Bitrate uint32 `protobuf:"varint,4,opt,name=bitrate,proto3" json:"bitrate,omitempty"`
	// Spreading factors (in case of LoRa modulation).
	SpreadingFactors     []uint32 `protobuf:"varint,5,rep,packed,name=spreading_factors,json=spreadingFactors,proto3" json:"spreading_factors,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GatewayProfileExtraChannel) Descriptor 

func (*GatewayProfileExtraChannel) Descriptor() ([]byte, []int)

func (*GatewayProfileExtraChannel) GetBandwidth 

func (m *GatewayProfileExtraChannel) GetBandwidth() uint32

func (*GatewayProfileExtraChannel) GetBitrate 

func (m *GatewayProfileExtraChannel) GetBitrate() uint32

func (*GatewayProfileExtraChannel) GetFrequency 

func (m *GatewayProfileExtraChannel) GetFrequency() uint32

func (*GatewayProfileExtraChannel) GetModulation 

func (m *GatewayProfileExtraChannel) GetModulation() common.Modulation

func (*GatewayProfileExtraChannel) GetSpreadingFactors 

func (m *GatewayProfileExtraChannel) GetSpreadingFactors() []uint32

func (*GatewayProfileExtraChannel) ProtoMessage 

func (*GatewayProfileExtraChannel) ProtoMessage()

func (*GatewayProfileExtraChannel) Reset 

func (m *GatewayProfileExtraChannel) Reset()

func (*GatewayProfileExtraChannel) String 

func (m *GatewayProfileExtraChannel) String() string

func (*GatewayProfileExtraChannel) XXX_DiscardUnknown 

func (m *GatewayProfileExtraChannel) XXX_DiscardUnknown()

func (*GatewayProfileExtraChannel) XXX_Marshal 

func (m *GatewayProfileExtraChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayProfileExtraChannel) XXX_Merge 

func (m *GatewayProfileExtraChannel) XXX_Merge(src proto.Message)

func (*GatewayProfileExtraChannel) XXX_Size 

func (m *GatewayProfileExtraChannel) XXX_Size() int

func (*GatewayProfileExtraChannel) XXX_Unmarshal 

func (m *GatewayProfileExtraChannel) XXX_Unmarshal(b []byte) error

type GatewayProfileListItem 

type GatewayProfileListItem struct {
	// Gateway-profile ID (UUID string).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Gateway-profile name,
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Network-server ID on which the gateway-profile is provisioned.
	NetworkServerId int64 `protobuf:"varint,3,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	// Network-server name.
	NetworkServerName string `protobuf:"bytes,7,opt,name=network_server_name,json=networkServerName,proto3" json:"network_server_name,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GatewayProfileListItem) Descriptor 

func (*GatewayProfileListItem) Descriptor() ([]byte, []int)

func (*GatewayProfileListItem) GetCreatedAt 

func (m *GatewayProfileListItem) GetCreatedAt() *timestamppb.Timestamp

func (*GatewayProfileListItem) GetId 

func (m *GatewayProfileListItem) GetId() string

func (*GatewayProfileListItem) GetName 

func (m *GatewayProfileListItem) GetName() string

func (*GatewayProfileListItem) GetNetworkServerId 

func (m *GatewayProfileListItem) GetNetworkServerId() int64

func (*GatewayProfileListItem) GetNetworkServerName 

func (m *GatewayProfileListItem) GetNetworkServerName() string

func (*GatewayProfileListItem) GetUpdatedAt 

func (m *GatewayProfileListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*GatewayProfileListItem) ProtoMessage 

func (*GatewayProfileListItem) ProtoMessage()

func (*GatewayProfileListItem) Reset 

func (m *GatewayProfileListItem) Reset()

func (*GatewayProfileListItem) String 

func (m *GatewayProfileListItem) String() string

func (*GatewayProfileListItem) XXX_DiscardUnknown 

func (m *GatewayProfileListItem) XXX_DiscardUnknown()

func (*GatewayProfileListItem) XXX_Marshal 

func (m *GatewayProfileListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayProfileListItem) XXX_Merge 

func (m *GatewayProfileListItem) XXX_Merge(src proto.Message)

func (*GatewayProfileListItem) XXX_Size 

func (m *GatewayProfileListItem) XXX_Size() int

func (*GatewayProfileListItem) XXX_Unmarshal 

func (m *GatewayProfileListItem) XXX_Unmarshal(b []byte) error

type GatewayProfileServiceClient 

type GatewayProfileServiceClient interface {
	// Create creates the given gateway-profile.
	Create(ctx context.Context, in *CreateGatewayProfileRequest, opts ...grpc.CallOption) (*CreateGatewayProfileResponse, error)
	// Get returns the gateway-profile matching the given id.
	Get(ctx context.Context, in *GetGatewayProfileRequest, opts ...grpc.CallOption) (*GetGatewayProfileResponse, error)
	// Update updates the given gateway-profile.
	Update(ctx context.Context, in *UpdateGatewayProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete deletes the gateway-profile matching the given id.
	Delete(ctx context.Context, in *DeleteGatewayProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List returns the existing gateway-profiles.
	List(ctx context.Context, in *ListGatewayProfilesRequest, opts ...grpc.CallOption) (*ListGatewayProfilesResponse, error)
}

GatewayProfileServiceClient is the client API for GatewayProfileService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewGatewayProfileServiceClient 

func NewGatewayProfileServiceClient(cc grpc.ClientConnInterface) GatewayProfileServiceClient

type GatewayProfileServiceServer 

type GatewayProfileServiceServer interface {
	// Create creates the given gateway-profile.
	Create(context.Context, *CreateGatewayProfileRequest) (*CreateGatewayProfileResponse, error)
	// Get returns the gateway-profile matching the given id.
	Get(context.Context, *GetGatewayProfileRequest) (*GetGatewayProfileResponse, error)
	// Update updates the given gateway-profile.
	Update(context.Context, *UpdateGatewayProfileRequest) (*emptypb.Empty, error)
	// Delete deletes the gateway-profile matching the given id.
	Delete(context.Context, *DeleteGatewayProfileRequest) (*emptypb.Empty, error)
	// List returns the existing gateway-profiles.
	List(context.Context, *ListGatewayProfilesRequest) (*ListGatewayProfilesResponse, error)
}

GatewayProfileServiceServer is the server API for GatewayProfileService service.

type GatewayServiceClient 

type GatewayServiceClient interface {
	// Create creates the given gateway.
	Create(ctx context.Context, in *CreateGatewayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Get returns the gateway for the requested mac address.
	Get(ctx context.Context, in *GetGatewayRequest, opts ...grpc.CallOption) (*GetGatewayResponse, error)
	// Update updates the gateway matching the given mac address.
	Update(ctx context.Context, in *UpdateGatewayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete deletes the gateway matching the given mac address.
	Delete(ctx context.Context, in *DeleteGatewayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List lists the gateways.
	List(ctx context.Context, in *ListGatewayRequest, opts ...grpc.CallOption) (*ListGatewayResponse, error)
	// GetStats lists the gateway stats given the query parameters.
	GetStats(ctx context.Context, in *GetGatewayStatsRequest, opts ...grpc.CallOption) (*GetGatewayStatsResponse, error)
	// GetLastPing returns the last emitted ping and gateways receiving this ping.
	GetLastPing(ctx context.Context, in *GetLastPingRequest, opts ...grpc.CallOption) (*GetLastPingResponse, error)
	// GenerateGatewayClientCertificate returns TLS certificate gateway authentication / authorization.
	// This endpoint can ony be used when ChirpStack Network Server is configured with a gateway
	// CA certificate and key, which is used for signing the TLS certificate. The returned TLS
	// certificate will have the Gateway ID as Common Name.
	GenerateGatewayClientCertificate(ctx context.Context, in *GenerateGatewayClientCertificateRequest, opts ...grpc.CallOption) (*GenerateGatewayClientCertificateResponse, error)
	// StreamFrameLogs streams the uplink and downlink frame-logs for the given gateway ID.
	// Notes:
	//   - These are the raw LoRaWAN frames and this endpoint is intended for debugging only.
	//   - This endpoint does not work from a web-browser.
	StreamFrameLogs(ctx context.Context, in *StreamGatewayFrameLogsRequest, opts ...grpc.CallOption) (GatewayService_StreamFrameLogsClient, error)
}

GatewayServiceClient is the client API for GatewayService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewGatewayServiceClient 

func NewGatewayServiceClient(cc grpc.ClientConnInterface) GatewayServiceClient

type GatewayServiceServer 

type GatewayServiceServer interface {
	// Create creates the given gateway.
	Create(context.Context, *CreateGatewayRequest) (*emptypb.Empty, error)
	// Get returns the gateway for the requested mac address.
	Get(context.Context, *GetGatewayRequest) (*GetGatewayResponse, error)
	// Update updates the gateway matching the given mac address.
	Update(context.Context, *UpdateGatewayRequest) (*emptypb.Empty, error)
	// Delete deletes the gateway matching the given mac address.
	Delete(context.Context, *DeleteGatewayRequest) (*emptypb.Empty, error)
	// List lists the gateways.
	List(context.Context, *ListGatewayRequest) (*ListGatewayResponse, error)
	// GetStats lists the gateway stats given the query parameters.
	GetStats(context.Context, *GetGatewayStatsRequest) (*GetGatewayStatsResponse, error)
	// GetLastPing returns the last emitted ping and gateways receiving this ping.
	GetLastPing(context.Context, *GetLastPingRequest) (*GetLastPingResponse, error)
	// GenerateGatewayClientCertificate returns TLS certificate gateway authentication / authorization.
	// This endpoint can ony be used when ChirpStack Network Server is configured with a gateway
	// CA certificate and key, which is used for signing the TLS certificate. The returned TLS
	// certificate will have the Gateway ID as Common Name.
	GenerateGatewayClientCertificate(context.Context, *GenerateGatewayClientCertificateRequest) (*GenerateGatewayClientCertificateResponse, error)
	// StreamFrameLogs streams the uplink and downlink frame-logs for the given gateway ID.
	// Notes:
	//   - These are the raw LoRaWAN frames and this endpoint is intended for debugging only.
	//   - This endpoint does not work from a web-browser.
	StreamFrameLogs(*StreamGatewayFrameLogsRequest, GatewayService_StreamFrameLogsServer) error
}

GatewayServiceServer is the server API for GatewayService service.

type GatewayService_StreamFrameLogsClient 

type GatewayService_StreamFrameLogsClient interface {
	Recv() (*StreamGatewayFrameLogsResponse, error)
	grpc.ClientStream
}

type GatewayService_StreamFrameLogsServer 

type GatewayService_StreamFrameLogsServer interface {
	Send(*StreamGatewayFrameLogsResponse) error
	grpc.ServerStream
}

type GatewayStats 

type GatewayStats struct {
	// Timestamp of the (aggregated) measurement.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Packets received by the gateway.
	RxPacketsReceived int32 `protobuf:"varint,2,opt,name=rx_packets_received,json=rxPacketsReceived,proto3" json:"rx_packets_received,omitempty"`
	// Packets received by the gateway that passed the CRC check.
	RxPacketsReceivedOk int32 `protobuf:"varint,3,opt,name=rx_packets_received_ok,json=rxPacketsReceivedOK,proto3" json:"rx_packets_received_ok,omitempty"`
	// Packets received by the gateway for transmission.
	TxPacketsReceived int32 `protobuf:"varint,4,opt,name=tx_packets_received,json=txPacketsReceived,proto3" json:"tx_packets_received,omitempty"`
	// Packets transmitted by the gateway.
	TxPacketsEmitted     int32    `protobuf:"varint,5,opt,name=tx_packets_emitted,json=txPacketsEmitted,proto3" json:"tx_packets_emitted,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GatewayStats) Descriptor 

func (*GatewayStats) Descriptor() ([]byte, []int)

func (*GatewayStats) GetRxPacketsReceived 

func (m *GatewayStats) GetRxPacketsReceived() int32

func (*GatewayStats) GetRxPacketsReceivedOk 

func (m *GatewayStats) GetRxPacketsReceivedOk() int32

func (*GatewayStats) GetTimestamp 

func (m *GatewayStats) GetTimestamp() *timestamppb.Timestamp

func (*GatewayStats) GetTxPacketsEmitted 

func (m *GatewayStats) GetTxPacketsEmitted() int32

func (*GatewayStats) GetTxPacketsReceived 

func (m *GatewayStats) GetTxPacketsReceived() int32

func (*GatewayStats) ProtoMessage 

func (*GatewayStats) ProtoMessage()

func (*GatewayStats) Reset 

func (m *GatewayStats) Reset()

func (*GatewayStats) String 

func (m *GatewayStats) String() string

func (*GatewayStats) XXX_DiscardUnknown 

func (m *GatewayStats) XXX_DiscardUnknown()

func (*GatewayStats) XXX_Marshal 

func (m *GatewayStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayStats) XXX_Merge 

func (m *GatewayStats) XXX_Merge(src proto.Message)

func (*GatewayStats) XXX_Size 

func (m *GatewayStats) XXX_Size() int

func (*GatewayStats) XXX_Unmarshal 

func (m *GatewayStats) XXX_Unmarshal(b []byte) error

type GatewayStatsRequest 

type GatewayStatsRequest struct {
	GatewayId            string   `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayID,proto3" json:"gateway_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GatewayStatsRequest) Descriptor 

func (*GatewayStatsRequest) Descriptor() ([]byte, []int)

func (*GatewayStatsRequest) GetGatewayId 

func (m *GatewayStatsRequest) GetGatewayId() string

func (*GatewayStatsRequest) ProtoMessage 

func (*GatewayStatsRequest) ProtoMessage()

func (*GatewayStatsRequest) Reset 

func (m *GatewayStatsRequest) Reset()

func (*GatewayStatsRequest) String 

func (m *GatewayStatsRequest) String() string

func (*GatewayStatsRequest) XXX_DiscardUnknown 

func (m *GatewayStatsRequest) XXX_DiscardUnknown()

func (*GatewayStatsRequest) XXX_Marshal 

func (m *GatewayStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayStatsRequest) XXX_Merge 

func (m *GatewayStatsRequest) XXX_Merge(src proto.Message)

func (*GatewayStatsRequest) XXX_Size 

func (m *GatewayStatsRequest) XXX_Size() int

func (*GatewayStatsRequest) XXX_Unmarshal 

func (m *GatewayStatsRequest) XXX_Unmarshal(b []byte) error

type GatewayStatsResponse 

type GatewayStatsResponse struct {
	Stats                *gw.GatewayStatitics `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*GatewayStatsResponse) Descriptor 

func (*GatewayStatsResponse) Descriptor() ([]byte, []int)

func (*GatewayStatsResponse) GetStats 

func (m *GatewayStatsResponse) GetStats() *gw.GatewayStatitics

func (*GatewayStatsResponse) ProtoMessage 

func (*GatewayStatsResponse) ProtoMessage()

func (*GatewayStatsResponse) Reset 

func (m *GatewayStatsResponse) Reset()

func (*GatewayStatsResponse) String 

func (m *GatewayStatsResponse) String() string

func (*GatewayStatsResponse) XXX_DiscardUnknown 

func (m *GatewayStatsResponse) XXX_DiscardUnknown()

func (*GatewayStatsResponse) XXX_Marshal 

func (m *GatewayStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GatewayStatsResponse) XXX_Merge 

func (m *GatewayStatsResponse) XXX_Merge(src proto.Message)

func (*GatewayStatsResponse) XXX_Size 

func (m *GatewayStatsResponse) XXX_Size() int

func (*GatewayStatsResponse) XXX_Unmarshal 

func (m *GatewayStatsResponse) XXX_Unmarshal(b []byte) error

type GenerateGatewayClientCertificateRequest 

type GenerateGatewayClientCertificateRequest struct {
	// Gateway ID (HEX encoded).
	GatewayId            string   `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayId,proto3" json:"gateway_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GenerateGatewayClientCertificateRequest) Descriptor 

func (*GenerateGatewayClientCertificateRequest) Descriptor() ([]byte, []int)

func (*GenerateGatewayClientCertificateRequest) GetGatewayId 

func (m *GenerateGatewayClientCertificateRequest) GetGatewayId() string

func (*GenerateGatewayClientCertificateRequest) ProtoMessage 

func (*GenerateGatewayClientCertificateRequest) ProtoMessage()

func (*GenerateGatewayClientCertificateRequest) Reset 

func (m *GenerateGatewayClientCertificateRequest) Reset()

func (*GenerateGatewayClientCertificateRequest) String 

func (m *GenerateGatewayClientCertificateRequest) String() string

func (*GenerateGatewayClientCertificateRequest) XXX_DiscardUnknown 

func (m *GenerateGatewayClientCertificateRequest) XXX_DiscardUnknown()

func (*GenerateGatewayClientCertificateRequest) XXX_Marshal 

func (m *GenerateGatewayClientCertificateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GenerateGatewayClientCertificateRequest) XXX_Merge 

func (m *GenerateGatewayClientCertificateRequest) XXX_Merge(src proto.Message)

func (*GenerateGatewayClientCertificateRequest) XXX_Size 

func (m *GenerateGatewayClientCertificateRequest) XXX_Size() int

func (*GenerateGatewayClientCertificateRequest) XXX_Unmarshal 

func (m *GenerateGatewayClientCertificateRequest) XXX_Unmarshal(b []byte) error

type GenerateGatewayClientCertificateResponse 

type GenerateGatewayClientCertificateResponse struct {
	// TLS certificate.
	TlsCert string `protobuf:"bytes,1,opt,name=tls_cert,json=tlsCert,proto3" json:"tls_cert,omitempty"`
	// TLS key.
	TlsKey string `protobuf:"bytes,2,opt,name=tls_key,json=tlsKey,proto3" json:"tls_key,omitempty"`
	// CA certificate.
	CaCert string `protobuf:"bytes,3,opt,name=ca_cert,json=caCert,proto3" json:"ca_cert,omitempty"`
	// Expires at defines the expiration date of the certificate.
	ExpiresAt            *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GenerateGatewayClientCertificateResponse) Descriptor 

func (*GenerateGatewayClientCertificateResponse) Descriptor() ([]byte, []int)

func (*GenerateGatewayClientCertificateResponse) GetCaCert 

func (m *GenerateGatewayClientCertificateResponse) GetCaCert() string

func (*GenerateGatewayClientCertificateResponse) GetExpiresAt 

func (m *GenerateGatewayClientCertificateResponse) GetExpiresAt() *timestamppb.Timestamp

func (*GenerateGatewayClientCertificateResponse) GetTlsCert 

func (m *GenerateGatewayClientCertificateResponse) GetTlsCert() string

func (*GenerateGatewayClientCertificateResponse) GetTlsKey 

func (m *GenerateGatewayClientCertificateResponse) GetTlsKey() string

func (*GenerateGatewayClientCertificateResponse) ProtoMessage 

func (*GenerateGatewayClientCertificateResponse) ProtoMessage()

func (*GenerateGatewayClientCertificateResponse) Reset 

func (m *GenerateGatewayClientCertificateResponse) Reset()

func (*GenerateGatewayClientCertificateResponse) String 

func (m *GenerateGatewayClientCertificateResponse) String() string

func (*GenerateGatewayClientCertificateResponse) XXX_DiscardUnknown 

func (m *GenerateGatewayClientCertificateResponse) XXX_DiscardUnknown()

func (*GenerateGatewayClientCertificateResponse) XXX_Marshal 

func (m *GenerateGatewayClientCertificateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GenerateGatewayClientCertificateResponse) XXX_Merge 

func (m *GenerateGatewayClientCertificateResponse) XXX_Merge(src proto.Message)

func (*GenerateGatewayClientCertificateResponse) XXX_Size 

func (m *GenerateGatewayClientCertificateResponse) XXX_Size() int

func (*GenerateGatewayClientCertificateResponse) XXX_Unmarshal 

func (m *GenerateGatewayClientCertificateResponse) XXX_Unmarshal(b []byte) error

type GetAWSSNSIntegrationRequest 

type GetAWSSNSIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetAWSSNSIntegrationRequest) Descriptor 

func (*GetAWSSNSIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetAWSSNSIntegrationRequest) GetApplicationId 

func (m *GetAWSSNSIntegrationRequest) GetApplicationId() int64

func (*GetAWSSNSIntegrationRequest) ProtoMessage 

func (*GetAWSSNSIntegrationRequest) ProtoMessage()

func (*GetAWSSNSIntegrationRequest) Reset 

func (m *GetAWSSNSIntegrationRequest) Reset()

func (*GetAWSSNSIntegrationRequest) String 

func (m *GetAWSSNSIntegrationRequest) String() string

func (*GetAWSSNSIntegrationRequest) XXX_DiscardUnknown 

func (m *GetAWSSNSIntegrationRequest) XXX_DiscardUnknown()

func (*GetAWSSNSIntegrationRequest) XXX_Marshal 

func (m *GetAWSSNSIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetAWSSNSIntegrationRequest) XXX_Merge 

func (m *GetAWSSNSIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetAWSSNSIntegrationRequest) XXX_Size 

func (m *GetAWSSNSIntegrationRequest) XXX_Size() int

func (*GetAWSSNSIntegrationRequest) XXX_Unmarshal 

func (m *GetAWSSNSIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetAWSSNSIntegrationResponse 

type GetAWSSNSIntegrationResponse struct {
	// Integration object.
	Integration          *AWSSNSIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*GetAWSSNSIntegrationResponse) Descriptor 

func (*GetAWSSNSIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetAWSSNSIntegrationResponse) GetIntegration 

func (m *GetAWSSNSIntegrationResponse) GetIntegration() *AWSSNSIntegration

func (*GetAWSSNSIntegrationResponse) ProtoMessage 

func (*GetAWSSNSIntegrationResponse) ProtoMessage()

func (*GetAWSSNSIntegrationResponse) Reset 

func (m *GetAWSSNSIntegrationResponse) Reset()

func (*GetAWSSNSIntegrationResponse) String 

func (m *GetAWSSNSIntegrationResponse) String() string

func (*GetAWSSNSIntegrationResponse) XXX_DiscardUnknown 

func (m *GetAWSSNSIntegrationResponse) XXX_DiscardUnknown()

func (*GetAWSSNSIntegrationResponse) XXX_Marshal 

func (m *GetAWSSNSIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetAWSSNSIntegrationResponse) XXX_Merge 

func (m *GetAWSSNSIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetAWSSNSIntegrationResponse) XXX_Size 

func (m *GetAWSSNSIntegrationResponse) XXX_Size() int

func (*GetAWSSNSIntegrationResponse) XXX_Unmarshal 

func (m *GetAWSSNSIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetApplicationRequest 

type GetApplicationRequest struct {
	// Application ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetApplicationRequest) Descriptor 

func (*GetApplicationRequest) Descriptor() ([]byte, []int)

func (*GetApplicationRequest) GetId 

func (m *GetApplicationRequest) GetId() int64

func (*GetApplicationRequest) ProtoMessage 

func (*GetApplicationRequest) ProtoMessage()

func (*GetApplicationRequest) Reset 

func (m *GetApplicationRequest) Reset()

func (*GetApplicationRequest) String 

func (m *GetApplicationRequest) String() string

func (*GetApplicationRequest) XXX_DiscardUnknown 

func (m *GetApplicationRequest) XXX_DiscardUnknown()

func (*GetApplicationRequest) XXX_Marshal 

func (m *GetApplicationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetApplicationRequest) XXX_Merge 

func (m *GetApplicationRequest) XXX_Merge(src proto.Message)

func (*GetApplicationRequest) XXX_Size 

func (m *GetApplicationRequest) XXX_Size() int

func (*GetApplicationRequest) XXX_Unmarshal 

func (m *GetApplicationRequest) XXX_Unmarshal(b []byte) error

type GetApplicationResponse 

type GetApplicationResponse struct {
	// Application object.
	Application          *Application `protobuf:"bytes,1,opt,name=application,proto3" json:"application,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (*GetApplicationResponse) Descriptor 

func (*GetApplicationResponse) Descriptor() ([]byte, []int)

func (*GetApplicationResponse) GetApplication 

func (m *GetApplicationResponse) GetApplication() *Application

func (*GetApplicationResponse) ProtoMessage 

func (*GetApplicationResponse) ProtoMessage()

func (*GetApplicationResponse) Reset 

func (m *GetApplicationResponse) Reset()

func (*GetApplicationResponse) String 

func (m *GetApplicationResponse) String() string

func (*GetApplicationResponse) XXX_DiscardUnknown 

func (m *GetApplicationResponse) XXX_DiscardUnknown()

func (*GetApplicationResponse) XXX_Marshal 

func (m *GetApplicationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetApplicationResponse) XXX_Merge 

func (m *GetApplicationResponse) XXX_Merge(src proto.Message)

func (*GetApplicationResponse) XXX_Size 

func (m *GetApplicationResponse) XXX_Size() int

func (*GetApplicationResponse) XXX_Unmarshal 

func (m *GetApplicationResponse) XXX_Unmarshal(b []byte) error

type GetAzureServiceBusIntegrationRequest 

type GetAzureServiceBusIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetAzureServiceBusIntegrationRequest) Descriptor 

func (*GetAzureServiceBusIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetAzureServiceBusIntegrationRequest) GetApplicationId 

func (m *GetAzureServiceBusIntegrationRequest) GetApplicationId() int64

func (*GetAzureServiceBusIntegrationRequest) ProtoMessage 

func (*GetAzureServiceBusIntegrationRequest) ProtoMessage()

func (*GetAzureServiceBusIntegrationRequest) Reset 

func (m *GetAzureServiceBusIntegrationRequest) Reset()

func (*GetAzureServiceBusIntegrationRequest) String 

func (m *GetAzureServiceBusIntegrationRequest) String() string

func (*GetAzureServiceBusIntegrationRequest) XXX_DiscardUnknown 

func (m *GetAzureServiceBusIntegrationRequest) XXX_DiscardUnknown()

func (*GetAzureServiceBusIntegrationRequest) XXX_Marshal 

func (m *GetAzureServiceBusIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetAzureServiceBusIntegrationRequest) XXX_Merge 

func (m *GetAzureServiceBusIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetAzureServiceBusIntegrationRequest) XXX_Size 

func (m *GetAzureServiceBusIntegrationRequest) XXX_Size() int

func (*GetAzureServiceBusIntegrationRequest) XXX_Unmarshal 

func (m *GetAzureServiceBusIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetAzureServiceBusIntegrationResponse 

type GetAzureServiceBusIntegrationResponse struct {
	// Integration object.
	Integration          *AzureServiceBusIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (*GetAzureServiceBusIntegrationResponse) Descriptor 

func (*GetAzureServiceBusIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetAzureServiceBusIntegrationResponse) GetIntegration 

func (m *GetAzureServiceBusIntegrationResponse) GetIntegration() *AzureServiceBusIntegration

func (*GetAzureServiceBusIntegrationResponse) ProtoMessage 

func (*GetAzureServiceBusIntegrationResponse) ProtoMessage()

func (*GetAzureServiceBusIntegrationResponse) Reset 

func (m *GetAzureServiceBusIntegrationResponse) Reset()

func (*GetAzureServiceBusIntegrationResponse) String 

func (m *GetAzureServiceBusIntegrationResponse) String() string

func (*GetAzureServiceBusIntegrationResponse) XXX_DiscardUnknown 

func (m *GetAzureServiceBusIntegrationResponse) XXX_DiscardUnknown()

func (*GetAzureServiceBusIntegrationResponse) XXX_Marshal 

func (m *GetAzureServiceBusIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetAzureServiceBusIntegrationResponse) XXX_Merge 

func (m *GetAzureServiceBusIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetAzureServiceBusIntegrationResponse) XXX_Size 

func (m *GetAzureServiceBusIntegrationResponse) XXX_Size() int

func (*GetAzureServiceBusIntegrationResponse) XXX_Unmarshal 

func (m *GetAzureServiceBusIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetClientResponse 

type GetClientResponse struct {
	Eth                  *Ethernet   `protobuf:"bytes,2,opt,name=eth,proto3" json:"eth,omitempty"`
	Cat1                 *MoudleCat1 `protobuf:"bytes,3,opt,name=cat1,proto3" json:"cat1,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*GetClientResponse) Descriptor 

func (*GetClientResponse) Descriptor() ([]byte, []int)

func (*GetClientResponse) GetCat1 

func (m *GetClientResponse) GetCat1() *MoudleCat1

func (*GetClientResponse) GetEth 

func (m *GetClientResponse) GetEth() *Ethernet

func (*GetClientResponse) ProtoMessage 

func (*GetClientResponse) ProtoMessage()

func (*GetClientResponse) Reset 

func (m *GetClientResponse) Reset()

func (*GetClientResponse) String 

func (m *GetClientResponse) String() string

func (*GetClientResponse) XXX_DiscardUnknown 

func (m *GetClientResponse) XXX_DiscardUnknown()

func (*GetClientResponse) XXX_Marshal 

func (m *GetClientResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetClientResponse) XXX_Merge 

func (m *GetClientResponse) XXX_Merge(src proto.Message)

func (*GetClientResponse) XXX_Size 

func (m *GetClientResponse) XXX_Size() int

func (*GetClientResponse) XXX_Unmarshal 

func (m *GetClientResponse) XXX_Unmarshal(b []byte) error

type GetDeviceActivationRequest 

type GetDeviceActivationRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetDeviceActivationRequest) Descriptor 

func (*GetDeviceActivationRequest) Descriptor() ([]byte, []int)

func (*GetDeviceActivationRequest) GetDevEui 

func (m *GetDeviceActivationRequest) GetDevEui() string

func (*GetDeviceActivationRequest) ProtoMessage 

func (*GetDeviceActivationRequest) ProtoMessage()

func (*GetDeviceActivationRequest) Reset 

func (m *GetDeviceActivationRequest) Reset()

func (*GetDeviceActivationRequest) String 

func (m *GetDeviceActivationRequest) String() string

func (*GetDeviceActivationRequest) XXX_DiscardUnknown 

func (m *GetDeviceActivationRequest) XXX_DiscardUnknown()

func (*GetDeviceActivationRequest) XXX_Marshal 

func (m *GetDeviceActivationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceActivationRequest) XXX_Merge 

func (m *GetDeviceActivationRequest) XXX_Merge(src proto.Message)

func (*GetDeviceActivationRequest) XXX_Size 

func (m *GetDeviceActivationRequest) XXX_Size() int

func (*GetDeviceActivationRequest) XXX_Unmarshal 

func (m *GetDeviceActivationRequest) XXX_Unmarshal(b []byte) error

type GetDeviceActivationResponse 

type GetDeviceActivationResponse struct {
	// Device-activation object.
	DeviceActivation     *DeviceActivation `protobuf:"bytes,1,opt,name=device_activation,json=deviceActivation,proto3" json:"device_activation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*GetDeviceActivationResponse) Descriptor 

func (*GetDeviceActivationResponse) Descriptor() ([]byte, []int)

func (*GetDeviceActivationResponse) GetDeviceActivation 

func (m *GetDeviceActivationResponse) GetDeviceActivation() *DeviceActivation

func (*GetDeviceActivationResponse) ProtoMessage 

func (*GetDeviceActivationResponse) ProtoMessage()

func (*GetDeviceActivationResponse) Reset 

func (m *GetDeviceActivationResponse) Reset()

func (*GetDeviceActivationResponse) String 

func (m *GetDeviceActivationResponse) String() string

func (*GetDeviceActivationResponse) XXX_DiscardUnknown 

func (m *GetDeviceActivationResponse) XXX_DiscardUnknown()

func (*GetDeviceActivationResponse) XXX_Marshal 

func (m *GetDeviceActivationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceActivationResponse) XXX_Merge 

func (m *GetDeviceActivationResponse) XXX_Merge(src proto.Message)

func (*GetDeviceActivationResponse) XXX_Size 

func (m *GetDeviceActivationResponse) XXX_Size() int

func (*GetDeviceActivationResponse) XXX_Unmarshal 

func (m *GetDeviceActivationResponse) XXX_Unmarshal(b []byte) error

type GetDeviceDetailsRequest 

type GetDeviceDetailsRequest struct {
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetDeviceDetailsRequest) Descriptor 

func (*GetDeviceDetailsRequest) Descriptor() ([]byte, []int)

func (*GetDeviceDetailsRequest) GetDevEui 

func (m *GetDeviceDetailsRequest) GetDevEui() string

func (*GetDeviceDetailsRequest) ProtoMessage 

func (*GetDeviceDetailsRequest) ProtoMessage()

func (*GetDeviceDetailsRequest) Reset 

func (m *GetDeviceDetailsRequest) Reset()

func (*GetDeviceDetailsRequest) String 

func (m *GetDeviceDetailsRequest) String() string

func (*GetDeviceDetailsRequest) XXX_DiscardUnknown 

func (m *GetDeviceDetailsRequest) XXX_DiscardUnknown()

func (*GetDeviceDetailsRequest) XXX_Marshal 

func (m *GetDeviceDetailsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceDetailsRequest) XXX_Merge 

func (m *GetDeviceDetailsRequest) XXX_Merge(src proto.Message)

func (*GetDeviceDetailsRequest) XXX_Size 

func (m *GetDeviceDetailsRequest) XXX_Size() int

func (*GetDeviceDetailsRequest) XXX_Unmarshal 

func (m *GetDeviceDetailsRequest) XXX_Unmarshal(b []byte) error

type GetDeviceDetailsResponse 

type GetDeviceDetailsResponse struct {
	Name                 string      `protobuf:"bytes,1,opt,name=name,json=devName,proto3" json:"name,omitempty"`
	Otaa                 *OTAADevice `protobuf:"bytes,2,opt,name=otaa,json=OTAA,proto3" json:"otaa,omitempty"`
	Abp                  *ABPDevice  `protobuf:"bytes,3,opt,name=abp,json=ABP,proto3" json:"abp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*GetDeviceDetailsResponse) Descriptor 

func (*GetDeviceDetailsResponse) Descriptor() ([]byte, []int)

func (*GetDeviceDetailsResponse) GetAbp 

func (m *GetDeviceDetailsResponse) GetAbp() *ABPDevice

func (*GetDeviceDetailsResponse) GetName 

func (m *GetDeviceDetailsResponse) GetName() string

func (*GetDeviceDetailsResponse) GetOtaa 

func (m *GetDeviceDetailsResponse) GetOtaa() *OTAADevice

func (*GetDeviceDetailsResponse) ProtoMessage 

func (*GetDeviceDetailsResponse) ProtoMessage()

func (*GetDeviceDetailsResponse) Reset 

func (m *GetDeviceDetailsResponse) Reset()

func (*GetDeviceDetailsResponse) String 

func (m *GetDeviceDetailsResponse) String() string

func (*GetDeviceDetailsResponse) XXX_DiscardUnknown 

func (m *GetDeviceDetailsResponse) XXX_DiscardUnknown()

func (*GetDeviceDetailsResponse) XXX_Marshal 

func (m *GetDeviceDetailsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceDetailsResponse) XXX_Merge 

func (m *GetDeviceDetailsResponse) XXX_Merge(src proto.Message)

func (*GetDeviceDetailsResponse) XXX_Size 

func (m *GetDeviceDetailsResponse) XXX_Size() int

func (*GetDeviceDetailsResponse) XXX_Unmarshal 

func (m *GetDeviceDetailsResponse) XXX_Unmarshal(b []byte) error

type GetDeviceKeysRequest 

type GetDeviceKeysRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetDeviceKeysRequest) Descriptor 

func (*GetDeviceKeysRequest) Descriptor() ([]byte, []int)

func (*GetDeviceKeysRequest) GetDevEui 

func (m *GetDeviceKeysRequest) GetDevEui() string

func (*GetDeviceKeysRequest) ProtoMessage 

func (*GetDeviceKeysRequest) ProtoMessage()

func (*GetDeviceKeysRequest) Reset 

func (m *GetDeviceKeysRequest) Reset()

func (*GetDeviceKeysRequest) String 

func (m *GetDeviceKeysRequest) String() string

func (*GetDeviceKeysRequest) XXX_DiscardUnknown 

func (m *GetDeviceKeysRequest) XXX_DiscardUnknown()

func (*GetDeviceKeysRequest) XXX_Marshal 

func (m *GetDeviceKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceKeysRequest) XXX_Merge 

func (m *GetDeviceKeysRequest) XXX_Merge(src proto.Message)

func (*GetDeviceKeysRequest) XXX_Size 

func (m *GetDeviceKeysRequest) XXX_Size() int

func (*GetDeviceKeysRequest) XXX_Unmarshal 

func (m *GetDeviceKeysRequest) XXX_Unmarshal(b []byte) error

type GetDeviceKeysResponse 

type GetDeviceKeysResponse struct {
	// Device-key object.
	DeviceKeys           *DeviceKeys `protobuf:"bytes,1,opt,name=device_keys,json=deviceKeys,proto3" json:"device_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*GetDeviceKeysResponse) Descriptor 

func (*GetDeviceKeysResponse) Descriptor() ([]byte, []int)

func (*GetDeviceKeysResponse) GetDeviceKeys 

func (m *GetDeviceKeysResponse) GetDeviceKeys() *DeviceKeys

func (*GetDeviceKeysResponse) ProtoMessage 

func (*GetDeviceKeysResponse) ProtoMessage()

func (*GetDeviceKeysResponse) Reset 

func (m *GetDeviceKeysResponse) Reset()

func (*GetDeviceKeysResponse) String 

func (m *GetDeviceKeysResponse) String() string

func (*GetDeviceKeysResponse) XXX_DiscardUnknown 

func (m *GetDeviceKeysResponse) XXX_DiscardUnknown()

func (*GetDeviceKeysResponse) XXX_Marshal 

func (m *GetDeviceKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceKeysResponse) XXX_Merge 

func (m *GetDeviceKeysResponse) XXX_Merge(src proto.Message)

func (*GetDeviceKeysResponse) XXX_Size 

func (m *GetDeviceKeysResponse) XXX_Size() int

func (*GetDeviceKeysResponse) XXX_Unmarshal 

func (m *GetDeviceKeysResponse) XXX_Unmarshal(b []byte) error

type GetDeviceProfileRequest 

type GetDeviceProfileRequest struct {
	// Device-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetDeviceProfileRequest) Descriptor 

func (*GetDeviceProfileRequest) Descriptor() ([]byte, []int)

func (*GetDeviceProfileRequest) GetId 

func (m *GetDeviceProfileRequest) GetId() string

func (*GetDeviceProfileRequest) ProtoMessage 

func (*GetDeviceProfileRequest) ProtoMessage()

func (*GetDeviceProfileRequest) Reset 

func (m *GetDeviceProfileRequest) Reset()

func (*GetDeviceProfileRequest) String 

func (m *GetDeviceProfileRequest) String() string

func (*GetDeviceProfileRequest) XXX_DiscardUnknown 

func (m *GetDeviceProfileRequest) XXX_DiscardUnknown()

func (*GetDeviceProfileRequest) XXX_Marshal 

func (m *GetDeviceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceProfileRequest) XXX_Merge 

func (m *GetDeviceProfileRequest) XXX_Merge(src proto.Message)

func (*GetDeviceProfileRequest) XXX_Size 

func (m *GetDeviceProfileRequest) XXX_Size() int

func (*GetDeviceProfileRequest) XXX_Unmarshal 

func (m *GetDeviceProfileRequest) XXX_Unmarshal(b []byte) error

type GetDeviceProfileResponse 

type GetDeviceProfileResponse struct {
	// Device-profile object.
	DeviceProfile *DeviceProfile `protobuf:"bytes,1,opt,name=device_profile,json=deviceProfile,proto3" json:"device_profile,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetDeviceProfileResponse) Descriptor 

func (*GetDeviceProfileResponse) Descriptor() ([]byte, []int)

func (*GetDeviceProfileResponse) GetCreatedAt 

func (m *GetDeviceProfileResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetDeviceProfileResponse) GetDeviceProfile 

func (m *GetDeviceProfileResponse) GetDeviceProfile() *DeviceProfile

func (*GetDeviceProfileResponse) GetUpdatedAt 

func (m *GetDeviceProfileResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetDeviceProfileResponse) ProtoMessage 

func (*GetDeviceProfileResponse) ProtoMessage()

func (*GetDeviceProfileResponse) Reset 

func (m *GetDeviceProfileResponse) Reset()

func (*GetDeviceProfileResponse) String 

func (m *GetDeviceProfileResponse) String() string

func (*GetDeviceProfileResponse) XXX_DiscardUnknown 

func (m *GetDeviceProfileResponse) XXX_DiscardUnknown()

func (*GetDeviceProfileResponse) XXX_Marshal 

func (m *GetDeviceProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceProfileResponse) XXX_Merge 

func (m *GetDeviceProfileResponse) XXX_Merge(src proto.Message)

func (*GetDeviceProfileResponse) XXX_Size 

func (m *GetDeviceProfileResponse) XXX_Size() int

func (*GetDeviceProfileResponse) XXX_Unmarshal 

func (m *GetDeviceProfileResponse) XXX_Unmarshal(b []byte) error

type GetDeviceRequest 

type GetDeviceRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetDeviceRequest) Descriptor 

func (*GetDeviceRequest) Descriptor() ([]byte, []int)

func (*GetDeviceRequest) GetDevEui 

func (m *GetDeviceRequest) GetDevEui() string

func (*GetDeviceRequest) ProtoMessage 

func (*GetDeviceRequest) ProtoMessage()

func (*GetDeviceRequest) Reset 

func (m *GetDeviceRequest) Reset()

func (*GetDeviceRequest) String 

func (m *GetDeviceRequest) String() string

func (*GetDeviceRequest) XXX_DiscardUnknown 

func (m *GetDeviceRequest) XXX_DiscardUnknown()

func (*GetDeviceRequest) XXX_Marshal 

func (m *GetDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceRequest) XXX_Merge 

func (m *GetDeviceRequest) XXX_Merge(src proto.Message)

func (*GetDeviceRequest) XXX_Size 

func (m *GetDeviceRequest) XXX_Size() int

func (*GetDeviceRequest) XXX_Unmarshal 

func (m *GetDeviceRequest) XXX_Unmarshal(b []byte) error

type GetDeviceResponse 

type GetDeviceResponse struct {
	// Device object.
	Device *Device `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	// Created at 2
	// Updated at 3
	// First seen at 4
	// Create timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Last seen timestamp.
	LastSeenAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=last_seen_at,json=lastSeenAt,proto3" json:"last_seen_at,omitempty"`
	// The device battery status
	// 0:      The end-device is connected to an external power source
	// 1..254: The battery level, 1 being at minimum and 254 being at maximum
	// 255:    The end-device was not able to measure the battery level
	// 256:    The device-status is not available.
	DeviceStatusBattery uint32 `protobuf:"varint,6,opt,name=device_status_battery,json=deviceStatusBattery,proto3" json:"device_status_battery,omitempty"`
	// The device margin status
	// -32..32: The demodulation SNR ration in dB
	// 256:     The device-status is not available.
	DeviceStatusMargin int32 `protobuf:"varint,20,opt,name=device_status_margin,json=deviceStatusMargin,proto3" json:"device_status_margin,omitempty"`
	// Device location.
	// This will set when the network-server was able to resolve the location
	// using the geolocation-server.
	Location             *common.Location `protobuf:"bytes,21,opt,name=location,proto3" json:"location,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*GetDeviceResponse) Descriptor 

func (*GetDeviceResponse) Descriptor() ([]byte, []int)

func (*GetDeviceResponse) GetCreatedAt 

func (m *GetDeviceResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetDeviceResponse) GetDevice 

func (m *GetDeviceResponse) GetDevice() *Device

func (*GetDeviceResponse) GetDeviceStatusBattery 

func (m *GetDeviceResponse) GetDeviceStatusBattery() uint32

func (*GetDeviceResponse) GetDeviceStatusMargin 

func (m *GetDeviceResponse) GetDeviceStatusMargin() int32

func (*GetDeviceResponse) GetLastSeenAt 

func (m *GetDeviceResponse) GetLastSeenAt() *timestamppb.Timestamp

func (*GetDeviceResponse) GetLocation 

func (m *GetDeviceResponse) GetLocation() *common.Location

func (*GetDeviceResponse) GetUpdatedAt 

func (m *GetDeviceResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetDeviceResponse) ProtoMessage 

func (*GetDeviceResponse) ProtoMessage()

func (*GetDeviceResponse) Reset 

func (m *GetDeviceResponse) Reset()

func (*GetDeviceResponse) String 

func (m *GetDeviceResponse) String() string

func (*GetDeviceResponse) XXX_DiscardUnknown 

func (m *GetDeviceResponse) XXX_DiscardUnknown()

func (*GetDeviceResponse) XXX_Marshal 

func (m *GetDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDeviceResponse) XXX_Merge 

func (m *GetDeviceResponse) XXX_Merge(src proto.Message)

func (*GetDeviceResponse) XXX_Size 

func (m *GetDeviceResponse) XXX_Size() int

func (*GetDeviceResponse) XXX_Unmarshal 

func (m *GetDeviceResponse) XXX_Unmarshal(b []byte) error

type GetDevicesSummaryRequest 

type GetDevicesSummaryRequest struct {
	// Organization ID.
	OrganizationId       int64    `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetDevicesSummaryRequest) Descriptor 

func (*GetDevicesSummaryRequest) Descriptor() ([]byte, []int)

func (*GetDevicesSummaryRequest) GetOrganizationId 

func (m *GetDevicesSummaryRequest) GetOrganizationId() int64

func (*GetDevicesSummaryRequest) ProtoMessage 

func (*GetDevicesSummaryRequest) ProtoMessage()

func (*GetDevicesSummaryRequest) Reset 

func (m *GetDevicesSummaryRequest) Reset()

func (*GetDevicesSummaryRequest) String 

func (m *GetDevicesSummaryRequest) String() string

func (*GetDevicesSummaryRequest) XXX_DiscardUnknown 

func (m *GetDevicesSummaryRequest) XXX_DiscardUnknown()

func (*GetDevicesSummaryRequest) XXX_Marshal 

func (m *GetDevicesSummaryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDevicesSummaryRequest) XXX_Merge 

func (m *GetDevicesSummaryRequest) XXX_Merge(src proto.Message)

func (*GetDevicesSummaryRequest) XXX_Size 

func (m *GetDevicesSummaryRequest) XXX_Size() int

func (*GetDevicesSummaryRequest) XXX_Unmarshal 

func (m *GetDevicesSummaryRequest) XXX_Unmarshal(b []byte) error

type GetDevicesSummaryResponse 

type GetDevicesSummaryResponse struct {
	// Active count.
	ActiveCount uint32 `protobuf:"varint,1,opt,name=active_count,json=activeCount,proto3" json:"active_count,omitempty"`
	// Inactive count.
	InactiveCount uint32 `protobuf:"varint,2,opt,name=inactive_count,json=inactiveCount,proto3" json:"inactive_count,omitempty"`
	// per data-rate count.
	// Devices that have never been seen are excluded.
	DrCount map[uint32]uint32 `` /* 172-byte string literal not displayed */
	// Never seen count.
	NeverSeenCount       uint32   `protobuf:"varint,4,opt,name=never_seen_count,json=neverSeenCount,proto3" json:"never_seen_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetDevicesSummaryResponse) Descriptor 

func (*GetDevicesSummaryResponse) Descriptor() ([]byte, []int)

func (*GetDevicesSummaryResponse) GetActiveCount 

func (m *GetDevicesSummaryResponse) GetActiveCount() uint32

func (*GetDevicesSummaryResponse) GetDrCount 

func (m *GetDevicesSummaryResponse) GetDrCount() map[uint32]uint32

func (*GetDevicesSummaryResponse) GetInactiveCount 

func (m *GetDevicesSummaryResponse) GetInactiveCount() uint32

func (*GetDevicesSummaryResponse) GetNeverSeenCount 

func (m *GetDevicesSummaryResponse) GetNeverSeenCount() uint32

func (*GetDevicesSummaryResponse) ProtoMessage 

func (*GetDevicesSummaryResponse) ProtoMessage()

func (*GetDevicesSummaryResponse) Reset 

func (m *GetDevicesSummaryResponse) Reset()

func (*GetDevicesSummaryResponse) String 

func (m *GetDevicesSummaryResponse) String() string

func (*GetDevicesSummaryResponse) XXX_DiscardUnknown 

func (m *GetDevicesSummaryResponse) XXX_DiscardUnknown()

func (*GetDevicesSummaryResponse) XXX_Marshal 

func (m *GetDevicesSummaryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetDevicesSummaryResponse) XXX_Merge 

func (m *GetDevicesSummaryResponse) XXX_Merge(src proto.Message)

func (*GetDevicesSummaryResponse) XXX_Size 

func (m *GetDevicesSummaryResponse) XXX_Size() int

func (*GetDevicesSummaryResponse) XXX_Unmarshal 

func (m *GetDevicesSummaryResponse) XXX_Unmarshal(b []byte) error

type GetFUOTADeploymentDeviceRequest 

type GetFUOTADeploymentDeviceRequest struct {
	// ID of the deployment (string formatted UUID).
	// This value will be automatically assigned on create.
	FuotaDeploymentId string `protobuf:"bytes,1,opt,name=fuota_deployment_id,json=fuotaDeploymentID,proto3" json:"fuota_deployment_id,omitempty"`
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,2,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetFUOTADeploymentDeviceRequest) Descriptor 

func (*GetFUOTADeploymentDeviceRequest) Descriptor() ([]byte, []int)

func (*GetFUOTADeploymentDeviceRequest) GetDevEui 

func (m *GetFUOTADeploymentDeviceRequest) GetDevEui() string

func (*GetFUOTADeploymentDeviceRequest) GetFuotaDeploymentId 

func (m *GetFUOTADeploymentDeviceRequest) GetFuotaDeploymentId() string

func (*GetFUOTADeploymentDeviceRequest) ProtoMessage 

func (*GetFUOTADeploymentDeviceRequest) ProtoMessage()

func (*GetFUOTADeploymentDeviceRequest) Reset 

func (m *GetFUOTADeploymentDeviceRequest) Reset()

func (*GetFUOTADeploymentDeviceRequest) String 

func (m *GetFUOTADeploymentDeviceRequest) String() string

func (*GetFUOTADeploymentDeviceRequest) XXX_DiscardUnknown 

func (m *GetFUOTADeploymentDeviceRequest) XXX_DiscardUnknown()

func (*GetFUOTADeploymentDeviceRequest) XXX_Marshal 

func (m *GetFUOTADeploymentDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetFUOTADeploymentDeviceRequest) XXX_Merge 

func (m *GetFUOTADeploymentDeviceRequest) XXX_Merge(src proto.Message)

func (*GetFUOTADeploymentDeviceRequest) XXX_Size 

func (m *GetFUOTADeploymentDeviceRequest) XXX_Size() int

func (*GetFUOTADeploymentDeviceRequest) XXX_Unmarshal 

func (m *GetFUOTADeploymentDeviceRequest) XXX_Unmarshal(b []byte) error

type GetFUOTADeploymentDeviceResponse 

type GetFUOTADeploymentDeviceResponse struct {
	DeploymentDevice     *FUOTADeploymentDeviceListItem `protobuf:"bytes,1,opt,name=deployment_device,json=deploymentDevice,proto3" json:"deployment_device,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

func (*GetFUOTADeploymentDeviceResponse) Descriptor 

func (*GetFUOTADeploymentDeviceResponse) Descriptor() ([]byte, []int)

func (*GetFUOTADeploymentDeviceResponse) GetDeploymentDevice 

func (m *GetFUOTADeploymentDeviceResponse) GetDeploymentDevice() *FUOTADeploymentDeviceListItem

func (*GetFUOTADeploymentDeviceResponse) ProtoMessage 

func (*GetFUOTADeploymentDeviceResponse) ProtoMessage()

func (*GetFUOTADeploymentDeviceResponse) Reset 

func (m *GetFUOTADeploymentDeviceResponse) Reset()

func (*GetFUOTADeploymentDeviceResponse) String 

func (m *GetFUOTADeploymentDeviceResponse) String() string

func (*GetFUOTADeploymentDeviceResponse) XXX_DiscardUnknown 

func (m *GetFUOTADeploymentDeviceResponse) XXX_DiscardUnknown()

func (*GetFUOTADeploymentDeviceResponse) XXX_Marshal 

func (m *GetFUOTADeploymentDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetFUOTADeploymentDeviceResponse) XXX_Merge 

func (m *GetFUOTADeploymentDeviceResponse) XXX_Merge(src proto.Message)

func (*GetFUOTADeploymentDeviceResponse) XXX_Size 

func (m *GetFUOTADeploymentDeviceResponse) XXX_Size() int

func (*GetFUOTADeploymentDeviceResponse) XXX_Unmarshal 

func (m *GetFUOTADeploymentDeviceResponse) XXX_Unmarshal(b []byte) error

type GetFUOTADeploymentRequest 

type GetFUOTADeploymentRequest struct {
	// ID of the deployment (string formatted UUID).
	// This value will be automatically assigned on create.
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetFUOTADeploymentRequest) Descriptor 

func (*GetFUOTADeploymentRequest) Descriptor() ([]byte, []int)

func (*GetFUOTADeploymentRequest) GetId 

func (m *GetFUOTADeploymentRequest) GetId() string

func (*GetFUOTADeploymentRequest) ProtoMessage 

func (*GetFUOTADeploymentRequest) ProtoMessage()

func (*GetFUOTADeploymentRequest) Reset 

func (m *GetFUOTADeploymentRequest) Reset()

func (*GetFUOTADeploymentRequest) String 

func (m *GetFUOTADeploymentRequest) String() string

func (*GetFUOTADeploymentRequest) XXX_DiscardUnknown 

func (m *GetFUOTADeploymentRequest) XXX_DiscardUnknown()

func (*GetFUOTADeploymentRequest) XXX_Marshal 

func (m *GetFUOTADeploymentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetFUOTADeploymentRequest) XXX_Merge 

func (m *GetFUOTADeploymentRequest) XXX_Merge(src proto.Message)

func (*GetFUOTADeploymentRequest) XXX_Size 

func (m *GetFUOTADeploymentRequest) XXX_Size() int

func (*GetFUOTADeploymentRequest) XXX_Unmarshal 

func (m *GetFUOTADeploymentRequest) XXX_Unmarshal(b []byte) error

type GetFUOTADeploymentResponse 

type GetFUOTADeploymentResponse struct {
	FuotaDeployment *FUOTADeployment `protobuf:"bytes,1,opt,name=fuota_deployment,json=fuotaDeployment,proto3" json:"fuota_deployment,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetFUOTADeploymentResponse) Descriptor 

func (*GetFUOTADeploymentResponse) Descriptor() ([]byte, []int)

func (*GetFUOTADeploymentResponse) GetCreatedAt 

func (m *GetFUOTADeploymentResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetFUOTADeploymentResponse) GetFuotaDeployment 

func (m *GetFUOTADeploymentResponse) GetFuotaDeployment() *FUOTADeployment

func (*GetFUOTADeploymentResponse) GetUpdatedAt 

func (m *GetFUOTADeploymentResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetFUOTADeploymentResponse) ProtoMessage 

func (*GetFUOTADeploymentResponse) ProtoMessage()

func (*GetFUOTADeploymentResponse) Reset 

func (m *GetFUOTADeploymentResponse) Reset()

func (*GetFUOTADeploymentResponse) String 

func (m *GetFUOTADeploymentResponse) String() string

func (*GetFUOTADeploymentResponse) XXX_DiscardUnknown 

func (m *GetFUOTADeploymentResponse) XXX_DiscardUnknown()

func (*GetFUOTADeploymentResponse) XXX_Marshal 

func (m *GetFUOTADeploymentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetFUOTADeploymentResponse) XXX_Merge 

func (m *GetFUOTADeploymentResponse) XXX_Merge(src proto.Message)

func (*GetFUOTADeploymentResponse) XXX_Size 

func (m *GetFUOTADeploymentResponse) XXX_Size() int

func (*GetFUOTADeploymentResponse) XXX_Unmarshal 

func (m *GetFUOTADeploymentResponse) XXX_Unmarshal(b []byte) error

type GetGCPPubSubIntegrationRequest 

type GetGCPPubSubIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetGCPPubSubIntegrationRequest) Descriptor 

func (*GetGCPPubSubIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetGCPPubSubIntegrationRequest) GetApplicationId 

func (m *GetGCPPubSubIntegrationRequest) GetApplicationId() int64

func (*GetGCPPubSubIntegrationRequest) ProtoMessage 

func (*GetGCPPubSubIntegrationRequest) ProtoMessage()

func (*GetGCPPubSubIntegrationRequest) Reset 

func (m *GetGCPPubSubIntegrationRequest) Reset()

func (*GetGCPPubSubIntegrationRequest) String 

func (m *GetGCPPubSubIntegrationRequest) String() string

func (*GetGCPPubSubIntegrationRequest) XXX_DiscardUnknown 

func (m *GetGCPPubSubIntegrationRequest) XXX_DiscardUnknown()

func (*GetGCPPubSubIntegrationRequest) XXX_Marshal 

func (m *GetGCPPubSubIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGCPPubSubIntegrationRequest) XXX_Merge 

func (m *GetGCPPubSubIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetGCPPubSubIntegrationRequest) XXX_Size 

func (m *GetGCPPubSubIntegrationRequest) XXX_Size() int

func (*GetGCPPubSubIntegrationRequest) XXX_Unmarshal 

func (m *GetGCPPubSubIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetGCPPubSubIntegrationResponse 

type GetGCPPubSubIntegrationResponse struct {
	// Integration object.
	Integration          *GCPPubSubIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*GetGCPPubSubIntegrationResponse) Descriptor 

func (*GetGCPPubSubIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetGCPPubSubIntegrationResponse) GetIntegration 

func (m *GetGCPPubSubIntegrationResponse) GetIntegration() *GCPPubSubIntegration

func (*GetGCPPubSubIntegrationResponse) ProtoMessage 

func (*GetGCPPubSubIntegrationResponse) ProtoMessage()

func (*GetGCPPubSubIntegrationResponse) Reset 

func (m *GetGCPPubSubIntegrationResponse) Reset()

func (*GetGCPPubSubIntegrationResponse) String 

func (m *GetGCPPubSubIntegrationResponse) String() string

func (*GetGCPPubSubIntegrationResponse) XXX_DiscardUnknown 

func (m *GetGCPPubSubIntegrationResponse) XXX_DiscardUnknown()

func (*GetGCPPubSubIntegrationResponse) XXX_Marshal 

func (m *GetGCPPubSubIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGCPPubSubIntegrationResponse) XXX_Merge 

func (m *GetGCPPubSubIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetGCPPubSubIntegrationResponse) XXX_Size 

func (m *GetGCPPubSubIntegrationResponse) XXX_Size() int

func (*GetGCPPubSubIntegrationResponse) XXX_Unmarshal 

func (m *GetGCPPubSubIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetGateWayModeRegionResponse 

type GetGateWayModeRegionResponse struct {
	Mode                 *GateWayMode   `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`
	Region               *GateWayRegion `protobuf:"bytes,2,opt,name=region,proto3" json:"region,omitempty"`
	Filter               *Filter        `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*GetGateWayModeRegionResponse) Descriptor 

func (*GetGateWayModeRegionResponse) Descriptor() ([]byte, []int)

func (*GetGateWayModeRegionResponse) GetFilter 

func (m *GetGateWayModeRegionResponse) GetFilter() *Filter

func (*GetGateWayModeRegionResponse) GetMode 

func (m *GetGateWayModeRegionResponse) GetMode() *GateWayMode

func (*GetGateWayModeRegionResponse) GetRegion 

func (m *GetGateWayModeRegionResponse) GetRegion() *GateWayRegion

func (*GetGateWayModeRegionResponse) ProtoMessage 

func (*GetGateWayModeRegionResponse) ProtoMessage()

func (*GetGateWayModeRegionResponse) Reset 

func (m *GetGateWayModeRegionResponse) Reset()

func (*GetGateWayModeRegionResponse) String 

func (m *GetGateWayModeRegionResponse) String() string

func (*GetGateWayModeRegionResponse) XXX_DiscardUnknown 

func (m *GetGateWayModeRegionResponse) XXX_DiscardUnknown()

func (*GetGateWayModeRegionResponse) XXX_Marshal 

func (m *GetGateWayModeRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGateWayModeRegionResponse) XXX_Merge 

func (m *GetGateWayModeRegionResponse) XXX_Merge(src proto.Message)

func (*GetGateWayModeRegionResponse) XXX_Size 

func (m *GetGateWayModeRegionResponse) XXX_Size() int

func (*GetGateWayModeRegionResponse) XXX_Unmarshal 

func (m *GetGateWayModeRegionResponse) XXX_Unmarshal(b []byte) error

type GetGatewayProfileRequest 

type GetGatewayProfileRequest struct {
	// Gateway-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetGatewayProfileRequest) Descriptor 

func (*GetGatewayProfileRequest) Descriptor() ([]byte, []int)

func (*GetGatewayProfileRequest) GetId 

func (m *GetGatewayProfileRequest) GetId() string

func (*GetGatewayProfileRequest) ProtoMessage 

func (*GetGatewayProfileRequest) ProtoMessage()

func (*GetGatewayProfileRequest) Reset 

func (m *GetGatewayProfileRequest) Reset()

func (*GetGatewayProfileRequest) String 

func (m *GetGatewayProfileRequest) String() string

func (*GetGatewayProfileRequest) XXX_DiscardUnknown 

func (m *GetGatewayProfileRequest) XXX_DiscardUnknown()

func (*GetGatewayProfileRequest) XXX_Marshal 

func (m *GetGatewayProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewayProfileRequest) XXX_Merge 

func (m *GetGatewayProfileRequest) XXX_Merge(src proto.Message)

func (*GetGatewayProfileRequest) XXX_Size 

func (m *GetGatewayProfileRequest) XXX_Size() int

func (*GetGatewayProfileRequest) XXX_Unmarshal 

func (m *GetGatewayProfileRequest) XXX_Unmarshal(b []byte) error

type GetGatewayProfileResponse 

type GetGatewayProfileResponse struct {
	// Gateway-profile object.
	GatewayProfile *GatewayProfile `protobuf:"bytes,1,opt,name=gateway_profile,json=gatewayProfile,proto3" json:"gateway_profile,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetGatewayProfileResponse) Descriptor 

func (*GetGatewayProfileResponse) Descriptor() ([]byte, []int)

func (*GetGatewayProfileResponse) GetCreatedAt 

func (m *GetGatewayProfileResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetGatewayProfileResponse) GetGatewayProfile 

func (m *GetGatewayProfileResponse) GetGatewayProfile() *GatewayProfile

func (*GetGatewayProfileResponse) GetUpdatedAt 

func (m *GetGatewayProfileResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetGatewayProfileResponse) ProtoMessage 

func (*GetGatewayProfileResponse) ProtoMessage()

func (*GetGatewayProfileResponse) Reset 

func (m *GetGatewayProfileResponse) Reset()

func (*GetGatewayProfileResponse) String 

func (m *GetGatewayProfileResponse) String() string

func (*GetGatewayProfileResponse) XXX_DiscardUnknown 

func (m *GetGatewayProfileResponse) XXX_DiscardUnknown()

func (*GetGatewayProfileResponse) XXX_Marshal 

func (m *GetGatewayProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewayProfileResponse) XXX_Merge 

func (m *GetGatewayProfileResponse) XXX_Merge(src proto.Message)

func (*GetGatewayProfileResponse) XXX_Size 

func (m *GetGatewayProfileResponse) XXX_Size() int

func (*GetGatewayProfileResponse) XXX_Unmarshal 

func (m *GetGatewayProfileResponse) XXX_Unmarshal(b []byte) error

type GetGatewayRequest 

type GetGatewayRequest struct {
	// Gateway ID (HEX encoded).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetGatewayRequest) Descriptor 

func (*GetGatewayRequest) Descriptor() ([]byte, []int)

func (*GetGatewayRequest) GetId 

func (m *GetGatewayRequest) GetId() string

func (*GetGatewayRequest) ProtoMessage 

func (*GetGatewayRequest) ProtoMessage()

func (*GetGatewayRequest) Reset 

func (m *GetGatewayRequest) Reset()

func (*GetGatewayRequest) String 

func (m *GetGatewayRequest) String() string

func (*GetGatewayRequest) XXX_DiscardUnknown 

func (m *GetGatewayRequest) XXX_DiscardUnknown()

func (*GetGatewayRequest) XXX_Marshal 

func (m *GetGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewayRequest) XXX_Merge 

func (m *GetGatewayRequest) XXX_Merge(src proto.Message)

func (*GetGatewayRequest) XXX_Size 

func (m *GetGatewayRequest) XXX_Size() int

func (*GetGatewayRequest) XXX_Unmarshal 

func (m *GetGatewayRequest) XXX_Unmarshal(b []byte) error

type GetGatewayResponse 

type GetGatewayResponse struct {
	// Gateway object.
	Gateway *Gateway `protobuf:"bytes,1,opt,name=gateway,proto3" json:"gateway,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// First seen at timestamp.
	FirstSeenAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=first_seen_at,json=firstSeenAt,proto3" json:"first_seen_at,omitempty"`
	// Last seen at timestamp.
	LastSeenAt           *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=last_seen_at,json=lastSeenAt,proto3" json:"last_seen_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetGatewayResponse) Descriptor 

func (*GetGatewayResponse) Descriptor() ([]byte, []int)

func (*GetGatewayResponse) GetCreatedAt 

func (m *GetGatewayResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetGatewayResponse) GetFirstSeenAt 

func (m *GetGatewayResponse) GetFirstSeenAt() *timestamppb.Timestamp

func (*GetGatewayResponse) GetGateway 

func (m *GetGatewayResponse) GetGateway() *Gateway

func (*GetGatewayResponse) GetLastSeenAt 

func (m *GetGatewayResponse) GetLastSeenAt() *timestamppb.Timestamp

func (*GetGatewayResponse) GetUpdatedAt 

func (m *GetGatewayResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetGatewayResponse) ProtoMessage 

func (*GetGatewayResponse) ProtoMessage()

func (*GetGatewayResponse) Reset 

func (m *GetGatewayResponse) Reset()

func (*GetGatewayResponse) String 

func (m *GetGatewayResponse) String() string

func (*GetGatewayResponse) XXX_DiscardUnknown 

func (m *GetGatewayResponse) XXX_DiscardUnknown()

func (*GetGatewayResponse) XXX_Marshal 

func (m *GetGatewayResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewayResponse) XXX_Merge 

func (m *GetGatewayResponse) XXX_Merge(src proto.Message)

func (*GetGatewayResponse) XXX_Size 

func (m *GetGatewayResponse) XXX_Size() int

func (*GetGatewayResponse) XXX_Unmarshal 

func (m *GetGatewayResponse) XXX_Unmarshal(b []byte) error

type GetGatewayStatsRequest 

type GetGatewayStatsRequest struct {
	// Gateway ID (HEX encoded).
	GatewayId string `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayID,proto3" json:"gateway_id,omitempty"`
	// Aggregation interval.  One of "second", "minute", "hour", "day", "week",
	// "month", "quarter", "year".  Case insensitive.
	Interval string `protobuf:"bytes,2,opt,name=interval,proto3" json:"interval,omitempty"`
	// Timestamp to start from.
	StartTimestamp *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"`
	// Timestamp until to get from.
	EndTimestamp         *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetGatewayStatsRequest) Descriptor 

func (*GetGatewayStatsRequest) Descriptor() ([]byte, []int)

func (*GetGatewayStatsRequest) GetEndTimestamp 

func (m *GetGatewayStatsRequest) GetEndTimestamp() *timestamppb.Timestamp

func (*GetGatewayStatsRequest) GetGatewayId 

func (m *GetGatewayStatsRequest) GetGatewayId() string

func (*GetGatewayStatsRequest) GetInterval 

func (m *GetGatewayStatsRequest) GetInterval() string

func (*GetGatewayStatsRequest) GetStartTimestamp 

func (m *GetGatewayStatsRequest) GetStartTimestamp() *timestamppb.Timestamp

func (*GetGatewayStatsRequest) ProtoMessage 

func (*GetGatewayStatsRequest) ProtoMessage()

func (*GetGatewayStatsRequest) Reset 

func (m *GetGatewayStatsRequest) Reset()

func (*GetGatewayStatsRequest) String 

func (m *GetGatewayStatsRequest) String() string

func (*GetGatewayStatsRequest) XXX_DiscardUnknown 

func (m *GetGatewayStatsRequest) XXX_DiscardUnknown()

func (*GetGatewayStatsRequest) XXX_Marshal 

func (m *GetGatewayStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewayStatsRequest) XXX_Merge 

func (m *GetGatewayStatsRequest) XXX_Merge(src proto.Message)

func (*GetGatewayStatsRequest) XXX_Size 

func (m *GetGatewayStatsRequest) XXX_Size() int

func (*GetGatewayStatsRequest) XXX_Unmarshal 

func (m *GetGatewayStatsRequest) XXX_Unmarshal(b []byte) error

type GetGatewayStatsResponse 

type GetGatewayStatsResponse struct {
	Result               []*GatewayStats `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*GetGatewayStatsResponse) Descriptor 

func (*GetGatewayStatsResponse) Descriptor() ([]byte, []int)

func (*GetGatewayStatsResponse) GetResult 

func (m *GetGatewayStatsResponse) GetResult() []*GatewayStats

func (*GetGatewayStatsResponse) ProtoMessage 

func (*GetGatewayStatsResponse) ProtoMessage()

func (*GetGatewayStatsResponse) Reset 

func (m *GetGatewayStatsResponse) Reset()

func (*GetGatewayStatsResponse) String 

func (m *GetGatewayStatsResponse) String() string

func (*GetGatewayStatsResponse) XXX_DiscardUnknown 

func (m *GetGatewayStatsResponse) XXX_DiscardUnknown()

func (*GetGatewayStatsResponse) XXX_Marshal 

func (m *GetGatewayStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewayStatsResponse) XXX_Merge 

func (m *GetGatewayStatsResponse) XXX_Merge(src proto.Message)

func (*GetGatewayStatsResponse) XXX_Size 

func (m *GetGatewayStatsResponse) XXX_Size() int

func (*GetGatewayStatsResponse) XXX_Unmarshal 

func (m *GetGatewayStatsResponse) XXX_Unmarshal(b []byte) error

type GetGatewaysSummaryRequest 

type GetGatewaysSummaryRequest struct {
	// Organization ID.
	OrganizationId       int64    `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetGatewaysSummaryRequest) Descriptor 

func (*GetGatewaysSummaryRequest) Descriptor() ([]byte, []int)

func (*GetGatewaysSummaryRequest) GetOrganizationId 

func (m *GetGatewaysSummaryRequest) GetOrganizationId() int64

func (*GetGatewaysSummaryRequest) ProtoMessage 

func (*GetGatewaysSummaryRequest) ProtoMessage()

func (*GetGatewaysSummaryRequest) Reset 

func (m *GetGatewaysSummaryRequest) Reset()

func (*GetGatewaysSummaryRequest) String 

func (m *GetGatewaysSummaryRequest) String() string

func (*GetGatewaysSummaryRequest) XXX_DiscardUnknown 

func (m *GetGatewaysSummaryRequest) XXX_DiscardUnknown()

func (*GetGatewaysSummaryRequest) XXX_Marshal 

func (m *GetGatewaysSummaryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewaysSummaryRequest) XXX_Merge 

func (m *GetGatewaysSummaryRequest) XXX_Merge(src proto.Message)

func (*GetGatewaysSummaryRequest) XXX_Size 

func (m *GetGatewaysSummaryRequest) XXX_Size() int

func (*GetGatewaysSummaryRequest) XXX_Unmarshal 

func (m *GetGatewaysSummaryRequest) XXX_Unmarshal(b []byte) error

type GetGatewaysSummaryResponse 

type GetGatewaysSummaryResponse struct {
	// Active count.
	ActiveCount uint32 `protobuf:"varint,1,opt,name=active_count,json=activeCount,proto3" json:"active_count,omitempty"`
	// Inactive count.
	InactiveCount uint32 `protobuf:"varint,2,opt,name=inactive_count,json=inactiveCount,proto3" json:"inactive_count,omitempty"`
	// Never seen count.
	NeverSeenCount       uint32   `protobuf:"varint,3,opt,name=never_seen_count,json=neverSeenCount,proto3" json:"never_seen_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetGatewaysSummaryResponse) Descriptor 

func (*GetGatewaysSummaryResponse) Descriptor() ([]byte, []int)

func (*GetGatewaysSummaryResponse) GetActiveCount 

func (m *GetGatewaysSummaryResponse) GetActiveCount() uint32

func (*GetGatewaysSummaryResponse) GetInactiveCount 

func (m *GetGatewaysSummaryResponse) GetInactiveCount() uint32

func (*GetGatewaysSummaryResponse) GetNeverSeenCount 

func (m *GetGatewaysSummaryResponse) GetNeverSeenCount() uint32

func (*GetGatewaysSummaryResponse) ProtoMessage 

func (*GetGatewaysSummaryResponse) ProtoMessage()

func (*GetGatewaysSummaryResponse) Reset 

func (m *GetGatewaysSummaryResponse) Reset()

func (*GetGatewaysSummaryResponse) String 

func (m *GetGatewaysSummaryResponse) String() string

func (*GetGatewaysSummaryResponse) XXX_DiscardUnknown 

func (m *GetGatewaysSummaryResponse) XXX_DiscardUnknown()

func (*GetGatewaysSummaryResponse) XXX_Marshal 

func (m *GetGatewaysSummaryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetGatewaysSummaryResponse) XXX_Merge 

func (m *GetGatewaysSummaryResponse) XXX_Merge(src proto.Message)

func (*GetGatewaysSummaryResponse) XXX_Size 

func (m *GetGatewaysSummaryResponse) XXX_Size() int

func (*GetGatewaysSummaryResponse) XXX_Unmarshal 

func (m *GetGatewaysSummaryResponse) XXX_Unmarshal(b []byte) error

type GetHTTPIntegrationRequest 

type GetHTTPIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetHTTPIntegrationRequest) Descriptor 

func (*GetHTTPIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetHTTPIntegrationRequest) GetApplicationId 

func (m *GetHTTPIntegrationRequest) GetApplicationId() int64

func (*GetHTTPIntegrationRequest) ProtoMessage 

func (*GetHTTPIntegrationRequest) ProtoMessage()

func (*GetHTTPIntegrationRequest) Reset 

func (m *GetHTTPIntegrationRequest) Reset()

func (*GetHTTPIntegrationRequest) String 

func (m *GetHTTPIntegrationRequest) String() string

func (*GetHTTPIntegrationRequest) XXX_DiscardUnknown 

func (m *GetHTTPIntegrationRequest) XXX_DiscardUnknown()

func (*GetHTTPIntegrationRequest) XXX_Marshal 

func (m *GetHTTPIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetHTTPIntegrationRequest) XXX_Merge 

func (m *GetHTTPIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetHTTPIntegrationRequest) XXX_Size 

func (m *GetHTTPIntegrationRequest) XXX_Size() int

func (*GetHTTPIntegrationRequest) XXX_Unmarshal 

func (m *GetHTTPIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetHTTPIntegrationResponse 

type GetHTTPIntegrationResponse struct {
	// Integration object.
	Integration          *HTTPIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*GetHTTPIntegrationResponse) Descriptor 

func (*GetHTTPIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetHTTPIntegrationResponse) GetIntegration 

func (m *GetHTTPIntegrationResponse) GetIntegration() *HTTPIntegration

func (*GetHTTPIntegrationResponse) ProtoMessage 

func (*GetHTTPIntegrationResponse) ProtoMessage()

func (*GetHTTPIntegrationResponse) Reset 

func (m *GetHTTPIntegrationResponse) Reset()

func (*GetHTTPIntegrationResponse) String 

func (m *GetHTTPIntegrationResponse) String() string

func (*GetHTTPIntegrationResponse) XXX_DiscardUnknown 

func (m *GetHTTPIntegrationResponse) XXX_DiscardUnknown()

func (*GetHTTPIntegrationResponse) XXX_Marshal 

func (m *GetHTTPIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetHTTPIntegrationResponse) XXX_Merge 

func (m *GetHTTPIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetHTTPIntegrationResponse) XXX_Size 

func (m *GetHTTPIntegrationResponse) XXX_Size() int

func (*GetHTTPIntegrationResponse) XXX_Unmarshal 

func (m *GetHTTPIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetInfluxDBIntegrationRequest 

type GetInfluxDBIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetInfluxDBIntegrationRequest) Descriptor 

func (*GetInfluxDBIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetInfluxDBIntegrationRequest) GetApplicationId 

func (m *GetInfluxDBIntegrationRequest) GetApplicationId() int64

func (*GetInfluxDBIntegrationRequest) ProtoMessage 

func (*GetInfluxDBIntegrationRequest) ProtoMessage()

func (*GetInfluxDBIntegrationRequest) Reset 

func (m *GetInfluxDBIntegrationRequest) Reset()

func (*GetInfluxDBIntegrationRequest) String 

func (m *GetInfluxDBIntegrationRequest) String() string

func (*GetInfluxDBIntegrationRequest) XXX_DiscardUnknown 

func (m *GetInfluxDBIntegrationRequest) XXX_DiscardUnknown()

func (*GetInfluxDBIntegrationRequest) XXX_Marshal 

func (m *GetInfluxDBIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetInfluxDBIntegrationRequest) XXX_Merge 

func (m *GetInfluxDBIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetInfluxDBIntegrationRequest) XXX_Size 

func (m *GetInfluxDBIntegrationRequest) XXX_Size() int

func (*GetInfluxDBIntegrationRequest) XXX_Unmarshal 

func (m *GetInfluxDBIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetInfluxDBIntegrationResponse 

type GetInfluxDBIntegrationResponse struct {
	// Integration object.
	Integration          *InfluxDBIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*GetInfluxDBIntegrationResponse) Descriptor 

func (*GetInfluxDBIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetInfluxDBIntegrationResponse) GetIntegration 

func (m *GetInfluxDBIntegrationResponse) GetIntegration() *InfluxDBIntegration

func (*GetInfluxDBIntegrationResponse) ProtoMessage 

func (*GetInfluxDBIntegrationResponse) ProtoMessage()

func (*GetInfluxDBIntegrationResponse) Reset 

func (m *GetInfluxDBIntegrationResponse) Reset()

func (*GetInfluxDBIntegrationResponse) String 

func (m *GetInfluxDBIntegrationResponse) String() string

func (*GetInfluxDBIntegrationResponse) XXX_DiscardUnknown 

func (m *GetInfluxDBIntegrationResponse) XXX_DiscardUnknown()

func (*GetInfluxDBIntegrationResponse) XXX_Marshal 

func (m *GetInfluxDBIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetInfluxDBIntegrationResponse) XXX_Merge 

func (m *GetInfluxDBIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetInfluxDBIntegrationResponse) XXX_Size 

func (m *GetInfluxDBIntegrationResponse) XXX_Size() int

func (*GetInfluxDBIntegrationResponse) XXX_Unmarshal 

func (m *GetInfluxDBIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetLastPingRequest 

type GetLastPingRequest struct {
	// Gateway ID (HEX encoded).
	GatewayId            string   `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayID,proto3" json:"gateway_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetLastPingRequest) Descriptor 

func (*GetLastPingRequest) Descriptor() ([]byte, []int)

func (*GetLastPingRequest) GetGatewayId 

func (m *GetLastPingRequest) GetGatewayId() string

func (*GetLastPingRequest) ProtoMessage 

func (*GetLastPingRequest) ProtoMessage()

func (*GetLastPingRequest) Reset 

func (m *GetLastPingRequest) Reset()

func (*GetLastPingRequest) String 

func (m *GetLastPingRequest) String() string

func (*GetLastPingRequest) XXX_DiscardUnknown 

func (m *GetLastPingRequest) XXX_DiscardUnknown()

func (*GetLastPingRequest) XXX_Marshal 

func (m *GetLastPingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetLastPingRequest) XXX_Merge 

func (m *GetLastPingRequest) XXX_Merge(src proto.Message)

func (*GetLastPingRequest) XXX_Size 

func (m *GetLastPingRequest) XXX_Size() int

func (*GetLastPingRequest) XXX_Unmarshal 

func (m *GetLastPingRequest) XXX_Unmarshal(b []byte) error

type GetLastPingResponse 

type GetLastPingResponse struct {
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Frequency (Hz).
	Frequency uint32 `protobuf:"varint,2,opt,name=frequency,proto3" json:"frequency,omitempty"`
	// Data-rate.
	Dr uint32 `protobuf:"varint,3,opt,name=dr,proto3" json:"dr,omitempty"`
	// Gateways and meta-data of reception.
	PingRx               []*PingRX `protobuf:"bytes,4,rep,name=ping_rx,json=pingRX,proto3" json:"ping_rx,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (*GetLastPingResponse) Descriptor 

func (*GetLastPingResponse) Descriptor() ([]byte, []int)

func (*GetLastPingResponse) GetCreatedAt 

func (m *GetLastPingResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetLastPingResponse) GetDr 

func (m *GetLastPingResponse) GetDr() uint32

func (*GetLastPingResponse) GetFrequency 

func (m *GetLastPingResponse) GetFrequency() uint32

func (*GetLastPingResponse) GetPingRx 

func (m *GetLastPingResponse) GetPingRx() []*PingRX

func (*GetLastPingResponse) ProtoMessage 

func (*GetLastPingResponse) ProtoMessage()

func (*GetLastPingResponse) Reset 

func (m *GetLastPingResponse) Reset()

func (*GetLastPingResponse) String 

func (m *GetLastPingResponse) String() string

func (*GetLastPingResponse) XXX_DiscardUnknown 

func (m *GetLastPingResponse) XXX_DiscardUnknown()

func (*GetLastPingResponse) XXX_Marshal 

func (m *GetLastPingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetLastPingResponse) XXX_Merge 

func (m *GetLastPingResponse) XXX_Merge(src proto.Message)

func (*GetLastPingResponse) XXX_Size 

func (m *GetLastPingResponse) XXX_Size() int

func (*GetLastPingResponse) XXX_Unmarshal 

func (m *GetLastPingResponse) XXX_Unmarshal(b []byte) error

type GetLoRaCloudIntegrationRequest 

type GetLoRaCloudIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetLoRaCloudIntegrationRequest) Descriptor 

func (*GetLoRaCloudIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetLoRaCloudIntegrationRequest) GetApplicationId 

func (m *GetLoRaCloudIntegrationRequest) GetApplicationId() int64

func (*GetLoRaCloudIntegrationRequest) ProtoMessage 

func (*GetLoRaCloudIntegrationRequest) ProtoMessage()

func (*GetLoRaCloudIntegrationRequest) Reset 

func (m *GetLoRaCloudIntegrationRequest) Reset()

func (*GetLoRaCloudIntegrationRequest) String 

func (m *GetLoRaCloudIntegrationRequest) String() string

func (*GetLoRaCloudIntegrationRequest) XXX_DiscardUnknown 

func (m *GetLoRaCloudIntegrationRequest) XXX_DiscardUnknown()

func (*GetLoRaCloudIntegrationRequest) XXX_Marshal 

func (m *GetLoRaCloudIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetLoRaCloudIntegrationRequest) XXX_Merge 

func (m *GetLoRaCloudIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetLoRaCloudIntegrationRequest) XXX_Size 

func (m *GetLoRaCloudIntegrationRequest) XXX_Size() int

func (*GetLoRaCloudIntegrationRequest) XXX_Unmarshal 

func (m *GetLoRaCloudIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetLoRaCloudIntegrationResponse 

type GetLoRaCloudIntegrationResponse struct {
	// Integration object.
	Integration          *LoRaCloudIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*GetLoRaCloudIntegrationResponse) Descriptor 

func (*GetLoRaCloudIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetLoRaCloudIntegrationResponse) GetIntegration 

func (m *GetLoRaCloudIntegrationResponse) GetIntegration() *LoRaCloudIntegration

func (*GetLoRaCloudIntegrationResponse) ProtoMessage 

func (*GetLoRaCloudIntegrationResponse) ProtoMessage()

func (*GetLoRaCloudIntegrationResponse) Reset 

func (m *GetLoRaCloudIntegrationResponse) Reset()

func (*GetLoRaCloudIntegrationResponse) String 

func (m *GetLoRaCloudIntegrationResponse) String() string

func (*GetLoRaCloudIntegrationResponse) XXX_DiscardUnknown 

func (m *GetLoRaCloudIntegrationResponse) XXX_DiscardUnknown()

func (*GetLoRaCloudIntegrationResponse) XXX_Marshal 

func (m *GetLoRaCloudIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetLoRaCloudIntegrationResponse) XXX_Merge 

func (m *GetLoRaCloudIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetLoRaCloudIntegrationResponse) XXX_Size 

func (m *GetLoRaCloudIntegrationResponse) XXX_Size() int

func (*GetLoRaCloudIntegrationResponse) XXX_Unmarshal 

func (m *GetLoRaCloudIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetLorawanRxResponse 

type GetLorawanRxResponse struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetLorawanRxResponse) Descriptor 

func (*GetLorawanRxResponse) Descriptor() ([]byte, []int)

func (*GetLorawanRxResponse) GetFreq 

func (m *GetLorawanRxResponse) GetFreq() int64

func (*GetLorawanRxResponse) ProtoMessage 

func (*GetLorawanRxResponse) ProtoMessage()

func (*GetLorawanRxResponse) Reset 

func (m *GetLorawanRxResponse) Reset()

func (*GetLorawanRxResponse) String 

func (m *GetLorawanRxResponse) String() string

func (*GetLorawanRxResponse) XXX_DiscardUnknown 

func (m *GetLorawanRxResponse) XXX_DiscardUnknown()

func (*GetLorawanRxResponse) XXX_Marshal 

func (m *GetLorawanRxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetLorawanRxResponse) XXX_Merge 

func (m *GetLorawanRxResponse) XXX_Merge(src proto.Message)

func (*GetLorawanRxResponse) XXX_Size 

func (m *GetLorawanRxResponse) XXX_Size() int

func (*GetLorawanRxResponse) XXX_Unmarshal 

func (m *GetLorawanRxResponse) XXX_Unmarshal(b []byte) error

type GetLorawanTxResponse 

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

func (*GetLorawanTxResponse) Descriptor 

func (*GetLorawanTxResponse) Descriptor() ([]byte, []int)

func (*GetLorawanTxResponse) GetConfig 

func (m *GetLorawanTxResponse) GetConfig() *LorawanTX

func (*GetLorawanTxResponse) ProtoMessage 

func (*GetLorawanTxResponse) ProtoMessage()

func (*GetLorawanTxResponse) Reset 

func (m *GetLorawanTxResponse) Reset()

func (*GetLorawanTxResponse) String 

func (m *GetLorawanTxResponse) String() string

func (*GetLorawanTxResponse) XXX_DiscardUnknown 

func (m *GetLorawanTxResponse) XXX_DiscardUnknown()

func (*GetLorawanTxResponse) XXX_Marshal 

func (m *GetLorawanTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetLorawanTxResponse) XXX_Merge 

func (m *GetLorawanTxResponse) XXX_Merge(src proto.Message)

func (*GetLorawanTxResponse) XXX_Size 

func (m *GetLorawanTxResponse) XXX_Size() int

func (*GetLorawanTxResponse) XXX_Unmarshal 

func (m *GetLorawanTxResponse) XXX_Unmarshal(b []byte) error

type GetMulticastGroupRequest 

type GetMulticastGroupRequest struct {
	// ID (string formatted UUID).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetMulticastGroupRequest) Descriptor 

func (*GetMulticastGroupRequest) Descriptor() ([]byte, []int)

func (*GetMulticastGroupRequest) GetId 

func (m *GetMulticastGroupRequest) GetId() string

func (*GetMulticastGroupRequest) ProtoMessage 

func (*GetMulticastGroupRequest) ProtoMessage()

func (*GetMulticastGroupRequest) Reset 

func (m *GetMulticastGroupRequest) Reset()

func (*GetMulticastGroupRequest) String 

func (m *GetMulticastGroupRequest) String() string

func (*GetMulticastGroupRequest) XXX_DiscardUnknown 

func (m *GetMulticastGroupRequest) XXX_DiscardUnknown()

func (*GetMulticastGroupRequest) XXX_Marshal 

func (m *GetMulticastGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetMulticastGroupRequest) XXX_Merge 

func (m *GetMulticastGroupRequest) XXX_Merge(src proto.Message)

func (*GetMulticastGroupRequest) XXX_Size 

func (m *GetMulticastGroupRequest) XXX_Size() int

func (*GetMulticastGroupRequest) XXX_Unmarshal 

func (m *GetMulticastGroupRequest) XXX_Unmarshal(b []byte) error

type GetMulticastGroupResponse 

type GetMulticastGroupResponse struct {
	// Multicast-group object.
	MulticastGroup *MulticastGroup `protobuf:"bytes,1,opt,name=multicast_group,json=multicastGroup,proto3" json:"multicast_group,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetMulticastGroupResponse) Descriptor 

func (*GetMulticastGroupResponse) Descriptor() ([]byte, []int)

func (*GetMulticastGroupResponse) GetCreatedAt 

func (m *GetMulticastGroupResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetMulticastGroupResponse) GetMulticastGroup 

func (m *GetMulticastGroupResponse) GetMulticastGroup() *MulticastGroup

func (*GetMulticastGroupResponse) GetUpdatedAt 

func (m *GetMulticastGroupResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetMulticastGroupResponse) ProtoMessage 

func (*GetMulticastGroupResponse) ProtoMessage()

func (*GetMulticastGroupResponse) Reset 

func (m *GetMulticastGroupResponse) Reset()

func (*GetMulticastGroupResponse) String 

func (m *GetMulticastGroupResponse) String() string

func (*GetMulticastGroupResponse) XXX_DiscardUnknown 

func (m *GetMulticastGroupResponse) XXX_DiscardUnknown()

func (*GetMulticastGroupResponse) XXX_Marshal 

func (m *GetMulticastGroupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetMulticastGroupResponse) XXX_Merge 

func (m *GetMulticastGroupResponse) XXX_Merge(src proto.Message)

func (*GetMulticastGroupResponse) XXX_Size 

func (m *GetMulticastGroupResponse) XXX_Size() int

func (*GetMulticastGroupResponse) XXX_Unmarshal 

func (m *GetMulticastGroupResponse) XXX_Unmarshal(b []byte) error

type GetMyDevicesIntegrationRequest 

type GetMyDevicesIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetMyDevicesIntegrationRequest) Descriptor 

func (*GetMyDevicesIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetMyDevicesIntegrationRequest) GetApplicationId 

func (m *GetMyDevicesIntegrationRequest) GetApplicationId() int64

func (*GetMyDevicesIntegrationRequest) ProtoMessage 

func (*GetMyDevicesIntegrationRequest) ProtoMessage()

func (*GetMyDevicesIntegrationRequest) Reset 

func (m *GetMyDevicesIntegrationRequest) Reset()

func (*GetMyDevicesIntegrationRequest) String 

func (m *GetMyDevicesIntegrationRequest) String() string

func (*GetMyDevicesIntegrationRequest) XXX_DiscardUnknown 

func (m *GetMyDevicesIntegrationRequest) XXX_DiscardUnknown()

func (*GetMyDevicesIntegrationRequest) XXX_Marshal 

func (m *GetMyDevicesIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetMyDevicesIntegrationRequest) XXX_Merge 

func (m *GetMyDevicesIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetMyDevicesIntegrationRequest) XXX_Size 

func (m *GetMyDevicesIntegrationRequest) XXX_Size() int

func (*GetMyDevicesIntegrationRequest) XXX_Unmarshal 

func (m *GetMyDevicesIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetMyDevicesIntegrationResponse 

type GetMyDevicesIntegrationResponse struct {
	// Integration object.
	Integration          *MyDevicesIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*GetMyDevicesIntegrationResponse) Descriptor 

func (*GetMyDevicesIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetMyDevicesIntegrationResponse) GetIntegration 

func (m *GetMyDevicesIntegrationResponse) GetIntegration() *MyDevicesIntegration

func (*GetMyDevicesIntegrationResponse) ProtoMessage 

func (*GetMyDevicesIntegrationResponse) ProtoMessage()

func (*GetMyDevicesIntegrationResponse) Reset 

func (m *GetMyDevicesIntegrationResponse) Reset()

func (*GetMyDevicesIntegrationResponse) String 

func (m *GetMyDevicesIntegrationResponse) String() string

func (*GetMyDevicesIntegrationResponse) XXX_DiscardUnknown 

func (m *GetMyDevicesIntegrationResponse) XXX_DiscardUnknown()

func (*GetMyDevicesIntegrationResponse) XXX_Marshal 

func (m *GetMyDevicesIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetMyDevicesIntegrationResponse) XXX_Merge 

func (m *GetMyDevicesIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetMyDevicesIntegrationResponse) XXX_Size 

func (m *GetMyDevicesIntegrationResponse) XXX_Size() int

func (*GetMyDevicesIntegrationResponse) XXX_Unmarshal 

func (m *GetMyDevicesIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetNTPResponse 

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 (*GetNTPResponse) Descriptor 

func (*GetNTPResponse) Descriptor() ([]byte, []int)

func (*GetNTPResponse) GetNtp 

func (m *GetNTPResponse) GetNtp() *NTPConfig

func (*GetNTPResponse) ProtoMessage 

func (*GetNTPResponse) ProtoMessage()

func (*GetNTPResponse) Reset 

func (m *GetNTPResponse) Reset()

func (*GetNTPResponse) String 

func (m *GetNTPResponse) String() string

func (*GetNTPResponse) XXX_DiscardUnknown 

func (m *GetNTPResponse) XXX_DiscardUnknown()

func (*GetNTPResponse) XXX_Marshal 

func (m *GetNTPResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetNTPResponse) XXX_Merge 

func (m *GetNTPResponse) XXX_Merge(src proto.Message)

func (*GetNTPResponse) XXX_Size 

func (m *GetNTPResponse) XXX_Size() int

func (*GetNTPResponse) XXX_Unmarshal 

func (m *GetNTPResponse) XXX_Unmarshal(b []byte) error

type GetNetworkServerRequest 

type GetNetworkServerRequest struct {
	// Network-server ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetNetworkServerRequest) Descriptor 

func (*GetNetworkServerRequest) Descriptor() ([]byte, []int)

func (*GetNetworkServerRequest) GetId 

func (m *GetNetworkServerRequest) GetId() int64

func (*GetNetworkServerRequest) ProtoMessage 

func (*GetNetworkServerRequest) ProtoMessage()

func (*GetNetworkServerRequest) Reset 

func (m *GetNetworkServerRequest) Reset()

func (*GetNetworkServerRequest) String 

func (m *GetNetworkServerRequest) String() string

func (*GetNetworkServerRequest) XXX_DiscardUnknown 

func (m *GetNetworkServerRequest) XXX_DiscardUnknown()

func (*GetNetworkServerRequest) XXX_Marshal 

func (m *GetNetworkServerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetNetworkServerRequest) XXX_Merge 

func (m *GetNetworkServerRequest) XXX_Merge(src proto.Message)

func (*GetNetworkServerRequest) XXX_Size 

func (m *GetNetworkServerRequest) XXX_Size() int

func (*GetNetworkServerRequest) XXX_Unmarshal 

func (m *GetNetworkServerRequest) XXX_Unmarshal(b []byte) error

type GetNetworkServerResponse 

type GetNetworkServerResponse struct {
	// Network-server object.
	NetworkServer *NetworkServer `protobuf:"bytes,1,opt,name=network_server,json=networkServer,proto3" json:"network_server,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// The ChirpStack Network Server version.
	Version string `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
	// The ChirpStack Network Server region configured.
	Region               string   `protobuf:"bytes,5,opt,name=region,proto3" json:"region,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetNetworkServerResponse) Descriptor 

func (*GetNetworkServerResponse) Descriptor() ([]byte, []int)

func (*GetNetworkServerResponse) GetCreatedAt 

func (m *GetNetworkServerResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetNetworkServerResponse) GetNetworkServer 

func (m *GetNetworkServerResponse) GetNetworkServer() *NetworkServer

func (*GetNetworkServerResponse) GetRegion 

func (m *GetNetworkServerResponse) GetRegion() string

func (*GetNetworkServerResponse) GetUpdatedAt 

func (m *GetNetworkServerResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetNetworkServerResponse) GetVersion 

func (m *GetNetworkServerResponse) GetVersion() string

func (*GetNetworkServerResponse) ProtoMessage 

func (*GetNetworkServerResponse) ProtoMessage()

func (*GetNetworkServerResponse) Reset 

func (m *GetNetworkServerResponse) Reset()

func (*GetNetworkServerResponse) String 

func (m *GetNetworkServerResponse) String() string

func (*GetNetworkServerResponse) XXX_DiscardUnknown 

func (m *GetNetworkServerResponse) XXX_DiscardUnknown()

func (*GetNetworkServerResponse) XXX_Marshal 

func (m *GetNetworkServerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetNetworkServerResponse) XXX_Merge 

func (m *GetNetworkServerResponse) XXX_Merge(src proto.Message)

func (*GetNetworkServerResponse) XXX_Size 

func (m *GetNetworkServerResponse) XXX_Size() int

func (*GetNetworkServerResponse) XXX_Unmarshal 

func (m *GetNetworkServerResponse) XXX_Unmarshal(b []byte) error

type GetNoderedResponse 

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 (*GetNoderedResponse) Descriptor 

func (*GetNoderedResponse) Descriptor() ([]byte, []int)

func (*GetNoderedResponse) GetEnable 

func (m *GetNoderedResponse) GetEnable() bool

func (*GetNoderedResponse) ProtoMessage 

func (*GetNoderedResponse) ProtoMessage()

func (*GetNoderedResponse) Reset 

func (m *GetNoderedResponse) Reset()

func (*GetNoderedResponse) String 

func (m *GetNoderedResponse) String() string

func (*GetNoderedResponse) XXX_DiscardUnknown 

func (m *GetNoderedResponse) XXX_DiscardUnknown()

func (*GetNoderedResponse) XXX_Marshal 

func (m *GetNoderedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetNoderedResponse) XXX_Merge 

func (m *GetNoderedResponse) XXX_Merge(src proto.Message)

func (*GetNoderedResponse) XXX_Size 

func (m *GetNoderedResponse) XXX_Size() int

func (*GetNoderedResponse) XXX_Unmarshal 

func (m *GetNoderedResponse) XXX_Unmarshal(b []byte) error

type GetOTPRequest 

type GetOTPRequest struct {
	Id                   int32    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetOTPRequest) Descriptor 

func (*GetOTPRequest) Descriptor() ([]byte, []int)

func (*GetOTPRequest) GetId 

func (m *GetOTPRequest) GetId() int32

func (*GetOTPRequest) ProtoMessage 

func (*GetOTPRequest) ProtoMessage()

func (*GetOTPRequest) Reset 

func (m *GetOTPRequest) Reset()

func (*GetOTPRequest) String 

func (m *GetOTPRequest) String() string

func (*GetOTPRequest) XXX_DiscardUnknown 

func (m *GetOTPRequest) XXX_DiscardUnknown()

func (*GetOTPRequest) XXX_Marshal 

func (m *GetOTPRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetOTPRequest) XXX_Merge 

func (m *GetOTPRequest) XXX_Merge(src proto.Message)

func (*GetOTPRequest) XXX_Size 

func (m *GetOTPRequest) XXX_Size() int

func (*GetOTPRequest) XXX_Unmarshal 

func (m *GetOTPRequest) XXX_Unmarshal(b []byte) error

type GetOTPResponse 

type GetOTPResponse struct {
	Blocks               *OTPBLOCK `protobuf:"bytes,1,opt,name=blocks,proto3" json:"blocks,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (*GetOTPResponse) Descriptor 

func (*GetOTPResponse) Descriptor() ([]byte, []int)

func (*GetOTPResponse) GetBlocks 

func (m *GetOTPResponse) GetBlocks() *OTPBLOCK

func (*GetOTPResponse) ProtoMessage 

func (*GetOTPResponse) ProtoMessage()

func (*GetOTPResponse) Reset 

func (m *GetOTPResponse) Reset()

func (*GetOTPResponse) String 

func (m *GetOTPResponse) String() string

func (*GetOTPResponse) XXX_DiscardUnknown 

func (m *GetOTPResponse) XXX_DiscardUnknown()

func (*GetOTPResponse) XXX_Marshal 

func (m *GetOTPResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetOTPResponse) XXX_Merge 

func (m *GetOTPResponse) XXX_Merge(src proto.Message)

func (*GetOTPResponse) XXX_Size 

func (m *GetOTPResponse) XXX_Size() int

func (*GetOTPResponse) XXX_Unmarshal 

func (m *GetOTPResponse) XXX_Unmarshal(b []byte) error

type GetOrganizationRequest 

type GetOrganizationRequest struct {
	// Organization ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetOrganizationRequest) Descriptor 

func (*GetOrganizationRequest) Descriptor() ([]byte, []int)

func (*GetOrganizationRequest) GetId 

func (m *GetOrganizationRequest) GetId() int64

func (*GetOrganizationRequest) ProtoMessage 

func (*GetOrganizationRequest) ProtoMessage()

func (*GetOrganizationRequest) Reset 

func (m *GetOrganizationRequest) Reset()

func (*GetOrganizationRequest) String 

func (m *GetOrganizationRequest) String() string

func (*GetOrganizationRequest) XXX_DiscardUnknown 

func (m *GetOrganizationRequest) XXX_DiscardUnknown()

func (*GetOrganizationRequest) XXX_Marshal 

func (m *GetOrganizationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetOrganizationRequest) XXX_Merge 

func (m *GetOrganizationRequest) XXX_Merge(src proto.Message)

func (*GetOrganizationRequest) XXX_Size 

func (m *GetOrganizationRequest) XXX_Size() int

func (*GetOrganizationRequest) XXX_Unmarshal 

func (m *GetOrganizationRequest) XXX_Unmarshal(b []byte) error

type GetOrganizationResponse 

type GetOrganizationResponse struct {
	// Organization object.
	Organization *Organization `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetOrganizationResponse) Descriptor 

func (*GetOrganizationResponse) Descriptor() ([]byte, []int)

func (*GetOrganizationResponse) GetCreatedAt 

func (m *GetOrganizationResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetOrganizationResponse) GetOrganization 

func (m *GetOrganizationResponse) GetOrganization() *Organization

func (*GetOrganizationResponse) GetUpdatedAt 

func (m *GetOrganizationResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetOrganizationResponse) ProtoMessage 

func (*GetOrganizationResponse) ProtoMessage()

func (*GetOrganizationResponse) Reset 

func (m *GetOrganizationResponse) Reset()

func (*GetOrganizationResponse) String 

func (m *GetOrganizationResponse) String() string

func (*GetOrganizationResponse) XXX_DiscardUnknown 

func (m *GetOrganizationResponse) XXX_DiscardUnknown()

func (*GetOrganizationResponse) XXX_Marshal 

func (m *GetOrganizationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetOrganizationResponse) XXX_Merge 

func (m *GetOrganizationResponse) XXX_Merge(src proto.Message)

func (*GetOrganizationResponse) XXX_Size 

func (m *GetOrganizationResponse) XXX_Size() int

func (*GetOrganizationResponse) XXX_Unmarshal 

func (m *GetOrganizationResponse) XXX_Unmarshal(b []byte) error

type GetOrganizationUserRequest 

type GetOrganizationUserRequest struct {
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// User ID.
	UserId               int64    `protobuf:"varint,2,opt,name=user_id,json=userID,proto3" json:"user_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetOrganizationUserRequest) Descriptor 

func (*GetOrganizationUserRequest) Descriptor() ([]byte, []int)

func (*GetOrganizationUserRequest) GetOrganizationId 

func (m *GetOrganizationUserRequest) GetOrganizationId() int64

func (*GetOrganizationUserRequest) GetUserId 

func (m *GetOrganizationUserRequest) GetUserId() int64

func (*GetOrganizationUserRequest) ProtoMessage 

func (*GetOrganizationUserRequest) ProtoMessage()

func (*GetOrganizationUserRequest) Reset 

func (m *GetOrganizationUserRequest) Reset()

func (*GetOrganizationUserRequest) String 

func (m *GetOrganizationUserRequest) String() string

func (*GetOrganizationUserRequest) XXX_DiscardUnknown 

func (m *GetOrganizationUserRequest) XXX_DiscardUnknown()

func (*GetOrganizationUserRequest) XXX_Marshal 

func (m *GetOrganizationUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetOrganizationUserRequest) XXX_Merge 

func (m *GetOrganizationUserRequest) XXX_Merge(src proto.Message)

func (*GetOrganizationUserRequest) XXX_Size 

func (m *GetOrganizationUserRequest) XXX_Size() int

func (*GetOrganizationUserRequest) XXX_Unmarshal 

func (m *GetOrganizationUserRequest) XXX_Unmarshal(b []byte) error

type GetOrganizationUserResponse 

type GetOrganizationUserResponse struct {
	// Organization-user object.
	OrganizationUser *OrganizationUser `protobuf:"bytes,1,opt,name=organization_user,json=organizationUser,proto3" json:"organization_user,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

Response for a user in the organization

func (*GetOrganizationUserResponse) Descriptor 

func (*GetOrganizationUserResponse) Descriptor() ([]byte, []int)

func (*GetOrganizationUserResponse) GetCreatedAt 

func (m *GetOrganizationUserResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetOrganizationUserResponse) GetOrganizationUser 

func (m *GetOrganizationUserResponse) GetOrganizationUser() *OrganizationUser

func (*GetOrganizationUserResponse) GetUpdatedAt 

func (m *GetOrganizationUserResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetOrganizationUserResponse) ProtoMessage 

func (*GetOrganizationUserResponse) ProtoMessage()

func (*GetOrganizationUserResponse) Reset 

func (m *GetOrganizationUserResponse) Reset()

func (*GetOrganizationUserResponse) String 

func (m *GetOrganizationUserResponse) String() string

func (*GetOrganizationUserResponse) XXX_DiscardUnknown 

func (m *GetOrganizationUserResponse) XXX_DiscardUnknown()

func (*GetOrganizationUserResponse) XXX_Marshal 

func (m *GetOrganizationUserResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetOrganizationUserResponse) XXX_Merge 

func (m *GetOrganizationUserResponse) XXX_Merge(src proto.Message)

func (*GetOrganizationUserResponse) XXX_Size 

func (m *GetOrganizationUserResponse) XXX_Size() int

func (*GetOrganizationUserResponse) XXX_Unmarshal 

func (m *GetOrganizationUserResponse) XXX_Unmarshal(b []byte) error

type GetPilotThingsIntegrationRequest 

type GetPilotThingsIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetPilotThingsIntegrationRequest) Descriptor 

func (*GetPilotThingsIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetPilotThingsIntegrationRequest) GetApplicationId 

func (m *GetPilotThingsIntegrationRequest) GetApplicationId() int64

func (*GetPilotThingsIntegrationRequest) ProtoMessage 

func (*GetPilotThingsIntegrationRequest) ProtoMessage()

func (*GetPilotThingsIntegrationRequest) Reset 

func (m *GetPilotThingsIntegrationRequest) Reset()

func (*GetPilotThingsIntegrationRequest) String 

func (m *GetPilotThingsIntegrationRequest) String() string

func (*GetPilotThingsIntegrationRequest) XXX_DiscardUnknown 

func (m *GetPilotThingsIntegrationRequest) XXX_DiscardUnknown()

func (*GetPilotThingsIntegrationRequest) XXX_Marshal 

func (m *GetPilotThingsIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetPilotThingsIntegrationRequest) XXX_Merge 

func (m *GetPilotThingsIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetPilotThingsIntegrationRequest) XXX_Size 

func (m *GetPilotThingsIntegrationRequest) XXX_Size() int

func (*GetPilotThingsIntegrationRequest) XXX_Unmarshal 

func (m *GetPilotThingsIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetPilotThingsIntegrationResponse 

type GetPilotThingsIntegrationResponse struct {
	// Integration object.
	Integration          *PilotThingsIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*GetPilotThingsIntegrationResponse) Descriptor 

func (*GetPilotThingsIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetPilotThingsIntegrationResponse) GetIntegration 

func (m *GetPilotThingsIntegrationResponse) GetIntegration() *PilotThingsIntegration

func (*GetPilotThingsIntegrationResponse) ProtoMessage 

func (*GetPilotThingsIntegrationResponse) ProtoMessage()

func (*GetPilotThingsIntegrationResponse) Reset 

func (m *GetPilotThingsIntegrationResponse) Reset()

func (*GetPilotThingsIntegrationResponse) String 

func (m *GetPilotThingsIntegrationResponse) String() string

func (*GetPilotThingsIntegrationResponse) XXX_DiscardUnknown 

func (m *GetPilotThingsIntegrationResponse) XXX_DiscardUnknown()

func (*GetPilotThingsIntegrationResponse) XXX_Marshal 

func (m *GetPilotThingsIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetPilotThingsIntegrationResponse) XXX_Merge 

func (m *GetPilotThingsIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetPilotThingsIntegrationResponse) XXX_Size 

func (m *GetPilotThingsIntegrationResponse) XXX_Size() int

func (*GetPilotThingsIntegrationResponse) XXX_Unmarshal 

func (m *GetPilotThingsIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetRandomDevAddrRequest 

type GetRandomDevAddrRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetRandomDevAddrRequest) Descriptor 

func (*GetRandomDevAddrRequest) Descriptor() ([]byte, []int)

func (*GetRandomDevAddrRequest) GetDevEui 

func (m *GetRandomDevAddrRequest) GetDevEui() string

func (*GetRandomDevAddrRequest) ProtoMessage 

func (*GetRandomDevAddrRequest) ProtoMessage()

func (*GetRandomDevAddrRequest) Reset 

func (m *GetRandomDevAddrRequest) Reset()

func (*GetRandomDevAddrRequest) String 

func (m *GetRandomDevAddrRequest) String() string

func (*GetRandomDevAddrRequest) XXX_DiscardUnknown 

func (m *GetRandomDevAddrRequest) XXX_DiscardUnknown()

func (*GetRandomDevAddrRequest) XXX_Marshal 

func (m *GetRandomDevAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetRandomDevAddrRequest) XXX_Merge 

func (m *GetRandomDevAddrRequest) XXX_Merge(src proto.Message)

func (*GetRandomDevAddrRequest) XXX_Size 

func (m *GetRandomDevAddrRequest) XXX_Size() int

func (*GetRandomDevAddrRequest) XXX_Unmarshal 

func (m *GetRandomDevAddrRequest) XXX_Unmarshal(b []byte) error

type GetRandomDevAddrResponse 

type GetRandomDevAddrResponse struct {
	// Device address (HEX encoded).
	DevAddr              string   `protobuf:"bytes,1,opt,name=dev_addr,json=devAddr,proto3" json:"dev_addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetRandomDevAddrResponse) Descriptor 

func (*GetRandomDevAddrResponse) Descriptor() ([]byte, []int)

func (*GetRandomDevAddrResponse) GetDevAddr 

func (m *GetRandomDevAddrResponse) GetDevAddr() string

func (*GetRandomDevAddrResponse) ProtoMessage 

func (*GetRandomDevAddrResponse) ProtoMessage()

func (*GetRandomDevAddrResponse) Reset 

func (m *GetRandomDevAddrResponse) Reset()

func (*GetRandomDevAddrResponse) String 

func (m *GetRandomDevAddrResponse) String() string

func (*GetRandomDevAddrResponse) XXX_DiscardUnknown 

func (m *GetRandomDevAddrResponse) XXX_DiscardUnknown()

func (*GetRandomDevAddrResponse) XXX_Marshal 

func (m *GetRandomDevAddrResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetRandomDevAddrResponse) XXX_Merge 

func (m *GetRandomDevAddrResponse) XXX_Merge(src proto.Message)

func (*GetRandomDevAddrResponse) XXX_Size 

func (m *GetRandomDevAddrResponse) XXX_Size() int

func (*GetRandomDevAddrResponse) XXX_Unmarshal 

func (m *GetRandomDevAddrResponse) XXX_Unmarshal(b []byte) error

type GetServerResponse 

type GetServerResponse struct {
	WifiAP               *WiFiAP  `protobuf:"bytes,1,opt,name=wifiAP,proto3" json:"wifiAP,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetServerResponse) Descriptor 

func (*GetServerResponse) Descriptor() ([]byte, []int)

func (*GetServerResponse) GetWifiAP 

func (m *GetServerResponse) GetWifiAP() *WiFiAP

func (*GetServerResponse) ProtoMessage 

func (*GetServerResponse) ProtoMessage()

func (*GetServerResponse) Reset 

func (m *GetServerResponse) Reset()

func (*GetServerResponse) String 

func (m *GetServerResponse) String() string

func (*GetServerResponse) XXX_DiscardUnknown 

func (m *GetServerResponse) XXX_DiscardUnknown()

func (*GetServerResponse) XXX_Marshal 

func (m *GetServerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetServerResponse) XXX_Merge 

func (m *GetServerResponse) XXX_Merge(src proto.Message)

func (*GetServerResponse) XXX_Size 

func (m *GetServerResponse) XXX_Size() int

func (*GetServerResponse) XXX_Unmarshal 

func (m *GetServerResponse) XXX_Unmarshal(b []byte) error

type GetServiceProfileRequest 

type GetServiceProfileRequest struct {
	// Service-profile ID (UUID string).
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetServiceProfileRequest) Descriptor 

func (*GetServiceProfileRequest) Descriptor() ([]byte, []int)

func (*GetServiceProfileRequest) GetId 

func (m *GetServiceProfileRequest) GetId() string

func (*GetServiceProfileRequest) ProtoMessage 

func (*GetServiceProfileRequest) ProtoMessage()

func (*GetServiceProfileRequest) Reset 

func (m *GetServiceProfileRequest) Reset()

func (*GetServiceProfileRequest) String 

func (m *GetServiceProfileRequest) String() string

func (*GetServiceProfileRequest) XXX_DiscardUnknown 

func (m *GetServiceProfileRequest) XXX_DiscardUnknown()

func (*GetServiceProfileRequest) XXX_Marshal 

func (m *GetServiceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetServiceProfileRequest) XXX_Merge 

func (m *GetServiceProfileRequest) XXX_Merge(src proto.Message)

func (*GetServiceProfileRequest) XXX_Size 

func (m *GetServiceProfileRequest) XXX_Size() int

func (*GetServiceProfileRequest) XXX_Unmarshal 

func (m *GetServiceProfileRequest) XXX_Unmarshal(b []byte) error

type GetServiceProfileResponse 

type GetServiceProfileResponse struct {
	// Service-profile object.
	ServiceProfile *ServiceProfile `protobuf:"bytes,1,opt,name=service_profile,json=serviceProfile,proto3" json:"service_profile,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetServiceProfileResponse) Descriptor 

func (*GetServiceProfileResponse) Descriptor() ([]byte, []int)

func (*GetServiceProfileResponse) GetCreatedAt 

func (m *GetServiceProfileResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetServiceProfileResponse) GetServiceProfile 

func (m *GetServiceProfileResponse) GetServiceProfile() *ServiceProfile

func (*GetServiceProfileResponse) GetUpdatedAt 

func (m *GetServiceProfileResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetServiceProfileResponse) ProtoMessage 

func (*GetServiceProfileResponse) ProtoMessage()

func (*GetServiceProfileResponse) Reset 

func (m *GetServiceProfileResponse) Reset()

func (*GetServiceProfileResponse) String 

func (m *GetServiceProfileResponse) String() string

func (*GetServiceProfileResponse) XXX_DiscardUnknown 

func (m *GetServiceProfileResponse) XXX_DiscardUnknown()

func (*GetServiceProfileResponse) XXX_Marshal 

func (m *GetServiceProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetServiceProfileResponse) XXX_Merge 

func (m *GetServiceProfileResponse) XXX_Merge(src proto.Message)

func (*GetServiceProfileResponse) XXX_Size 

func (m *GetServiceProfileResponse) XXX_Size() int

func (*GetServiceProfileResponse) XXX_Unmarshal 

func (m *GetServiceProfileResponse) XXX_Unmarshal(b []byte) error

type GetSystemTimeResponse 

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 (*GetSystemTimeResponse) Descriptor 

func (*GetSystemTimeResponse) Descriptor() ([]byte, []int)

func (*GetSystemTimeResponse) GetTimestamp 

func (m *GetSystemTimeResponse) GetTimestamp() *timestamppb.Timestamp

func (*GetSystemTimeResponse) ProtoMessage 

func (*GetSystemTimeResponse) ProtoMessage()

func (*GetSystemTimeResponse) Reset 

func (m *GetSystemTimeResponse) Reset()

func (*GetSystemTimeResponse) String 

func (m *GetSystemTimeResponse) String() string

func (*GetSystemTimeResponse) XXX_DiscardUnknown 

func (m *GetSystemTimeResponse) XXX_DiscardUnknown()

func (*GetSystemTimeResponse) XXX_Marshal 

func (m *GetSystemTimeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetSystemTimeResponse) XXX_Merge 

func (m *GetSystemTimeResponse) XXX_Merge(src proto.Message)

func (*GetSystemTimeResponse) XXX_Size 

func (m *GetSystemTimeResponse) XXX_Size() int

func (*GetSystemTimeResponse) XXX_Unmarshal 

func (m *GetSystemTimeResponse) XXX_Unmarshal(b []byte) error

type GetThingsBoardIntegrationRequest 

type GetThingsBoardIntegrationRequest struct {
	// Application ID.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetThingsBoardIntegrationRequest) Descriptor 

func (*GetThingsBoardIntegrationRequest) Descriptor() ([]byte, []int)

func (*GetThingsBoardIntegrationRequest) GetApplicationId 

func (m *GetThingsBoardIntegrationRequest) GetApplicationId() int64

func (*GetThingsBoardIntegrationRequest) ProtoMessage 

func (*GetThingsBoardIntegrationRequest) ProtoMessage()

func (*GetThingsBoardIntegrationRequest) Reset 

func (m *GetThingsBoardIntegrationRequest) Reset()

func (*GetThingsBoardIntegrationRequest) String 

func (m *GetThingsBoardIntegrationRequest) String() string

func (*GetThingsBoardIntegrationRequest) XXX_DiscardUnknown 

func (m *GetThingsBoardIntegrationRequest) XXX_DiscardUnknown()

func (*GetThingsBoardIntegrationRequest) XXX_Marshal 

func (m *GetThingsBoardIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetThingsBoardIntegrationRequest) XXX_Merge 

func (m *GetThingsBoardIntegrationRequest) XXX_Merge(src proto.Message)

func (*GetThingsBoardIntegrationRequest) XXX_Size 

func (m *GetThingsBoardIntegrationRequest) XXX_Size() int

func (*GetThingsBoardIntegrationRequest) XXX_Unmarshal 

func (m *GetThingsBoardIntegrationRequest) XXX_Unmarshal(b []byte) error

type GetThingsBoardIntegrationResponse 

type GetThingsBoardIntegrationResponse struct {
	// Integration object.
	Integration          *ThingsBoardIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*GetThingsBoardIntegrationResponse) Descriptor 

func (*GetThingsBoardIntegrationResponse) Descriptor() ([]byte, []int)

func (*GetThingsBoardIntegrationResponse) GetIntegration 

func (m *GetThingsBoardIntegrationResponse) GetIntegration() *ThingsBoardIntegration

func (*GetThingsBoardIntegrationResponse) ProtoMessage 

func (*GetThingsBoardIntegrationResponse) ProtoMessage()

func (*GetThingsBoardIntegrationResponse) Reset 

func (m *GetThingsBoardIntegrationResponse) Reset()

func (*GetThingsBoardIntegrationResponse) String 

func (m *GetThingsBoardIntegrationResponse) String() string

func (*GetThingsBoardIntegrationResponse) XXX_DiscardUnknown 

func (m *GetThingsBoardIntegrationResponse) XXX_DiscardUnknown()

func (*GetThingsBoardIntegrationResponse) XXX_Marshal 

func (m *GetThingsBoardIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetThingsBoardIntegrationResponse) XXX_Merge 

func (m *GetThingsBoardIntegrationResponse) XXX_Merge(src proto.Message)

func (*GetThingsBoardIntegrationResponse) XXX_Size 

func (m *GetThingsBoardIntegrationResponse) XXX_Size() int

func (*GetThingsBoardIntegrationResponse) XXX_Unmarshal 

func (m *GetThingsBoardIntegrationResponse) XXX_Unmarshal(b []byte) error

type GetTimezoneResponse 

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 (*GetTimezoneResponse) Descriptor 

func (*GetTimezoneResponse) Descriptor() ([]byte, []int)

func (*GetTimezoneResponse) GetTimezone 

func (m *GetTimezoneResponse) GetTimezone() string

func (*GetTimezoneResponse) ProtoMessage 

func (*GetTimezoneResponse) ProtoMessage()

func (*GetTimezoneResponse) Reset 

func (m *GetTimezoneResponse) Reset()

func (*GetTimezoneResponse) String 

func (m *GetTimezoneResponse) String() string

func (*GetTimezoneResponse) XXX_DiscardUnknown 

func (m *GetTimezoneResponse) XXX_DiscardUnknown()

func (*GetTimezoneResponse) XXX_Marshal 

func (m *GetTimezoneResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetTimezoneResponse) XXX_Merge 

func (m *GetTimezoneResponse) XXX_Merge(src proto.Message)

func (*GetTimezoneResponse) XXX_Size 

func (m *GetTimezoneResponse) XXX_Size() int

func (*GetTimezoneResponse) XXX_Unmarshal 

func (m *GetTimezoneResponse) XXX_Unmarshal(b []byte) error

type GetUserRequest 

type GetUserRequest struct {
	// User ID.
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GetUserRequest) Descriptor 

func (*GetUserRequest) Descriptor() ([]byte, []int)

func (*GetUserRequest) GetId 

func (m *GetUserRequest) GetId() int64

func (*GetUserRequest) ProtoMessage 

func (*GetUserRequest) ProtoMessage()

func (*GetUserRequest) Reset 

func (m *GetUserRequest) Reset()

func (*GetUserRequest) String 

func (m *GetUserRequest) String() string

func (*GetUserRequest) XXX_DiscardUnknown 

func (m *GetUserRequest) XXX_DiscardUnknown()

func (*GetUserRequest) XXX_Marshal 

func (m *GetUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetUserRequest) XXX_Merge 

func (m *GetUserRequest) XXX_Merge(src proto.Message)

func (*GetUserRequest) XXX_Size 

func (m *GetUserRequest) XXX_Size() int

func (*GetUserRequest) XXX_Unmarshal 

func (m *GetUserRequest) XXX_Unmarshal(b []byte) error

type GetUserResponse 

type GetUserResponse struct {
	// User object.
	User *User `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*GetUserResponse) Descriptor 

func (*GetUserResponse) Descriptor() ([]byte, []int)

func (*GetUserResponse) GetCreatedAt 

func (m *GetUserResponse) GetCreatedAt() *timestamppb.Timestamp

func (*GetUserResponse) GetUpdatedAt 

func (m *GetUserResponse) GetUpdatedAt() *timestamppb.Timestamp

func (*GetUserResponse) GetUser 

func (m *GetUserResponse) GetUser() *User

func (*GetUserResponse) ProtoMessage 

func (*GetUserResponse) ProtoMessage()

func (*GetUserResponse) Reset 

func (m *GetUserResponse) Reset()

func (*GetUserResponse) String 

func (m *GetUserResponse) String() string

func (*GetUserResponse) XXX_DiscardUnknown 

func (m *GetUserResponse) XXX_DiscardUnknown()

func (*GetUserResponse) XXX_Marshal 

func (m *GetUserResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetUserResponse) XXX_Merge 

func (m *GetUserResponse) XXX_Merge(src proto.Message)

func (*GetUserResponse) XXX_Size 

func (m *GetUserResponse) XXX_Size() int

func (*GetUserResponse) XXX_Unmarshal 

func (m *GetUserResponse) XXX_Unmarshal(b []byte) error

type GetVPNRequest 

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

func (*GetVPNRequest) Descriptor 

func (*GetVPNRequest) Descriptor() ([]byte, []int)

func (*GetVPNRequest) GetMode 

func (m *GetVPNRequest) GetMode() string

func (*GetVPNRequest) ProtoMessage 

func (*GetVPNRequest) ProtoMessage()

func (*GetVPNRequest) Reset 

func (m *GetVPNRequest) Reset()

func (*GetVPNRequest) String 

func (m *GetVPNRequest) String() string

func (*GetVPNRequest) XXX_DiscardUnknown 

func (m *GetVPNRequest) XXX_DiscardUnknown()

func (*GetVPNRequest) XXX_Marshal 

func (m *GetVPNRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetVPNRequest) XXX_Merge 

func (m *GetVPNRequest) XXX_Merge(src proto.Message)

func (*GetVPNRequest) XXX_Size 

func (m *GetVPNRequest) XXX_Size() int

func (*GetVPNRequest) XXX_Unmarshal 

func (m *GetVPNRequest) XXX_Unmarshal(b []byte) error

type GetVPNResponse 

type GetVPNResponse struct {
	Enable bool   `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"`
	Status string `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	// Types that are valid to be assigned to Vpn:
	//
	//	*GetVPNResponse_Pptp
	//	*GetVPNResponse_L2Tp
	//	*GetVPNResponse_Ipsec
	Vpn                  isGetVPNResponse_Vpn `protobuf_oneof:"vpn"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*GetVPNResponse) Descriptor 

func (*GetVPNResponse) Descriptor() ([]byte, []int)

func (*GetVPNResponse) GetEnable 

func (m *GetVPNResponse) GetEnable() bool

func (*GetVPNResponse) GetIpsec 

func (m *GetVPNResponse) GetIpsec() *VPN_IPSec

func (*GetVPNResponse) GetL2Tp 

func (m *GetVPNResponse) GetL2Tp() *VPN_L2TP

func (*GetVPNResponse) GetPptp 

func (m *GetVPNResponse) GetPptp() *VPN_PPTP

func (*GetVPNResponse) GetStatus 

func (m *GetVPNResponse) GetStatus() string

func (*GetVPNResponse) GetVpn 

func (m *GetVPNResponse) GetVpn() isGetVPNResponse_Vpn

func (*GetVPNResponse) ProtoMessage 

func (*GetVPNResponse) ProtoMessage()

func (*GetVPNResponse) Reset 

func (m *GetVPNResponse) Reset()

func (*GetVPNResponse) String 

func (m *GetVPNResponse) String() string

func (*GetVPNResponse) XXX_DiscardUnknown 

func (m *GetVPNResponse) XXX_DiscardUnknown()

func (*GetVPNResponse) XXX_Marshal 

func (m *GetVPNResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetVPNResponse) XXX_Merge 

func (m *GetVPNResponse) XXX_Merge(src proto.Message)

func (*GetVPNResponse) XXX_OneofWrappers 

func (*GetVPNResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*GetVPNResponse) XXX_Size 

func (m *GetVPNResponse) XXX_Size() int

func (*GetVPNResponse) XXX_Unmarshal 

func (m *GetVPNResponse) XXX_Unmarshal(b []byte) error

type GetVPNResponse_Ipsec 

type GetVPNResponse_Ipsec struct {
	Ipsec *VPN_IPSec `protobuf:"bytes,3,opt,name=ipsec,json=IPSec,proto3,oneof"`
}

type GetVPNResponse_L2Tp 

type GetVPNResponse_L2Tp struct {
	L2Tp *VPN_L2TP `protobuf:"bytes,2,opt,name=l2tp,json=L2TP,proto3,oneof"`
}

type GetVPNResponse_Pptp 

type GetVPNResponse_Pptp struct {
	Pptp *VPN_PPTP `protobuf:"bytes,1,opt,name=pptp,json=PPTP,proto3,oneof"`
}

type GetWiFiConfigurationRequest 

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

func (*GetWiFiConfigurationRequest) Descriptor 

func (*GetWiFiConfigurationRequest) Descriptor() ([]byte, []int)

func (*GetWiFiConfigurationRequest) GetMode 

func (m *GetWiFiConfigurationRequest) GetMode() string

func (*GetWiFiConfigurationRequest) ProtoMessage 

func (*GetWiFiConfigurationRequest) ProtoMessage()

func (*GetWiFiConfigurationRequest) Reset 

func (m *GetWiFiConfigurationRequest) Reset()

func (*GetWiFiConfigurationRequest) String 

func (m *GetWiFiConfigurationRequest) String() string

func (*GetWiFiConfigurationRequest) XXX_DiscardUnknown 

func (m *GetWiFiConfigurationRequest) XXX_DiscardUnknown()

func (*GetWiFiConfigurationRequest) XXX_Marshal 

func (m *GetWiFiConfigurationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetWiFiConfigurationRequest) XXX_Merge 

func (m *GetWiFiConfigurationRequest) XXX_Merge(src proto.Message)

func (*GetWiFiConfigurationRequest) XXX_Size 

func (m *GetWiFiConfigurationRequest) XXX_Size() int

func (*GetWiFiConfigurationRequest) XXX_Unmarshal 

func (m *GetWiFiConfigurationRequest) XXX_Unmarshal(b []byte) error

type GetWiFiConfigurationResponse 

type GetWiFiConfigurationResponse struct {
	// Types that are valid to be assigned to Configuration:
	//
	//	*GetWiFiConfigurationResponse_WifiAP
	//	*GetWiFiConfigurationResponse_WifiSTA
	Configuration        isGetWiFiConfigurationResponse_Configuration `protobuf_oneof:"configuration"`
	XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
	XXX_unrecognized     []byte                                       `json:"-"`
	XXX_sizecache        int32                                        `json:"-"`
}

func (*GetWiFiConfigurationResponse) Descriptor 

func (*GetWiFiConfigurationResponse) Descriptor() ([]byte, []int)

func (*GetWiFiConfigurationResponse) GetConfiguration 

func (m *GetWiFiConfigurationResponse) GetConfiguration() isGetWiFiConfigurationResponse_Configuration

func (*GetWiFiConfigurationResponse) GetWifiAP 

func (m *GetWiFiConfigurationResponse) GetWifiAP() *WiFiAPConfiguration

func (*GetWiFiConfigurationResponse) GetWifiSTA 

func (m *GetWiFiConfigurationResponse) GetWifiSTA() *WiFiSTAConfigurationList

func (*GetWiFiConfigurationResponse) ProtoMessage 

func (*GetWiFiConfigurationResponse) ProtoMessage()

func (*GetWiFiConfigurationResponse) Reset 

func (m *GetWiFiConfigurationResponse) Reset()

func (*GetWiFiConfigurationResponse) String 

func (m *GetWiFiConfigurationResponse) String() string

func (*GetWiFiConfigurationResponse) XXX_DiscardUnknown 

func (m *GetWiFiConfigurationResponse) XXX_DiscardUnknown()

func (*GetWiFiConfigurationResponse) XXX_Marshal 

func (m *GetWiFiConfigurationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GetWiFiConfigurationResponse) XXX_Merge 

func (m *GetWiFiConfigurationResponse) XXX_Merge(src proto.Message)

func (*GetWiFiConfigurationResponse) XXX_OneofWrappers 

func (*GetWiFiConfigurationResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*GetWiFiConfigurationResponse) XXX_Size 

func (m *GetWiFiConfigurationResponse) XXX_Size() int

func (*GetWiFiConfigurationResponse) XXX_Unmarshal 

func (m *GetWiFiConfigurationResponse) XXX_Unmarshal(b []byte) error

type GetWiFiConfigurationResponse_WifiAP 

type GetWiFiConfigurationResponse_WifiAP struct {
	WifiAP *WiFiAPConfiguration `protobuf:"bytes,1,opt,name=wifiAP,proto3,oneof"`
}

type GetWiFiConfigurationResponse_WifiSTA 

type GetWiFiConfigurationResponse_WifiSTA struct {
	WifiSTA *WiFiSTAConfigurationList `protobuf:"bytes,2,opt,name=wifiSTA,proto3,oneof"`
}

type GlobalSearchRequest 

type GlobalSearchRequest struct {
	// Search query.
	Search string `protobuf:"bytes,1,opt,name=search,proto3" json:"search,omitempty"`
	// Max number of results to return.
	Limit int64 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset offset of the result-set (for pagination).
	Offset               int64    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GlobalSearchRequest) Descriptor 

func (*GlobalSearchRequest) Descriptor() ([]byte, []int)

func (*GlobalSearchRequest) GetLimit 

func (m *GlobalSearchRequest) GetLimit() int64

func (*GlobalSearchRequest) GetOffset 

func (m *GlobalSearchRequest) GetOffset() int64

func (*GlobalSearchRequest) GetSearch 

func (m *GlobalSearchRequest) GetSearch() string

func (*GlobalSearchRequest) ProtoMessage 

func (*GlobalSearchRequest) ProtoMessage()

func (*GlobalSearchRequest) Reset 

func (m *GlobalSearchRequest) Reset()

func (*GlobalSearchRequest) String 

func (m *GlobalSearchRequest) String() string

func (*GlobalSearchRequest) XXX_DiscardUnknown 

func (m *GlobalSearchRequest) XXX_DiscardUnknown()

func (*GlobalSearchRequest) XXX_Marshal 

func (m *GlobalSearchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GlobalSearchRequest) XXX_Merge 

func (m *GlobalSearchRequest) XXX_Merge(src proto.Message)

func (*GlobalSearchRequest) XXX_Size 

func (m *GlobalSearchRequest) XXX_Size() int

func (*GlobalSearchRequest) XXX_Unmarshal 

func (m *GlobalSearchRequest) XXX_Unmarshal(b []byte) error

type GlobalSearchResponse 

type GlobalSearchResponse struct {
	Result               []*GlobalSearchResult `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*GlobalSearchResponse) Descriptor 

func (*GlobalSearchResponse) Descriptor() ([]byte, []int)

func (*GlobalSearchResponse) GetResult 

func (m *GlobalSearchResponse) GetResult() []*GlobalSearchResult

func (*GlobalSearchResponse) ProtoMessage 

func (*GlobalSearchResponse) ProtoMessage()

func (*GlobalSearchResponse) Reset 

func (m *GlobalSearchResponse) Reset()

func (*GlobalSearchResponse) String 

func (m *GlobalSearchResponse) String() string

func (*GlobalSearchResponse) XXX_DiscardUnknown 

func (m *GlobalSearchResponse) XXX_DiscardUnknown()

func (*GlobalSearchResponse) XXX_Marshal 

func (m *GlobalSearchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GlobalSearchResponse) XXX_Merge 

func (m *GlobalSearchResponse) XXX_Merge(src proto.Message)

func (*GlobalSearchResponse) XXX_Size 

func (m *GlobalSearchResponse) XXX_Size() int

func (*GlobalSearchResponse) XXX_Unmarshal 

func (m *GlobalSearchResponse) XXX_Unmarshal(b []byte) error

type GlobalSearchResult 

type GlobalSearchResult struct {
	// Record kind.
	Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
	// Search score.
	Score float32 `protobuf:"fixed32,2,opt,name=score,proto3" json:"score,omitempty"`
	// Organization id.
	OrganizationId int64 `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Organization name.
	OrganizationName string `protobuf:"bytes,4,opt,name=organization_name,json=organizationName,proto3" json:"organization_name,omitempty"`
	// Application id.
	ApplicationId int64 `protobuf:"varint,5,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Application name.
	ApplicationName string `protobuf:"bytes,6,opt,name=application_name,json=applicationName,proto3" json:"application_name,omitempty"`
	// Device DevEUI (hex encoded).
	DeviceDevEui string `protobuf:"bytes,7,opt,name=device_dev_eui,json=deviceDevEUI,proto3" json:"device_dev_eui,omitempty"`
	// Device name.
	DeviceName string `protobuf:"bytes,8,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
	// Gateway MAC (hex encoded).
	GatewayMac string `protobuf:"bytes,9,opt,name=gateway_mac,json=gatewayMAC,proto3" json:"gateway_mac,omitempty"`
	// Gateway name.
	GatewayName          string   `protobuf:"bytes,10,opt,name=gateway_name,json=gatewayName,proto3" json:"gateway_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*GlobalSearchResult) Descriptor 

func (*GlobalSearchResult) Descriptor() ([]byte, []int)

func (*GlobalSearchResult) GetApplicationId 

func (m *GlobalSearchResult) GetApplicationId() int64

func (*GlobalSearchResult) GetApplicationName 

func (m *GlobalSearchResult) GetApplicationName() string

func (*GlobalSearchResult) GetDeviceDevEui 

func (m *GlobalSearchResult) GetDeviceDevEui() string

func (*GlobalSearchResult) GetDeviceName 

func (m *GlobalSearchResult) GetDeviceName() string

func (*GlobalSearchResult) GetGatewayMac 

func (m *GlobalSearchResult) GetGatewayMac() string

func (*GlobalSearchResult) GetGatewayName 

func (m *GlobalSearchResult) GetGatewayName() string

func (*GlobalSearchResult) GetKind 

func (m *GlobalSearchResult) GetKind() string

func (*GlobalSearchResult) GetOrganizationId 

func (m *GlobalSearchResult) GetOrganizationId() int64

func (*GlobalSearchResult) GetOrganizationName 

func (m *GlobalSearchResult) GetOrganizationName() string

func (*GlobalSearchResult) GetScore 

func (m *GlobalSearchResult) GetScore() float32

func (*GlobalSearchResult) ProtoMessage 

func (*GlobalSearchResult) ProtoMessage()

func (*GlobalSearchResult) Reset 

func (m *GlobalSearchResult) Reset()

func (*GlobalSearchResult) String 

func (m *GlobalSearchResult) String() string

func (*GlobalSearchResult) XXX_DiscardUnknown 

func (m *GlobalSearchResult) XXX_DiscardUnknown()

func (*GlobalSearchResult) XXX_Marshal 

func (m *GlobalSearchResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GlobalSearchResult) XXX_Merge 

func (m *GlobalSearchResult) XXX_Merge(src proto.Message)

func (*GlobalSearchResult) XXX_Size 

func (m *GlobalSearchResult) XXX_Size() int

func (*GlobalSearchResult) XXX_Unmarshal 

func (m *GlobalSearchResult) XXX_Unmarshal(b []byte) error

type HTTPIntegration 

type HTTPIntegration struct {
	// The id of the application.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// The headers to use when making HTTP callbacks.
	Headers []*HTTPIntegrationHeader `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty"`
	// The URL to call for uplink data.
	// Deprecated: use event_endpoint_url.
	UplinkDataUrl string `protobuf:"bytes,3,opt,name=uplink_data_url,json=uplinkDataURL,proto3" json:"uplink_data_url,omitempty"`
	// The URL to call for join notifications.
	// Deprecated: use event_endpoint_url.
	JoinNotificationUrl string `protobuf:"bytes,4,opt,name=join_notification_url,json=joinNotificationURL,proto3" json:"join_notification_url,omitempty"`
	// The URL to call for ACK notifications (for confirmed downlink data).
	// Deprecated: use event_endpoint_url.
	AckNotificationUrl string `protobuf:"bytes,5,opt,name=ack_notification_url,json=ackNotificationURL,proto3" json:"ack_notification_url,omitempty"`
	// The URL to call for error notifications.
	// Deprecated: use event_endpoint_url.
	ErrorNotificationUrl string `protobuf:"bytes,6,opt,name=error_notification_url,json=errorNotificationURL,proto3" json:"error_notification_url,omitempty"`
	// The URL to call for device-status notifications.
	// Deprecated: use event_endpoint_url.
	StatusNotificationUrl string `` /* 126-byte string literal not displayed */
	// The URL to call for location notifications.
	// Deprecated: use event_endpoint_url.
	LocationNotificationUrl string `` /* 132-byte string literal not displayed */
	// The URL to call for tx ack notifications (downlink acknowledged by gateway for transmission).
	// Deprecated: use event_endpoint_url.
	TxAckNotificationUrl string `protobuf:"bytes,9,opt,name=tx_ack_notification_url,json=txAckNotificationURL,proto3" json:"tx_ack_notification_url,omitempty"`
	// The URL to call for integration notifications.
	// Deprecated: use event_endpoint_url.
	IntegrationNotificationUrl string `` /* 142-byte string literal not displayed */
	// Marshaler.
	// This defines the marshaler that is used to encode the event payload.
	Marshaler Marshaler `protobuf:"varint,11,opt,name=marshaler,proto3,enum=api.Marshaler" json:"marshaler,omitempty"`
	// Event endpoint URL.
	// The HTTP integration will POST all events to this enpoint. The request
	// will contain a query parameters "event" containing the type of the
	// event.
	EventEndpointUrl     string   `protobuf:"bytes,12,opt,name=event_endpoint_url,json=eventEndpointURL,proto3" json:"event_endpoint_url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*HTTPIntegration) Descriptor 

func (*HTTPIntegration) Descriptor() ([]byte, []int)

func (*HTTPIntegration) GetAckNotificationUrl 

func (m *HTTPIntegration) GetAckNotificationUrl() string

func (*HTTPIntegration) GetApplicationId 

func (m *HTTPIntegration) GetApplicationId() int64

func (*HTTPIntegration) GetErrorNotificationUrl 

func (m *HTTPIntegration) GetErrorNotificationUrl() string

func (*HTTPIntegration) GetEventEndpointUrl 

func (m *HTTPIntegration) GetEventEndpointUrl() string

func (*HTTPIntegration) GetHeaders 

func (m *HTTPIntegration) GetHeaders() []*HTTPIntegrationHeader

func (*HTTPIntegration) GetIntegrationNotificationUrl 

func (m *HTTPIntegration) GetIntegrationNotificationUrl() string

func (*HTTPIntegration) GetJoinNotificationUrl 

func (m *HTTPIntegration) GetJoinNotificationUrl() string

func (*HTTPIntegration) GetLocationNotificationUrl 

func (m *HTTPIntegration) GetLocationNotificationUrl() string

func (*HTTPIntegration) GetMarshaler 

func (m *HTTPIntegration) GetMarshaler() Marshaler

func (*HTTPIntegration) GetStatusNotificationUrl 

func (m *HTTPIntegration) GetStatusNotificationUrl() string

func (*HTTPIntegration) GetTxAckNotificationUrl 

func (m *HTTPIntegration) GetTxAckNotificationUrl() string

func (*HTTPIntegration) GetUplinkDataUrl 

func (m *HTTPIntegration) GetUplinkDataUrl() string

func (*HTTPIntegration) ProtoMessage 

func (*HTTPIntegration) ProtoMessage()

func (*HTTPIntegration) Reset 

func (m *HTTPIntegration) Reset()

func (*HTTPIntegration) String 

func (m *HTTPIntegration) String() string

func (*HTTPIntegration) XXX_DiscardUnknown 

func (m *HTTPIntegration) XXX_DiscardUnknown()

func (*HTTPIntegration) XXX_Marshal 

func (m *HTTPIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*HTTPIntegration) XXX_Merge 

func (m *HTTPIntegration) XXX_Merge(src proto.Message)

func (*HTTPIntegration) XXX_Size 

func (m *HTTPIntegration) XXX_Size() int

func (*HTTPIntegration) XXX_Unmarshal 

func (m *HTTPIntegration) XXX_Unmarshal(b []byte) error

type HTTPIntegrationHeader 

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

func (*HTTPIntegrationHeader) Descriptor 

func (*HTTPIntegrationHeader) Descriptor() ([]byte, []int)

func (*HTTPIntegrationHeader) GetKey 

func (m *HTTPIntegrationHeader) GetKey() string

func (*HTTPIntegrationHeader) GetValue 

func (m *HTTPIntegrationHeader) GetValue() string

func (*HTTPIntegrationHeader) ProtoMessage 

func (*HTTPIntegrationHeader) ProtoMessage()

func (*HTTPIntegrationHeader) Reset 

func (m *HTTPIntegrationHeader) Reset()

func (*HTTPIntegrationHeader) String 

func (m *HTTPIntegrationHeader) String() string

func (*HTTPIntegrationHeader) XXX_DiscardUnknown 

func (m *HTTPIntegrationHeader) XXX_DiscardUnknown()

func (*HTTPIntegrationHeader) XXX_Marshal 

func (m *HTTPIntegrationHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*HTTPIntegrationHeader) XXX_Merge 

func (m *HTTPIntegrationHeader) XXX_Merge(src proto.Message)

func (*HTTPIntegrationHeader) XXX_Size 

func (m *HTTPIntegrationHeader) XXX_Size() int

func (*HTTPIntegrationHeader) XXX_Unmarshal 

func (m *HTTPIntegrationHeader) XXX_Unmarshal(b []byte) error

type InfluxDBIntegration 

type InfluxDBIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// InfluxDB API write endpoint (e.g. http://localhost:8086/write).
	Endpoint string `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	// InfluxDB database name.
	Db string `protobuf:"bytes,3,opt,name=db,proto3" json:"db,omitempty"`
	// InfluxDB username.
	Username string `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"`
	// InfluxDB password.
	Password string `protobuf:"bytes,5,opt,name=password,proto3" json:"password,omitempty"`
	// InfluxDB retention policy name.
	RetentionPolicyName string `protobuf:"bytes,6,opt,name=retention_policy_name,json=retentionPolicyName,proto3" json:"retention_policy_name,omitempty"`
	// InfluxDB timestamp precision.
	Precision            InfluxDBPrecision `protobuf:"varint,7,opt,name=precision,proto3,enum=api.InfluxDBPrecision" json:"precision,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*InfluxDBIntegration) Descriptor 

func (*InfluxDBIntegration) Descriptor() ([]byte, []int)

func (*InfluxDBIntegration) GetApplicationId 

func (m *InfluxDBIntegration) GetApplicationId() int64

func (*InfluxDBIntegration) GetDb 

func (m *InfluxDBIntegration) GetDb() string

func (*InfluxDBIntegration) GetEndpoint 

func (m *InfluxDBIntegration) GetEndpoint() string

func (*InfluxDBIntegration) GetPassword 

func (m *InfluxDBIntegration) GetPassword() string

func (*InfluxDBIntegration) GetPrecision 

func (m *InfluxDBIntegration) GetPrecision() InfluxDBPrecision

func (*InfluxDBIntegration) GetRetentionPolicyName 

func (m *InfluxDBIntegration) GetRetentionPolicyName() string

func (*InfluxDBIntegration) GetUsername 

func (m *InfluxDBIntegration) GetUsername() string

func (*InfluxDBIntegration) ProtoMessage 

func (*InfluxDBIntegration) ProtoMessage()

func (*InfluxDBIntegration) Reset 

func (m *InfluxDBIntegration) Reset()

func (*InfluxDBIntegration) String 

func (m *InfluxDBIntegration) String() string

func (*InfluxDBIntegration) XXX_DiscardUnknown 

func (m *InfluxDBIntegration) XXX_DiscardUnknown()

func (*InfluxDBIntegration) XXX_Marshal 

func (m *InfluxDBIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*InfluxDBIntegration) XXX_Merge 

func (m *InfluxDBIntegration) XXX_Merge(src proto.Message)

func (*InfluxDBIntegration) XXX_Size 

func (m *InfluxDBIntegration) XXX_Size() int

func (*InfluxDBIntegration) XXX_Unmarshal 

func (m *InfluxDBIntegration) XXX_Unmarshal(b []byte) error

type InfluxDBPrecision 

type InfluxDBPrecision int32
const (
	InfluxDBPrecision_NS InfluxDBPrecision = 0
	InfluxDBPrecision_U  InfluxDBPrecision = 1
	InfluxDBPrecision_MS InfluxDBPrecision = 2
	InfluxDBPrecision_S  InfluxDBPrecision = 3
	InfluxDBPrecision_M  InfluxDBPrecision = 4
	InfluxDBPrecision_H  InfluxDBPrecision = 5
)

func (InfluxDBPrecision) EnumDescriptor 

func (InfluxDBPrecision) EnumDescriptor() ([]byte, []int)

func (InfluxDBPrecision) String 

func (x InfluxDBPrecision) String() string

type InstallListRequest 

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 (*InstallListRequest) Descriptor 

func (*InstallListRequest) Descriptor() ([]byte, []int)

func (*InstallListRequest) GetLimit 

func (m *InstallListRequest) GetLimit() int64

func (*InstallListRequest) GetOffset 

func (m *InstallListRequest) GetOffset() int64

func (*InstallListRequest) ProtoMessage 

func (*InstallListRequest) ProtoMessage()

func (*InstallListRequest) Reset 

func (m *InstallListRequest) Reset()

func (*InstallListRequest) String 

func (m *InstallListRequest) String() string

func (*InstallListRequest) XXX_DiscardUnknown 

func (m *InstallListRequest) XXX_DiscardUnknown()

func (*InstallListRequest) XXX_Marshal 

func (m *InstallListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*InstallListRequest) XXX_Merge 

func (m *InstallListRequest) XXX_Merge(src proto.Message)

func (*InstallListRequest) XXX_Size 

func (m *InstallListRequest) XXX_Size() int

func (*InstallListRequest) XXX_Unmarshal 

func (m *InstallListRequest) XXX_Unmarshal(b []byte) error

type InstallListResponse 

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 (*InstallListResponse) Descriptor 

func (*InstallListResponse) Descriptor() ([]byte, []int)

func (*InstallListResponse) GetResult 

func (m *InstallListResponse) GetResult() []*SoftwareInformation

func (*InstallListResponse) GetTotalCount 

func (m *InstallListResponse) GetTotalCount() int64

func (*InstallListResponse) ProtoMessage 

func (*InstallListResponse) ProtoMessage()

func (*InstallListResponse) Reset 

func (m *InstallListResponse) Reset()

func (*InstallListResponse) String 

func (m *InstallListResponse) String() string

func (*InstallListResponse) XXX_DiscardUnknown 

func (m *InstallListResponse) XXX_DiscardUnknown()

func (*InstallListResponse) XXX_Marshal 

func (m *InstallListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*InstallListResponse) XXX_Merge 

func (m *InstallListResponse) XXX_Merge(src proto.Message)

func (*InstallListResponse) XXX_Size 

func (m *InstallListResponse) XXX_Size() int

func (*InstallListResponse) XXX_Unmarshal 

func (m *InstallListResponse) XXX_Unmarshal(b []byte) error

type InstallRequest 

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 (*InstallRequest) Descriptor 

func (*InstallRequest) Descriptor() ([]byte, []int)

func (*InstallRequest) GetPath 

func (m *InstallRequest) GetPath() string

func (*InstallRequest) ProtoMessage 

func (*InstallRequest) ProtoMessage()

func (*InstallRequest) Reset 

func (m *InstallRequest) Reset()

func (*InstallRequest) String 

func (m *InstallRequest) String() string

func (*InstallRequest) XXX_DiscardUnknown 

func (m *InstallRequest) XXX_DiscardUnknown()

func (*InstallRequest) XXX_Marshal 

func (m *InstallRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*InstallRequest) XXX_Merge 

func (m *InstallRequest) XXX_Merge(src proto.Message)

func (*InstallRequest) XXX_Size 

func (m *InstallRequest) XXX_Size() int

func (*InstallRequest) XXX_Unmarshal 

func (m *InstallRequest) XXX_Unmarshal(b []byte) error

type IntegrationKind 

type IntegrationKind int32
const (
	IntegrationKind_HTTP              IntegrationKind = 0
	IntegrationKind_INFLUXDB          IntegrationKind = 1
	IntegrationKind_THINGSBOARD       IntegrationKind = 2
	IntegrationKind_MYDEVICES         IntegrationKind = 3
	IntegrationKind_LORACLOUD         IntegrationKind = 4
	IntegrationKind_GCP_PUBSUB        IntegrationKind = 5
	IntegrationKind_AWS_SNS           IntegrationKind = 6
	IntegrationKind_AZURE_SERVICE_BUS IntegrationKind = 7
	IntegrationKind_PILOT_THINGS      IntegrationKind = 8
)

func (IntegrationKind) EnumDescriptor 

func (IntegrationKind) EnumDescriptor() ([]byte, []int)

func (IntegrationKind) String 

func (x IntegrationKind) String() string

type IntegrationListItem 

type IntegrationListItem struct {
	// Integration kind.
	Kind                 IntegrationKind `protobuf:"varint,1,opt,name=kind,proto3,enum=api.IntegrationKind" json:"kind,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*IntegrationListItem) Descriptor 

func (*IntegrationListItem) Descriptor() ([]byte, []int)

func (*IntegrationListItem) GetKind 

func (m *IntegrationListItem) GetKind() IntegrationKind

func (*IntegrationListItem) ProtoMessage 

func (*IntegrationListItem) ProtoMessage()

func (*IntegrationListItem) Reset 

func (m *IntegrationListItem) Reset()

func (*IntegrationListItem) String 

func (m *IntegrationListItem) String() string

func (*IntegrationListItem) XXX_DiscardUnknown 

func (m *IntegrationListItem) XXX_DiscardUnknown()

func (*IntegrationListItem) XXX_Marshal 

func (m *IntegrationListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*IntegrationListItem) XXX_Merge 

func (m *IntegrationListItem) XXX_Merge(src proto.Message)

func (*IntegrationListItem) XXX_Size 

func (m *IntegrationListItem) XXX_Size() int

func (*IntegrationListItem) XXX_Unmarshal 

func (m *IntegrationListItem) XXX_Unmarshal(b []byte) error

type InternalServiceClient 

type InternalServiceClient interface {
	// Log in a user
	Login(ctx context.Context, in *LoginRequest, opts ...grpc.CallOption) (*LoginResponse, error)
	Quit(ctx context.Context, in *QuitRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Get the current user's profile
	Profile(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProfileResponse, error)
	// Perform a global search.
	GlobalSearch(ctx context.Context, in *GlobalSearchRequest, opts ...grpc.CallOption) (*GlobalSearchResponse, error)
	// CreateAPIKey creates the given API key.
	CreateAPIKey(ctx context.Context, in *CreateAPIKeyRequest, opts ...grpc.CallOption) (*CreateAPIKeyResponse, error)
	// DeleteAPIKey deletes the API key.
	DeleteAPIKey(ctx context.Context, in *DeleteAPIKeyRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// ListAPIKeys lists the available API keys.
	ListAPIKeys(ctx context.Context, in *ListAPIKeysRequest, opts ...grpc.CallOption) (*ListAPIKeysResponse, error)
	// Get the global settings.
	Settings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SettingsResponse, error)
	// OpenID Connect login.
	OpenIDConnectLogin(ctx context.Context, in *OpenIDConnectLoginRequest, opts ...grpc.CallOption) (*OpenIDConnectLoginResponse, error)
	// GetDevicesSummary returns an aggregated summary of the devices.
	GetDevicesSummary(ctx context.Context, in *GetDevicesSummaryRequest, opts ...grpc.CallOption) (*GetDevicesSummaryResponse, error)
	// GetGatewaysSummary returns an aggregated summary of the gateways.
	GetGatewaysSummary(ctx context.Context, in *GetGatewaysSummaryRequest, opts ...grpc.CallOption) (*GetGatewaysSummaryResponse, error)
	ShellCommand(ctx context.Context, in *ShellCommandRequest, opts ...grpc.CallOption) (*ShellCommandResponse, error)
}

InternalServiceClient is the client API for InternalService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewInternalServiceClient 

func NewInternalServiceClient(cc grpc.ClientConnInterface) InternalServiceClient

type InternalServiceServer 

type InternalServiceServer interface {
	// Log in a user
	Login(context.Context, *LoginRequest) (*LoginResponse, error)
	Quit(context.Context, *QuitRequest) (*emptypb.Empty, error)
	// Get the current user's profile
	Profile(context.Context, *emptypb.Empty) (*ProfileResponse, error)
	// Perform a global search.
	GlobalSearch(context.Context, *GlobalSearchRequest) (*GlobalSearchResponse, error)
	// CreateAPIKey creates the given API key.
	CreateAPIKey(context.Context, *CreateAPIKeyRequest) (*CreateAPIKeyResponse, error)
	// DeleteAPIKey deletes the API key.
	DeleteAPIKey(context.Context, *DeleteAPIKeyRequest) (*emptypb.Empty, error)
	// ListAPIKeys lists the available API keys.
	ListAPIKeys(context.Context, *ListAPIKeysRequest) (*ListAPIKeysResponse, error)
	// Get the global settings.
	Settings(context.Context, *emptypb.Empty) (*SettingsResponse, error)
	// OpenID Connect login.
	OpenIDConnectLogin(context.Context, *OpenIDConnectLoginRequest) (*OpenIDConnectLoginResponse, error)
	// GetDevicesSummary returns an aggregated summary of the devices.
	GetDevicesSummary(context.Context, *GetDevicesSummaryRequest) (*GetDevicesSummaryResponse, error)
	// GetGatewaysSummary returns an aggregated summary of the gateways.
	GetGatewaysSummary(context.Context, *GetGatewaysSummaryRequest) (*GetGatewaysSummaryResponse, error)
	ShellCommand(context.Context, *ShellCommandRequest) (*ShellCommandResponse, error)
}

InternalServiceServer is the server API for InternalService service.

type JoinEUIs 

type JoinEUIs struct {
	From                 string   `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	To                   string   `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*JoinEUIs) Descriptor 

func (*JoinEUIs) Descriptor() ([]byte, []int)

func (*JoinEUIs) GetFrom 

func (m *JoinEUIs) GetFrom() string

func (*JoinEUIs) GetTo 

func (m *JoinEUIs) GetTo() string

func (*JoinEUIs) ProtoMessage 

func (*JoinEUIs) ProtoMessage()

func (*JoinEUIs) Reset 

func (m *JoinEUIs) Reset()

func (*JoinEUIs) String 

func (m *JoinEUIs) String() string

func (*JoinEUIs) XXX_DiscardUnknown 

func (m *JoinEUIs) XXX_DiscardUnknown()

func (*JoinEUIs) XXX_Marshal 

func (m *JoinEUIs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*JoinEUIs) XXX_Merge 

func (m *JoinEUIs) XXX_Merge(src proto.Message)

func (*JoinEUIs) XXX_Size 

func (m *JoinEUIs) XXX_Size() int

func (*JoinEUIs) XXX_Unmarshal 

func (m *JoinEUIs) XXX_Unmarshal(b []byte) error

type ListAPIKeysRequest 

type ListAPIKeysRequest struct {
	// Max number of items to return.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Return only admin keys.
	IsAdmin bool `protobuf:"varint,3,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// Filter on organization ID.
	OrganizationId int64 `protobuf:"varint,4,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Filter on application ID.
	ApplicationId        int64    `protobuf:"varint,5,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListAPIKeysRequest) Descriptor 

func (*ListAPIKeysRequest) Descriptor() ([]byte, []int)

func (*ListAPIKeysRequest) GetApplicationId 

func (m *ListAPIKeysRequest) GetApplicationId() int64

func (*ListAPIKeysRequest) GetIsAdmin 

func (m *ListAPIKeysRequest) GetIsAdmin() bool

func (*ListAPIKeysRequest) GetLimit 

func (m *ListAPIKeysRequest) GetLimit() int64

func (*ListAPIKeysRequest) GetOffset 

func (m *ListAPIKeysRequest) GetOffset() int64

func (*ListAPIKeysRequest) GetOrganizationId 

func (m *ListAPIKeysRequest) GetOrganizationId() int64

func (*ListAPIKeysRequest) ProtoMessage 

func (*ListAPIKeysRequest) ProtoMessage()

func (*ListAPIKeysRequest) Reset 

func (m *ListAPIKeysRequest) Reset()

func (*ListAPIKeysRequest) String 

func (m *ListAPIKeysRequest) String() string

func (*ListAPIKeysRequest) XXX_DiscardUnknown 

func (m *ListAPIKeysRequest) XXX_DiscardUnknown()

func (*ListAPIKeysRequest) XXX_Marshal 

func (m *ListAPIKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListAPIKeysRequest) XXX_Merge 

func (m *ListAPIKeysRequest) XXX_Merge(src proto.Message)

func (*ListAPIKeysRequest) XXX_Size 

func (m *ListAPIKeysRequest) XXX_Size() int

func (*ListAPIKeysRequest) XXX_Unmarshal 

func (m *ListAPIKeysRequest) XXX_Unmarshal(b []byte) error

type ListAPIKeysResponse 

type ListAPIKeysResponse struct {
	// Total number of API keys.
	TotalCount           int64     `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*APIKey `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (*ListAPIKeysResponse) Descriptor 

func (*ListAPIKeysResponse) Descriptor() ([]byte, []int)

func (*ListAPIKeysResponse) GetResult 

func (m *ListAPIKeysResponse) GetResult() []*APIKey

func (*ListAPIKeysResponse) GetTotalCount 

func (m *ListAPIKeysResponse) GetTotalCount() int64

func (*ListAPIKeysResponse) ProtoMessage 

func (*ListAPIKeysResponse) ProtoMessage()

func (*ListAPIKeysResponse) Reset 

func (m *ListAPIKeysResponse) Reset()

func (*ListAPIKeysResponse) String 

func (m *ListAPIKeysResponse) String() string

func (*ListAPIKeysResponse) XXX_DiscardUnknown 

func (m *ListAPIKeysResponse) XXX_DiscardUnknown()

func (*ListAPIKeysResponse) XXX_Marshal 

func (m *ListAPIKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListAPIKeysResponse) XXX_Merge 

func (m *ListAPIKeysResponse) XXX_Merge(src proto.Message)

func (*ListAPIKeysResponse) XXX_Size 

func (m *ListAPIKeysResponse) XXX_Size() int

func (*ListAPIKeysResponse) XXX_Unmarshal 

func (m *ListAPIKeysResponse) XXX_Unmarshal(b []byte) error

type ListApplicationRequest 

type ListApplicationRequest struct {
	// Max number of applications to return in the result-test.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// ID of the organization to filter on.
	OrganizationId int64 `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Search on name (optional).
	Search               string   `protobuf:"bytes,4,opt,name=search,proto3" json:"search,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListApplicationRequest) Descriptor 

func (*ListApplicationRequest) Descriptor() ([]byte, []int)

func (*ListApplicationRequest) GetLimit 

func (m *ListApplicationRequest) GetLimit() int64

func (*ListApplicationRequest) GetOffset 

func (m *ListApplicationRequest) GetOffset() int64

func (*ListApplicationRequest) GetOrganizationId 

func (m *ListApplicationRequest) GetOrganizationId() int64

func (*ListApplicationRequest) GetSearch 

func (m *ListApplicationRequest) GetSearch() string

func (*ListApplicationRequest) ProtoMessage 

func (*ListApplicationRequest) ProtoMessage()

func (*ListApplicationRequest) Reset 

func (m *ListApplicationRequest) Reset()

func (*ListApplicationRequest) String 

func (m *ListApplicationRequest) String() string

func (*ListApplicationRequest) XXX_DiscardUnknown 

func (m *ListApplicationRequest) XXX_DiscardUnknown()

func (*ListApplicationRequest) XXX_Marshal 

func (m *ListApplicationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListApplicationRequest) XXX_Merge 

func (m *ListApplicationRequest) XXX_Merge(src proto.Message)

func (*ListApplicationRequest) XXX_Size 

func (m *ListApplicationRequest) XXX_Size() int

func (*ListApplicationRequest) XXX_Unmarshal 

func (m *ListApplicationRequest) XXX_Unmarshal(b []byte) error

type ListApplicationResponse 

type ListApplicationResponse struct {
	// Total number of applications available within the result-set.
	TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	// Applications within this result-set.
	Result               []*ApplicationListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*ListApplicationResponse) Descriptor 

func (*ListApplicationResponse) Descriptor() ([]byte, []int)

func (*ListApplicationResponse) GetResult 

func (m *ListApplicationResponse) GetResult() []*ApplicationListItem

func (*ListApplicationResponse) GetTotalCount 

func (m *ListApplicationResponse) GetTotalCount() int64

func (*ListApplicationResponse) ProtoMessage 

func (*ListApplicationResponse) ProtoMessage()

func (*ListApplicationResponse) Reset 

func (m *ListApplicationResponse) Reset()

func (*ListApplicationResponse) String 

func (m *ListApplicationResponse) String() string

func (*ListApplicationResponse) XXX_DiscardUnknown 

func (m *ListApplicationResponse) XXX_DiscardUnknown()

func (*ListApplicationResponse) XXX_Marshal 

func (m *ListApplicationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListApplicationResponse) XXX_Merge 

func (m *ListApplicationResponse) XXX_Merge(src proto.Message)

func (*ListApplicationResponse) XXX_Size 

func (m *ListApplicationResponse) XXX_Size() int

func (*ListApplicationResponse) XXX_Unmarshal 

func (m *ListApplicationResponse) XXX_Unmarshal(b []byte) error

type ListDeviceProfileRequest 

type ListDeviceProfileRequest struct {
	// Max number of items to return.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Organization id to filter on.
	OrganizationId int64 `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Application id to filter on.
	ApplicationId        int64    `protobuf:"varint,4,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListDeviceProfileRequest) Descriptor 

func (*ListDeviceProfileRequest) Descriptor() ([]byte, []int)

func (*ListDeviceProfileRequest) GetApplicationId 

func (m *ListDeviceProfileRequest) GetApplicationId() int64

func (*ListDeviceProfileRequest) GetLimit 

func (m *ListDeviceProfileRequest) GetLimit() int64

func (*ListDeviceProfileRequest) GetOffset 

func (m *ListDeviceProfileRequest) GetOffset() int64

func (*ListDeviceProfileRequest) GetOrganizationId 

func (m *ListDeviceProfileRequest) GetOrganizationId() int64

func (*ListDeviceProfileRequest) ProtoMessage 

func (*ListDeviceProfileRequest) ProtoMessage()

func (*ListDeviceProfileRequest) Reset 

func (m *ListDeviceProfileRequest) Reset()

func (*ListDeviceProfileRequest) String 

func (m *ListDeviceProfileRequest) String() string

func (*ListDeviceProfileRequest) XXX_DiscardUnknown 

func (m *ListDeviceProfileRequest) XXX_DiscardUnknown()

func (*ListDeviceProfileRequest) XXX_Marshal 

func (m *ListDeviceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListDeviceProfileRequest) XXX_Merge 

func (m *ListDeviceProfileRequest) XXX_Merge(src proto.Message)

func (*ListDeviceProfileRequest) XXX_Size 

func (m *ListDeviceProfileRequest) XXX_Size() int

func (*ListDeviceProfileRequest) XXX_Unmarshal 

func (m *ListDeviceProfileRequest) XXX_Unmarshal(b []byte) error

type ListDeviceProfileResponse 

type ListDeviceProfileResponse struct {
	// Total number of device-profiles.
	TotalCount           int64                    `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*DeviceProfileListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (*ListDeviceProfileResponse) Descriptor 

func (*ListDeviceProfileResponse) Descriptor() ([]byte, []int)

func (*ListDeviceProfileResponse) GetResult 

func (m *ListDeviceProfileResponse) GetResult() []*DeviceProfileListItem

func (*ListDeviceProfileResponse) GetTotalCount 

func (m *ListDeviceProfileResponse) GetTotalCount() int64

func (*ListDeviceProfileResponse) ProtoMessage 

func (*ListDeviceProfileResponse) ProtoMessage()

func (*ListDeviceProfileResponse) Reset 

func (m *ListDeviceProfileResponse) Reset()

func (*ListDeviceProfileResponse) String 

func (m *ListDeviceProfileResponse) String() string

func (*ListDeviceProfileResponse) XXX_DiscardUnknown 

func (m *ListDeviceProfileResponse) XXX_DiscardUnknown()

func (*ListDeviceProfileResponse) XXX_Marshal 

func (m *ListDeviceProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListDeviceProfileResponse) XXX_Merge 

func (m *ListDeviceProfileResponse) XXX_Merge(src proto.Message)

func (*ListDeviceProfileResponse) XXX_Size 

func (m *ListDeviceProfileResponse) XXX_Size() int

func (*ListDeviceProfileResponse) XXX_Unmarshal 

func (m *ListDeviceProfileResponse) XXX_Unmarshal(b []byte) error

type ListDeviceQueueItemsRequest 

type ListDeviceQueueItemsRequest struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Return only the count, not the result-set.
	CountOnly            bool     `protobuf:"varint,2,opt,name=count_only,json=countOnly,proto3" json:"count_only,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListDeviceQueueItemsRequest) Descriptor 

func (*ListDeviceQueueItemsRequest) Descriptor() ([]byte, []int)

func (*ListDeviceQueueItemsRequest) GetCountOnly 

func (m *ListDeviceQueueItemsRequest) GetCountOnly() bool

func (*ListDeviceQueueItemsRequest) GetDevEui 

func (m *ListDeviceQueueItemsRequest) GetDevEui() string

func (*ListDeviceQueueItemsRequest) ProtoMessage 

func (*ListDeviceQueueItemsRequest) ProtoMessage()

func (*ListDeviceQueueItemsRequest) Reset 

func (m *ListDeviceQueueItemsRequest) Reset()

func (*ListDeviceQueueItemsRequest) String 

func (m *ListDeviceQueueItemsRequest) String() string

func (*ListDeviceQueueItemsRequest) XXX_DiscardUnknown 

func (m *ListDeviceQueueItemsRequest) XXX_DiscardUnknown()

func (*ListDeviceQueueItemsRequest) XXX_Marshal 

func (m *ListDeviceQueueItemsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListDeviceQueueItemsRequest) XXX_Merge 

func (m *ListDeviceQueueItemsRequest) XXX_Merge(src proto.Message)

func (*ListDeviceQueueItemsRequest) XXX_Size 

func (m *ListDeviceQueueItemsRequest) XXX_Size() int

func (*ListDeviceQueueItemsRequest) XXX_Unmarshal 

func (m *ListDeviceQueueItemsRequest) XXX_Unmarshal(b []byte) error

type ListDeviceQueueItemsResponse 

type ListDeviceQueueItemsResponse struct {
	// The device queue items.
	DeviceQueueItems []*DeviceQueueItem `protobuf:"bytes,1,rep,name=device_queue_items,json=deviceQueueItems,proto3" json:"device_queue_items,omitempty"`
	// Total number of items in the queue.
	TotalCount           uint32   `protobuf:"varint,2,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListDeviceQueueItemsResponse) Descriptor 

func (*ListDeviceQueueItemsResponse) Descriptor() ([]byte, []int)

func (*ListDeviceQueueItemsResponse) GetDeviceQueueItems 

func (m *ListDeviceQueueItemsResponse) GetDeviceQueueItems() []*DeviceQueueItem

func (*ListDeviceQueueItemsResponse) GetTotalCount 

func (m *ListDeviceQueueItemsResponse) GetTotalCount() uint32

func (*ListDeviceQueueItemsResponse) ProtoMessage 

func (*ListDeviceQueueItemsResponse) ProtoMessage()

func (*ListDeviceQueueItemsResponse) Reset 

func (m *ListDeviceQueueItemsResponse) Reset()

func (*ListDeviceQueueItemsResponse) String 

func (m *ListDeviceQueueItemsResponse) String() string

func (*ListDeviceQueueItemsResponse) XXX_DiscardUnknown 

func (m *ListDeviceQueueItemsResponse) XXX_DiscardUnknown()

func (*ListDeviceQueueItemsResponse) XXX_Marshal 

func (m *ListDeviceQueueItemsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListDeviceQueueItemsResponse) XXX_Merge 

func (m *ListDeviceQueueItemsResponse) XXX_Merge(src proto.Message)

func (*ListDeviceQueueItemsResponse) XXX_Size 

func (m *ListDeviceQueueItemsResponse) XXX_Size() int

func (*ListDeviceQueueItemsResponse) XXX_Unmarshal 

func (m *ListDeviceQueueItemsResponse) XXX_Unmarshal(b []byte) error

type ListDeviceRequest 

type ListDeviceRequest struct {
	// Max number of devices to return in the result-set.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Application ID to filter on.
	ApplicationId int64 `protobuf:"varint,3,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Search on name or DevEUI.
	Search string `protobuf:"bytes,4,opt,name=search,proto3" json:"search,omitempty"`
	// Multicast-group ID to filter on (string formatted UUID).
	MulticastGroupId string `protobuf:"bytes,5,opt,name=multicast_group_id,json=multicastGroupID,proto3" json:"multicast_group_id,omitempty"`
	// Service-profile ID to filter on (string formatted UUID).
	ServiceProfileId string `protobuf:"bytes,6,opt,name=service_profile_id,json=serviceProfileID,proto3" json:"service_profile_id,omitempty"`
	// Tags to filter on.
	Tags                 map[string]string `` /* 149-byte string literal not displayed */
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*ListDeviceRequest) Descriptor 

func (*ListDeviceRequest) Descriptor() ([]byte, []int)

func (*ListDeviceRequest) GetApplicationId 

func (m *ListDeviceRequest) GetApplicationId() int64

func (*ListDeviceRequest) GetLimit 

func (m *ListDeviceRequest) GetLimit() int64

func (*ListDeviceRequest) GetMulticastGroupId 

func (m *ListDeviceRequest) GetMulticastGroupId() string

func (*ListDeviceRequest) GetOffset 

func (m *ListDeviceRequest) GetOffset() int64

func (*ListDeviceRequest) GetSearch 

func (m *ListDeviceRequest) GetSearch() string

func (*ListDeviceRequest) GetServiceProfileId 

func (m *ListDeviceRequest) GetServiceProfileId() string

func (*ListDeviceRequest) GetTags 

func (m *ListDeviceRequest) GetTags() map[string]string

func (*ListDeviceRequest) ProtoMessage 

func (*ListDeviceRequest) ProtoMessage()

func (*ListDeviceRequest) Reset 

func (m *ListDeviceRequest) Reset()

func (*ListDeviceRequest) String 

func (m *ListDeviceRequest) String() string

func (*ListDeviceRequest) XXX_DiscardUnknown 

func (m *ListDeviceRequest) XXX_DiscardUnknown()

func (*ListDeviceRequest) XXX_Marshal 

func (m *ListDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListDeviceRequest) XXX_Merge 

func (m *ListDeviceRequest) XXX_Merge(src proto.Message)

func (*ListDeviceRequest) XXX_Size 

func (m *ListDeviceRequest) XXX_Size() int

func (*ListDeviceRequest) XXX_Unmarshal 

func (m *ListDeviceRequest) XXX_Unmarshal(b []byte) error

type ListDeviceResponse 

type ListDeviceResponse struct {
	// Total number of devices available within the result-set.
	TotalCount int64                  `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Timestamp  *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Devices within this result-set.
	Result               []*DeviceListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*ListDeviceResponse) Descriptor 

func (*ListDeviceResponse) Descriptor() ([]byte, []int)

func (*ListDeviceResponse) GetResult 

func (m *ListDeviceResponse) GetResult() []*DeviceListItem

func (*ListDeviceResponse) GetTimestamp 

func (m *ListDeviceResponse) GetTimestamp() *timestamppb.Timestamp

func (*ListDeviceResponse) GetTotalCount 

func (m *ListDeviceResponse) GetTotalCount() int64

func (*ListDeviceResponse) ProtoMessage 

func (*ListDeviceResponse) ProtoMessage()

func (*ListDeviceResponse) Reset 

func (m *ListDeviceResponse) Reset()

func (*ListDeviceResponse) String 

func (m *ListDeviceResponse) String() string

func (*ListDeviceResponse) XXX_DiscardUnknown 

func (m *ListDeviceResponse) XXX_DiscardUnknown()

func (*ListDeviceResponse) XXX_Marshal 

func (m *ListDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListDeviceResponse) XXX_Merge 

func (m *ListDeviceResponse) XXX_Merge(src proto.Message)

func (*ListDeviceResponse) XXX_Size 

func (m *ListDeviceResponse) XXX_Size() int

func (*ListDeviceResponse) XXX_Unmarshal 

func (m *ListDeviceResponse) XXX_Unmarshal(b []byte) error

type ListFUOTADeploymentDevicesRequest 

type ListFUOTADeploymentDevicesRequest struct {
	// ID of the deployment (string formatted UUID).
	// This value will be automatically assigned on create.
	FuotaDeploymentId string `protobuf:"bytes,1,opt,name=fuota_deployment_id,json=fuotaDeploymentID,proto3" json:"fuota_deployment_id,omitempty"`
	// Max number of items to return.
	Limit int64 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset               int64    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListFUOTADeploymentDevicesRequest) Descriptor 

func (*ListFUOTADeploymentDevicesRequest) Descriptor() ([]byte, []int)

func (*ListFUOTADeploymentDevicesRequest) GetFuotaDeploymentId 

func (m *ListFUOTADeploymentDevicesRequest) GetFuotaDeploymentId() string

func (*ListFUOTADeploymentDevicesRequest) GetLimit 

func (m *ListFUOTADeploymentDevicesRequest) GetLimit() int64

func (*ListFUOTADeploymentDevicesRequest) GetOffset 

func (m *ListFUOTADeploymentDevicesRequest) GetOffset() int64

func (*ListFUOTADeploymentDevicesRequest) ProtoMessage 

func (*ListFUOTADeploymentDevicesRequest) ProtoMessage()

func (*ListFUOTADeploymentDevicesRequest) Reset 

func (m *ListFUOTADeploymentDevicesRequest) Reset()

func (*ListFUOTADeploymentDevicesRequest) String 

func (m *ListFUOTADeploymentDevicesRequest) String() string

func (*ListFUOTADeploymentDevicesRequest) XXX_DiscardUnknown 

func (m *ListFUOTADeploymentDevicesRequest) XXX_DiscardUnknown()

func (*ListFUOTADeploymentDevicesRequest) XXX_Marshal 

func (m *ListFUOTADeploymentDevicesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListFUOTADeploymentDevicesRequest) XXX_Merge 

func (m *ListFUOTADeploymentDevicesRequest) XXX_Merge(src proto.Message)

func (*ListFUOTADeploymentDevicesRequest) XXX_Size 

func (m *ListFUOTADeploymentDevicesRequest) XXX_Size() int

func (*ListFUOTADeploymentDevicesRequest) XXX_Unmarshal 

func (m *ListFUOTADeploymentDevicesRequest) XXX_Unmarshal(b []byte) error

type ListFUOTADeploymentDevicesResponse 

type ListFUOTADeploymentDevicesResponse struct {
	// Total number of devices for the FUOTA deployment.
	TotalCount           int64                            `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*FUOTADeploymentDeviceListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (*ListFUOTADeploymentDevicesResponse) Descriptor 

func (*ListFUOTADeploymentDevicesResponse) Descriptor() ([]byte, []int)

func (*ListFUOTADeploymentDevicesResponse) GetResult 

func (m *ListFUOTADeploymentDevicesResponse) GetResult() []*FUOTADeploymentDeviceListItem

func (*ListFUOTADeploymentDevicesResponse) GetTotalCount 

func (m *ListFUOTADeploymentDevicesResponse) GetTotalCount() int64

func (*ListFUOTADeploymentDevicesResponse) ProtoMessage 

func (*ListFUOTADeploymentDevicesResponse) ProtoMessage()

func (*ListFUOTADeploymentDevicesResponse) Reset 

func (m *ListFUOTADeploymentDevicesResponse) Reset()

func (*ListFUOTADeploymentDevicesResponse) String 

func (m *ListFUOTADeploymentDevicesResponse) String() string

func (*ListFUOTADeploymentDevicesResponse) XXX_DiscardUnknown 

func (m *ListFUOTADeploymentDevicesResponse) XXX_DiscardUnknown()

func (*ListFUOTADeploymentDevicesResponse) XXX_Marshal 

func (m *ListFUOTADeploymentDevicesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListFUOTADeploymentDevicesResponse) XXX_Merge 

func (m *ListFUOTADeploymentDevicesResponse) XXX_Merge(src proto.Message)

func (*ListFUOTADeploymentDevicesResponse) XXX_Size 

func (m *ListFUOTADeploymentDevicesResponse) XXX_Size() int

func (*ListFUOTADeploymentDevicesResponse) XXX_Unmarshal 

func (m *ListFUOTADeploymentDevicesResponse) XXX_Unmarshal(b []byte) error

type ListFUOTADeploymentRequest 

type ListFUOTADeploymentRequest struct {
	// Max number of deployments to return in the result-set.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Application ID to filter on (optional).
	ApplicationId int64 `protobuf:"varint,3,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Device EUI (HEX encoded) (optional).
	DevEui               string   `protobuf:"bytes,4,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListFUOTADeploymentRequest) Descriptor 

func (*ListFUOTADeploymentRequest) Descriptor() ([]byte, []int)

func (*ListFUOTADeploymentRequest) GetApplicationId 

func (m *ListFUOTADeploymentRequest) GetApplicationId() int64

func (*ListFUOTADeploymentRequest) GetDevEui 

func (m *ListFUOTADeploymentRequest) GetDevEui() string

func (*ListFUOTADeploymentRequest) GetLimit 

func (m *ListFUOTADeploymentRequest) GetLimit() int64

func (*ListFUOTADeploymentRequest) GetOffset 

func (m *ListFUOTADeploymentRequest) GetOffset() int64

func (*ListFUOTADeploymentRequest) ProtoMessage 

func (*ListFUOTADeploymentRequest) ProtoMessage()

func (*ListFUOTADeploymentRequest) Reset 

func (m *ListFUOTADeploymentRequest) Reset()

func (*ListFUOTADeploymentRequest) String 

func (m *ListFUOTADeploymentRequest) String() string

func (*ListFUOTADeploymentRequest) XXX_DiscardUnknown 

func (m *ListFUOTADeploymentRequest) XXX_DiscardUnknown()

func (*ListFUOTADeploymentRequest) XXX_Marshal 

func (m *ListFUOTADeploymentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListFUOTADeploymentRequest) XXX_Merge 

func (m *ListFUOTADeploymentRequest) XXX_Merge(src proto.Message)

func (*ListFUOTADeploymentRequest) XXX_Size 

func (m *ListFUOTADeploymentRequest) XXX_Size() int

func (*ListFUOTADeploymentRequest) XXX_Unmarshal 

func (m *ListFUOTADeploymentRequest) XXX_Unmarshal(b []byte) error

type ListFUOTADeploymentResponse 

type ListFUOTADeploymentResponse struct {
	// Total number of deployments available within the result-set.
	TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	// Deployments within this result-set.
	Result               []*FUOTADeploymentListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (*ListFUOTADeploymentResponse) Descriptor 

func (*ListFUOTADeploymentResponse) Descriptor() ([]byte, []int)

func (*ListFUOTADeploymentResponse) GetResult 

func (m *ListFUOTADeploymentResponse) GetResult() []*FUOTADeploymentListItem

func (*ListFUOTADeploymentResponse) GetTotalCount 

func (m *ListFUOTADeploymentResponse) GetTotalCount() int64

func (*ListFUOTADeploymentResponse) ProtoMessage 

func (*ListFUOTADeploymentResponse) ProtoMessage()

func (*ListFUOTADeploymentResponse) Reset 

func (m *ListFUOTADeploymentResponse) Reset()

func (*ListFUOTADeploymentResponse) String 

func (m *ListFUOTADeploymentResponse) String() string

func (*ListFUOTADeploymentResponse) XXX_DiscardUnknown 

func (m *ListFUOTADeploymentResponse) XXX_DiscardUnknown()

func (*ListFUOTADeploymentResponse) XXX_Marshal 

func (m *ListFUOTADeploymentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListFUOTADeploymentResponse) XXX_Merge 

func (m *ListFUOTADeploymentResponse) XXX_Merge(src proto.Message)

func (*ListFUOTADeploymentResponse) XXX_Size 

func (m *ListFUOTADeploymentResponse) XXX_Size() int

func (*ListFUOTADeploymentResponse) XXX_Unmarshal 

func (m *ListFUOTADeploymentResponse) XXX_Unmarshal(b []byte) error

type ListGatewayProfilesRequest 

type ListGatewayProfilesRequest struct {
	// Max number of items to return.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Network-server ID to filter on (optional).
	NetworkServerId      int64    `protobuf:"varint,3,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListGatewayProfilesRequest) Descriptor 

func (*ListGatewayProfilesRequest) Descriptor() ([]byte, []int)

func (*ListGatewayProfilesRequest) GetLimit 

func (m *ListGatewayProfilesRequest) GetLimit() int64

func (*ListGatewayProfilesRequest) GetNetworkServerId 

func (m *ListGatewayProfilesRequest) GetNetworkServerId() int64

func (*ListGatewayProfilesRequest) GetOffset 

func (m *ListGatewayProfilesRequest) GetOffset() int64

func (*ListGatewayProfilesRequest) ProtoMessage 

func (*ListGatewayProfilesRequest) ProtoMessage()

func (*ListGatewayProfilesRequest) Reset 

func (m *ListGatewayProfilesRequest) Reset()

func (*ListGatewayProfilesRequest) String 

func (m *ListGatewayProfilesRequest) String() string

func (*ListGatewayProfilesRequest) XXX_DiscardUnknown 

func (m *ListGatewayProfilesRequest) XXX_DiscardUnknown()

func (*ListGatewayProfilesRequest) XXX_Marshal 

func (m *ListGatewayProfilesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListGatewayProfilesRequest) XXX_Merge 

func (m *ListGatewayProfilesRequest) XXX_Merge(src proto.Message)

func (*ListGatewayProfilesRequest) XXX_Size 

func (m *ListGatewayProfilesRequest) XXX_Size() int

func (*ListGatewayProfilesRequest) XXX_Unmarshal 

func (m *ListGatewayProfilesRequest) XXX_Unmarshal(b []byte) error

type ListGatewayProfilesResponse 

type ListGatewayProfilesResponse struct {
	// Total number of gateway-profiles.
	TotalCount           int64                     `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*GatewayProfileListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (*ListGatewayProfilesResponse) Descriptor 

func (*ListGatewayProfilesResponse) Descriptor() ([]byte, []int)

func (*ListGatewayProfilesResponse) GetResult 

func (m *ListGatewayProfilesResponse) GetResult() []*GatewayProfileListItem

func (*ListGatewayProfilesResponse) GetTotalCount 

func (m *ListGatewayProfilesResponse) GetTotalCount() int64

func (*ListGatewayProfilesResponse) ProtoMessage 

func (*ListGatewayProfilesResponse) ProtoMessage()

func (*ListGatewayProfilesResponse) Reset 

func (m *ListGatewayProfilesResponse) Reset()

func (*ListGatewayProfilesResponse) String 

func (m *ListGatewayProfilesResponse) String() string

func (*ListGatewayProfilesResponse) XXX_DiscardUnknown 

func (m *ListGatewayProfilesResponse) XXX_DiscardUnknown()

func (*ListGatewayProfilesResponse) XXX_Marshal 

func (m *ListGatewayProfilesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListGatewayProfilesResponse) XXX_Merge 

func (m *ListGatewayProfilesResponse) XXX_Merge(src proto.Message)

func (*ListGatewayProfilesResponse) XXX_Size 

func (m *ListGatewayProfilesResponse) XXX_Size() int

func (*ListGatewayProfilesResponse) XXX_Unmarshal 

func (m *ListGatewayProfilesResponse) XXX_Unmarshal(b []byte) error

type ListGatewayRequest 

type ListGatewayRequest struct {
	// Max number of nodes to return in the result-set.
	Limit int32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset of the result-set (for pagination).
	Offset int32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// ID of the organization for which to filter on, when left blank the
	// response will return all gateways to which the user has access to.
	OrganizationId int64 `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Search on name or gateway MAC (optional).
	Search               string   `protobuf:"bytes,4,opt,name=search,proto3" json:"search,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListGatewayRequest) Descriptor 

func (*ListGatewayRequest) Descriptor() ([]byte, []int)

func (*ListGatewayRequest) GetLimit 

func (m *ListGatewayRequest) GetLimit() int32

func (*ListGatewayRequest) GetOffset 

func (m *ListGatewayRequest) GetOffset() int32

func (*ListGatewayRequest) GetOrganizationId 

func (m *ListGatewayRequest) GetOrganizationId() int64

func (*ListGatewayRequest) GetSearch 

func (m *ListGatewayRequest) GetSearch() string

func (*ListGatewayRequest) ProtoMessage 

func (*ListGatewayRequest) ProtoMessage()

func (*ListGatewayRequest) Reset 

func (m *ListGatewayRequest) Reset()

func (*ListGatewayRequest) String 

func (m *ListGatewayRequest) String() string

func (*ListGatewayRequest) XXX_DiscardUnknown 

func (m *ListGatewayRequest) XXX_DiscardUnknown()

func (*ListGatewayRequest) XXX_Marshal 

func (m *ListGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListGatewayRequest) XXX_Merge 

func (m *ListGatewayRequest) XXX_Merge(src proto.Message)

func (*ListGatewayRequest) XXX_Size 

func (m *ListGatewayRequest) XXX_Size() int

func (*ListGatewayRequest) XXX_Unmarshal 

func (m *ListGatewayRequest) XXX_Unmarshal(b []byte) error

type ListGatewayResponse 

type ListGatewayResponse struct {
	// Total number of nodes available within the result-set.
	TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	// Nodes within this result-set.
	Result               []*GatewayListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*ListGatewayResponse) Descriptor 

func (*ListGatewayResponse) Descriptor() ([]byte, []int)

func (*ListGatewayResponse) GetResult 

func (m *ListGatewayResponse) GetResult() []*GatewayListItem

func (*ListGatewayResponse) GetTotalCount 

func (m *ListGatewayResponse) GetTotalCount() int64

func (*ListGatewayResponse) ProtoMessage 

func (*ListGatewayResponse) ProtoMessage()

func (*ListGatewayResponse) Reset 

func (m *ListGatewayResponse) Reset()

func (*ListGatewayResponse) String 

func (m *ListGatewayResponse) String() string

func (*ListGatewayResponse) XXX_DiscardUnknown 

func (m *ListGatewayResponse) XXX_DiscardUnknown()

func (*ListGatewayResponse) XXX_Marshal 

func (m *ListGatewayResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListGatewayResponse) XXX_Merge 

func (m *ListGatewayResponse) XXX_Merge(src proto.Message)

func (*ListGatewayResponse) XXX_Size 

func (m *ListGatewayResponse) XXX_Size() int

func (*ListGatewayResponse) XXX_Unmarshal 

func (m *ListGatewayResponse) XXX_Unmarshal(b []byte) error

type ListIntegrationRequest 

type ListIntegrationRequest struct {
	// The id of the application.
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListIntegrationRequest) Descriptor 

func (*ListIntegrationRequest) Descriptor() ([]byte, []int)

func (*ListIntegrationRequest) GetApplicationId 

func (m *ListIntegrationRequest) GetApplicationId() int64

func (*ListIntegrationRequest) ProtoMessage 

func (*ListIntegrationRequest) ProtoMessage()

func (*ListIntegrationRequest) Reset 

func (m *ListIntegrationRequest) Reset()

func (*ListIntegrationRequest) String 

func (m *ListIntegrationRequest) String() string

func (*ListIntegrationRequest) XXX_DiscardUnknown 

func (m *ListIntegrationRequest) XXX_DiscardUnknown()

func (*ListIntegrationRequest) XXX_Marshal 

func (m *ListIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListIntegrationRequest) XXX_Merge 

func (m *ListIntegrationRequest) XXX_Merge(src proto.Message)

func (*ListIntegrationRequest) XXX_Size 

func (m *ListIntegrationRequest) XXX_Size() int

func (*ListIntegrationRequest) XXX_Unmarshal 

func (m *ListIntegrationRequest) XXX_Unmarshal(b []byte) error

type ListIntegrationResponse 

type ListIntegrationResponse struct {
	// Total number of integrations available within the result-set.
	TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	// Integrations within result-set.
	Result               []*IntegrationListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*ListIntegrationResponse) Descriptor 

func (*ListIntegrationResponse) Descriptor() ([]byte, []int)

func (*ListIntegrationResponse) GetResult 

func (m *ListIntegrationResponse) GetResult() []*IntegrationListItem

func (*ListIntegrationResponse) GetTotalCount 

func (m *ListIntegrationResponse) GetTotalCount() int64

func (*ListIntegrationResponse) ProtoMessage 

func (*ListIntegrationResponse) ProtoMessage()

func (*ListIntegrationResponse) Reset 

func (m *ListIntegrationResponse) Reset()

func (*ListIntegrationResponse) String 

func (m *ListIntegrationResponse) String() string

func (*ListIntegrationResponse) XXX_DiscardUnknown 

func (m *ListIntegrationResponse) XXX_DiscardUnknown()

func (*ListIntegrationResponse) XXX_Marshal 

func (m *ListIntegrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListIntegrationResponse) XXX_Merge 

func (m *ListIntegrationResponse) XXX_Merge(src proto.Message)

func (*ListIntegrationResponse) XXX_Size 

func (m *ListIntegrationResponse) XXX_Size() int

func (*ListIntegrationResponse) XXX_Unmarshal 

func (m *ListIntegrationResponse) XXX_Unmarshal(b []byte) error

type ListMulticastGroupQueueItemsRequest 

type ListMulticastGroupQueueItemsRequest struct {
	// Multicast-group ID (string formatted UUID).
	MulticastGroupId     string   `protobuf:"bytes,1,opt,name=multicast_group_id,json=multicastGroupID,proto3" json:"multicast_group_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListMulticastGroupQueueItemsRequest) Descriptor 

func (*ListMulticastGroupQueueItemsRequest) Descriptor() ([]byte, []int)

func (*ListMulticastGroupQueueItemsRequest) GetMulticastGroupId 

func (m *ListMulticastGroupQueueItemsRequest) GetMulticastGroupId() string

func (*ListMulticastGroupQueueItemsRequest) ProtoMessage 

func (*ListMulticastGroupQueueItemsRequest) ProtoMessage()

func (*ListMulticastGroupQueueItemsRequest) Reset 

func (m *ListMulticastGroupQueueItemsRequest) Reset()

func (*ListMulticastGroupQueueItemsRequest) String 

func (m *ListMulticastGroupQueueItemsRequest) String() string

func (*ListMulticastGroupQueueItemsRequest) XXX_DiscardUnknown 

func (m *ListMulticastGroupQueueItemsRequest) XXX_DiscardUnknown()

func (*ListMulticastGroupQueueItemsRequest) XXX_Marshal 

func (m *ListMulticastGroupQueueItemsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListMulticastGroupQueueItemsRequest) XXX_Merge 

func (m *ListMulticastGroupQueueItemsRequest) XXX_Merge(src proto.Message)

func (*ListMulticastGroupQueueItemsRequest) XXX_Size 

func (m *ListMulticastGroupQueueItemsRequest) XXX_Size() int

func (*ListMulticastGroupQueueItemsRequest) XXX_Unmarshal 

func (m *ListMulticastGroupQueueItemsRequest) XXX_Unmarshal(b []byte) error

type ListMulticastGroupQueueItemsResponse 

type ListMulticastGroupQueueItemsResponse struct {
	MulticastQueueItems  []*MulticastQueueItem `protobuf:"bytes,1,rep,name=multicast_queue_items,json=multicastQueueItems,proto3" json:"multicast_queue_items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*ListMulticastGroupQueueItemsResponse) Descriptor 

func (*ListMulticastGroupQueueItemsResponse) Descriptor() ([]byte, []int)

func (*ListMulticastGroupQueueItemsResponse) GetMulticastQueueItems 

func (m *ListMulticastGroupQueueItemsResponse) GetMulticastQueueItems() []*MulticastQueueItem

func (*ListMulticastGroupQueueItemsResponse) ProtoMessage 

func (*ListMulticastGroupQueueItemsResponse) ProtoMessage()

func (*ListMulticastGroupQueueItemsResponse) Reset 

func (m *ListMulticastGroupQueueItemsResponse) Reset()

func (*ListMulticastGroupQueueItemsResponse) String 

func (m *ListMulticastGroupQueueItemsResponse) String() string

func (*ListMulticastGroupQueueItemsResponse) XXX_DiscardUnknown 

func (m *ListMulticastGroupQueueItemsResponse) XXX_DiscardUnknown()

func (*ListMulticastGroupQueueItemsResponse) XXX_Marshal 

func (m *ListMulticastGroupQueueItemsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListMulticastGroupQueueItemsResponse) XXX_Merge 

func (m *ListMulticastGroupQueueItemsResponse) XXX_Merge(src proto.Message)

func (*ListMulticastGroupQueueItemsResponse) XXX_Size 

func (m *ListMulticastGroupQueueItemsResponse) XXX_Size() int

func (*ListMulticastGroupQueueItemsResponse) XXX_Unmarshal 

func (m *ListMulticastGroupQueueItemsResponse) XXX_Unmarshal(b []byte) error

type ListMulticastGroupRequest 

type ListMulticastGroupRequest struct {
	// Max number of items to return.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Organization id to filter on.
	OrganizationId int64 `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Device EUI (HEX encoded string) to filter on.
	DevEui string `protobuf:"bytes,4,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	// Service-profile ID to filter on.
	ServiceProfileId string `protobuf:"bytes,5,opt,name=service_profile_id,json=serviceProfileID,proto3" json:"service_profile_id,omitempty"`
	// Search can be used to search on the multicast-group name.
	Search               string   `protobuf:"bytes,6,opt,name=search,proto3" json:"search,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListMulticastGroupRequest) Descriptor 

func (*ListMulticastGroupRequest) Descriptor() ([]byte, []int)

func (*ListMulticastGroupRequest) GetDevEui 

func (m *ListMulticastGroupRequest) GetDevEui() string

func (*ListMulticastGroupRequest) GetLimit 

func (m *ListMulticastGroupRequest) GetLimit() int64

func (*ListMulticastGroupRequest) GetOffset 

func (m *ListMulticastGroupRequest) GetOffset() int64

func (*ListMulticastGroupRequest) GetOrganizationId 

func (m *ListMulticastGroupRequest) GetOrganizationId() int64

func (*ListMulticastGroupRequest) GetSearch 

func (m *ListMulticastGroupRequest) GetSearch() string

func (*ListMulticastGroupRequest) GetServiceProfileId 

func (m *ListMulticastGroupRequest) GetServiceProfileId() string

func (*ListMulticastGroupRequest) ProtoMessage 

func (*ListMulticastGroupRequest) ProtoMessage()

func (*ListMulticastGroupRequest) Reset 

func (m *ListMulticastGroupRequest) Reset()

func (*ListMulticastGroupRequest) String 

func (m *ListMulticastGroupRequest) String() string

func (*ListMulticastGroupRequest) XXX_DiscardUnknown 

func (m *ListMulticastGroupRequest) XXX_DiscardUnknown()

func (*ListMulticastGroupRequest) XXX_Marshal 

func (m *ListMulticastGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListMulticastGroupRequest) XXX_Merge 

func (m *ListMulticastGroupRequest) XXX_Merge(src proto.Message)

func (*ListMulticastGroupRequest) XXX_Size 

func (m *ListMulticastGroupRequest) XXX_Size() int

func (*ListMulticastGroupRequest) XXX_Unmarshal 

func (m *ListMulticastGroupRequest) XXX_Unmarshal(b []byte) error

type ListMulticastGroupResponse 

type ListMulticastGroupResponse struct {
	// Total number of multicast-groups.
	TotalCount           int64                     `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*MulticastGroupListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (*ListMulticastGroupResponse) Descriptor 

func (*ListMulticastGroupResponse) Descriptor() ([]byte, []int)

func (*ListMulticastGroupResponse) GetResult 

func (m *ListMulticastGroupResponse) GetResult() []*MulticastGroupListItem

func (*ListMulticastGroupResponse) GetTotalCount 

func (m *ListMulticastGroupResponse) GetTotalCount() int64

func (*ListMulticastGroupResponse) ProtoMessage 

func (*ListMulticastGroupResponse) ProtoMessage()

func (*ListMulticastGroupResponse) Reset 

func (m *ListMulticastGroupResponse) Reset()

func (*ListMulticastGroupResponse) String 

func (m *ListMulticastGroupResponse) String() string

func (*ListMulticastGroupResponse) XXX_DiscardUnknown 

func (m *ListMulticastGroupResponse) XXX_DiscardUnknown()

func (*ListMulticastGroupResponse) XXX_Marshal 

func (m *ListMulticastGroupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListMulticastGroupResponse) XXX_Merge 

func (m *ListMulticastGroupResponse) XXX_Merge(src proto.Message)

func (*ListMulticastGroupResponse) XXX_Size 

func (m *ListMulticastGroupResponse) XXX_Size() int

func (*ListMulticastGroupResponse) XXX_Unmarshal 

func (m *ListMulticastGroupResponse) XXX_Unmarshal(b []byte) error

type ListNetworkServerRequest 

type ListNetworkServerRequest struct {
	// Max number of items to return.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Organization id to filter on.
	OrganizationId       int64    `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListNetworkServerRequest) Descriptor 

func (*ListNetworkServerRequest) Descriptor() ([]byte, []int)

func (*ListNetworkServerRequest) GetLimit 

func (m *ListNetworkServerRequest) GetLimit() int64

func (*ListNetworkServerRequest) GetOffset 

func (m *ListNetworkServerRequest) GetOffset() int64

func (*ListNetworkServerRequest) GetOrganizationId 

func (m *ListNetworkServerRequest) GetOrganizationId() int64

func (*ListNetworkServerRequest) ProtoMessage 

func (*ListNetworkServerRequest) ProtoMessage()

func (*ListNetworkServerRequest) Reset 

func (m *ListNetworkServerRequest) Reset()

func (*ListNetworkServerRequest) String 

func (m *ListNetworkServerRequest) String() string

func (*ListNetworkServerRequest) XXX_DiscardUnknown 

func (m *ListNetworkServerRequest) XXX_DiscardUnknown()

func (*ListNetworkServerRequest) XXX_Marshal 

func (m *ListNetworkServerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListNetworkServerRequest) XXX_Merge 

func (m *ListNetworkServerRequest) XXX_Merge(src proto.Message)

func (*ListNetworkServerRequest) XXX_Size 

func (m *ListNetworkServerRequest) XXX_Size() int

func (*ListNetworkServerRequest) XXX_Unmarshal 

func (m *ListNetworkServerRequest) XXX_Unmarshal(b []byte) error

type ListNetworkServerResponse 

type ListNetworkServerResponse struct {
	// Total number of network-servers.
	TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	// Network-servers within the result-set.
	Result               []*NetworkServerListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (*ListNetworkServerResponse) Descriptor 

func (*ListNetworkServerResponse) Descriptor() ([]byte, []int)

func (*ListNetworkServerResponse) GetResult 

func (m *ListNetworkServerResponse) GetResult() []*NetworkServerListItem

func (*ListNetworkServerResponse) GetTotalCount 

func (m *ListNetworkServerResponse) GetTotalCount() int64

func (*ListNetworkServerResponse) ProtoMessage 

func (*ListNetworkServerResponse) ProtoMessage()

func (*ListNetworkServerResponse) Reset 

func (m *ListNetworkServerResponse) Reset()

func (*ListNetworkServerResponse) String 

func (m *ListNetworkServerResponse) String() string

func (*ListNetworkServerResponse) XXX_DiscardUnknown 

func (m *ListNetworkServerResponse) XXX_DiscardUnknown()

func (*ListNetworkServerResponse) XXX_Marshal 

func (m *ListNetworkServerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListNetworkServerResponse) XXX_Merge 

func (m *ListNetworkServerResponse) XXX_Merge(src proto.Message)

func (*ListNetworkServerResponse) XXX_Size 

func (m *ListNetworkServerResponse) XXX_Size() int

func (*ListNetworkServerResponse) XXX_Unmarshal 

func (m *ListNetworkServerResponse) XXX_Unmarshal(b []byte) error

type ListOTPResponse 

type ListOTPResponse struct {
	Blocks               []*OTPBLOCK `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*ListOTPResponse) Descriptor 

func (*ListOTPResponse) Descriptor() ([]byte, []int)

func (*ListOTPResponse) GetBlocks 

func (m *ListOTPResponse) GetBlocks() []*OTPBLOCK

func (*ListOTPResponse) ProtoMessage 

func (*ListOTPResponse) ProtoMessage()

func (*ListOTPResponse) Reset 

func (m *ListOTPResponse) Reset()

func (*ListOTPResponse) String 

func (m *ListOTPResponse) String() string

func (*ListOTPResponse) XXX_DiscardUnknown 

func (m *ListOTPResponse) XXX_DiscardUnknown()

func (*ListOTPResponse) XXX_Marshal 

func (m *ListOTPResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListOTPResponse) XXX_Merge 

func (m *ListOTPResponse) XXX_Merge(src proto.Message)

func (*ListOTPResponse) XXX_Size 

func (m *ListOTPResponse) XXX_Size() int

func (*ListOTPResponse) XXX_Unmarshal 

func (m *ListOTPResponse) XXX_Unmarshal(b []byte) error

type ListOrganizationRequest 

type ListOrganizationRequest struct {
	// Max number of organizations to return in the result-set.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// When provided, the given string will be used to search on
	// displayName.
	Search               string   `protobuf:"bytes,3,opt,name=search,proto3" json:"search,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListOrganizationRequest) Descriptor 

func (*ListOrganizationRequest) Descriptor() ([]byte, []int)

func (*ListOrganizationRequest) GetLimit 

func (m *ListOrganizationRequest) GetLimit() int64

func (*ListOrganizationRequest) GetOffset 

func (m *ListOrganizationRequest) GetOffset() int64

func (*ListOrganizationRequest) GetSearch 

func (m *ListOrganizationRequest) GetSearch() string

func (*ListOrganizationRequest) ProtoMessage 

func (*ListOrganizationRequest) ProtoMessage()

func (*ListOrganizationRequest) Reset 

func (m *ListOrganizationRequest) Reset()

func (*ListOrganizationRequest) String 

func (m *ListOrganizationRequest) String() string

func (*ListOrganizationRequest) XXX_DiscardUnknown 

func (m *ListOrganizationRequest) XXX_DiscardUnknown()

func (*ListOrganizationRequest) XXX_Marshal 

func (m *ListOrganizationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListOrganizationRequest) XXX_Merge 

func (m *ListOrganizationRequest) XXX_Merge(src proto.Message)

func (*ListOrganizationRequest) XXX_Size 

func (m *ListOrganizationRequest) XXX_Size() int

func (*ListOrganizationRequest) XXX_Unmarshal 

func (m *ListOrganizationRequest) XXX_Unmarshal(b []byte) error

type ListOrganizationResponse 

type ListOrganizationResponse struct {
	// Total number of organizations.
	TotalCount           int64                   `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*OrganizationListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*ListOrganizationResponse) Descriptor 

func (*ListOrganizationResponse) Descriptor() ([]byte, []int)

func (*ListOrganizationResponse) GetResult 

func (m *ListOrganizationResponse) GetResult() []*OrganizationListItem

func (*ListOrganizationResponse) GetTotalCount 

func (m *ListOrganizationResponse) GetTotalCount() int64

func (*ListOrganizationResponse) ProtoMessage 

func (*ListOrganizationResponse) ProtoMessage()

func (*ListOrganizationResponse) Reset 

func (m *ListOrganizationResponse) Reset()

func (*ListOrganizationResponse) String 

func (m *ListOrganizationResponse) String() string

func (*ListOrganizationResponse) XXX_DiscardUnknown 

func (m *ListOrganizationResponse) XXX_DiscardUnknown()

func (*ListOrganizationResponse) XXX_Marshal 

func (m *ListOrganizationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListOrganizationResponse) XXX_Merge 

func (m *ListOrganizationResponse) XXX_Merge(src proto.Message)

func (*ListOrganizationResponse) XXX_Size 

func (m *ListOrganizationResponse) XXX_Size() int

func (*ListOrganizationResponse) XXX_Unmarshal 

func (m *ListOrganizationResponse) XXX_Unmarshal(b []byte) error

type ListOrganizationUsersRequest 

type ListOrganizationUsersRequest struct {
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Max number of users to return in the result-set.
	Limit int32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset               int32    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListOrganizationUsersRequest) Descriptor 

func (*ListOrganizationUsersRequest) Descriptor() ([]byte, []int)

func (*ListOrganizationUsersRequest) GetLimit 

func (m *ListOrganizationUsersRequest) GetLimit() int32

func (*ListOrganizationUsersRequest) GetOffset 

func (m *ListOrganizationUsersRequest) GetOffset() int32

func (*ListOrganizationUsersRequest) GetOrganizationId 

func (m *ListOrganizationUsersRequest) GetOrganizationId() int64

func (*ListOrganizationUsersRequest) ProtoMessage 

func (*ListOrganizationUsersRequest) ProtoMessage()

func (*ListOrganizationUsersRequest) Reset 

func (m *ListOrganizationUsersRequest) Reset()

func (*ListOrganizationUsersRequest) String 

func (m *ListOrganizationUsersRequest) String() string

func (*ListOrganizationUsersRequest) XXX_DiscardUnknown 

func (m *ListOrganizationUsersRequest) XXX_DiscardUnknown()

func (*ListOrganizationUsersRequest) XXX_Marshal 

func (m *ListOrganizationUsersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListOrganizationUsersRequest) XXX_Merge 

func (m *ListOrganizationUsersRequest) XXX_Merge(src proto.Message)

func (*ListOrganizationUsersRequest) XXX_Size 

func (m *ListOrganizationUsersRequest) XXX_Size() int

func (*ListOrganizationUsersRequest) XXX_Unmarshal 

func (m *ListOrganizationUsersRequest) XXX_Unmarshal(b []byte) error

type ListOrganizationUsersResponse 

type ListOrganizationUsersResponse struct {
	// The total number of users in the organization.
	TotalCount           int64                       `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*OrganizationUserListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (*ListOrganizationUsersResponse) Descriptor 

func (*ListOrganizationUsersResponse) Descriptor() ([]byte, []int)

func (*ListOrganizationUsersResponse) GetResult 

func (m *ListOrganizationUsersResponse) GetResult() []*OrganizationUserListItem

func (*ListOrganizationUsersResponse) GetTotalCount 

func (m *ListOrganizationUsersResponse) GetTotalCount() int64

func (*ListOrganizationUsersResponse) ProtoMessage 

func (*ListOrganizationUsersResponse) ProtoMessage()

func (*ListOrganizationUsersResponse) Reset 

func (m *ListOrganizationUsersResponse) Reset()

func (*ListOrganizationUsersResponse) String 

func (m *ListOrganizationUsersResponse) String() string

func (*ListOrganizationUsersResponse) XXX_DiscardUnknown 

func (m *ListOrganizationUsersResponse) XXX_DiscardUnknown()

func (*ListOrganizationUsersResponse) XXX_Marshal 

func (m *ListOrganizationUsersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListOrganizationUsersResponse) XXX_Merge 

func (m *ListOrganizationUsersResponse) XXX_Merge(src proto.Message)

func (*ListOrganizationUsersResponse) XXX_Size 

func (m *ListOrganizationUsersResponse) XXX_Size() int

func (*ListOrganizationUsersResponse) XXX_Unmarshal 

func (m *ListOrganizationUsersResponse) XXX_Unmarshal(b []byte) error

type ListServiceProfileRequest 

type ListServiceProfileRequest struct {
	// Max number of items to return.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Organization id to filter on.
	OrganizationId       int64    `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ListServiceProfileRequest) Descriptor 

func (*ListServiceProfileRequest) Descriptor() ([]byte, []int)

func (*ListServiceProfileRequest) GetLimit 

func (m *ListServiceProfileRequest) GetLimit() int64

func (*ListServiceProfileRequest) GetOffset 

func (m *ListServiceProfileRequest) GetOffset() int64

func (*ListServiceProfileRequest) GetOrganizationId 

func (m *ListServiceProfileRequest) GetOrganizationId() int64

func (*ListServiceProfileRequest) ProtoMessage 

func (*ListServiceProfileRequest) ProtoMessage()

func (*ListServiceProfileRequest) Reset 

func (m *ListServiceProfileRequest) Reset()

func (*ListServiceProfileRequest) String 

func (m *ListServiceProfileRequest) String() string

func (*ListServiceProfileRequest) XXX_DiscardUnknown 

func (m *ListServiceProfileRequest) XXX_DiscardUnknown()

func (*ListServiceProfileRequest) XXX_Marshal 

func (m *ListServiceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListServiceProfileRequest) XXX_Merge 

func (m *ListServiceProfileRequest) XXX_Merge(src proto.Message)

func (*ListServiceProfileRequest) XXX_Size 

func (m *ListServiceProfileRequest) XXX_Size() int

func (*ListServiceProfileRequest) XXX_Unmarshal 

func (m *ListServiceProfileRequest) XXX_Unmarshal(b []byte) error

type ListServiceProfileResponse 

type ListServiceProfileResponse struct {
	// Total number of service-profiles.
	TotalCount           int64                     `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	Result               []*ServiceProfileListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (*ListServiceProfileResponse) Descriptor 

func (*ListServiceProfileResponse) Descriptor() ([]byte, []int)

func (*ListServiceProfileResponse) GetResult 

func (m *ListServiceProfileResponse) GetResult() []*ServiceProfileListItem

func (*ListServiceProfileResponse) GetTotalCount 

func (m *ListServiceProfileResponse) GetTotalCount() int64

func (*ListServiceProfileResponse) ProtoMessage 

func (*ListServiceProfileResponse) ProtoMessage()

func (*ListServiceProfileResponse) Reset 

func (m *ListServiceProfileResponse) Reset()

func (*ListServiceProfileResponse) String 

func (m *ListServiceProfileResponse) String() string

func (*ListServiceProfileResponse) XXX_DiscardUnknown 

func (m *ListServiceProfileResponse) XXX_DiscardUnknown()

func (*ListServiceProfileResponse) XXX_Marshal 

func (m *ListServiceProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListServiceProfileResponse) XXX_Merge 

func (m *ListServiceProfileResponse) XXX_Merge(src proto.Message)

func (*ListServiceProfileResponse) XXX_Size 

func (m *ListServiceProfileResponse) XXX_Size() int

func (*ListServiceProfileResponse) XXX_Unmarshal 

func (m *ListServiceProfileResponse) XXX_Unmarshal(b []byte) error

type ListUserRequest 

type ListUserRequest struct {
	// Max number of user to return in the result-set.
	Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset in the result-set (for pagination).
	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 (*ListUserRequest) Descriptor 

func (*ListUserRequest) Descriptor() ([]byte, []int)

func (*ListUserRequest) GetLimit 

func (m *ListUserRequest) GetLimit() int64

func (*ListUserRequest) GetOffset 

func (m *ListUserRequest) GetOffset() int64

func (*ListUserRequest) ProtoMessage 

func (*ListUserRequest) ProtoMessage()

func (*ListUserRequest) Reset 

func (m *ListUserRequest) Reset()

func (*ListUserRequest) String 

func (m *ListUserRequest) String() string

func (*ListUserRequest) XXX_DiscardUnknown 

func (m *ListUserRequest) XXX_DiscardUnknown()

func (*ListUserRequest) XXX_Marshal 

func (m *ListUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListUserRequest) XXX_Merge 

func (m *ListUserRequest) XXX_Merge(src proto.Message)

func (*ListUserRequest) XXX_Size 

func (m *ListUserRequest) XXX_Size() int

func (*ListUserRequest) XXX_Unmarshal 

func (m *ListUserRequest) XXX_Unmarshal(b []byte) error

type ListUserResponse 

type ListUserResponse struct {
	// Total number of users.
	TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	// Result-set.
	Result               []*UserListItem `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*ListUserResponse) Descriptor 

func (*ListUserResponse) Descriptor() ([]byte, []int)

func (*ListUserResponse) GetResult 

func (m *ListUserResponse) GetResult() []*UserListItem

func (*ListUserResponse) GetTotalCount 

func (m *ListUserResponse) GetTotalCount() int64

func (*ListUserResponse) ProtoMessage 

func (*ListUserResponse) ProtoMessage()

func (*ListUserResponse) Reset 

func (m *ListUserResponse) Reset()

func (*ListUserResponse) String 

func (m *ListUserResponse) String() string

func (*ListUserResponse) XXX_DiscardUnknown 

func (m *ListUserResponse) XXX_DiscardUnknown()

func (*ListUserResponse) XXX_Marshal 

func (m *ListUserResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ListUserResponse) XXX_Merge 

func (m *ListUserResponse) XXX_Merge(src proto.Message)

func (*ListUserResponse) XXX_Size 

func (m *ListUserResponse) XXX_Size() int

func (*ListUserResponse) XXX_Unmarshal 

func (m *ListUserResponse) XXX_Unmarshal(b []byte) error

type LoRaCloudIntegration 

type LoRaCloudIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Geolocation enabled.
	Geolocation bool `protobuf:"varint,2,opt,name=geolocation,proto3" json:"geolocation,omitempty"`
	// Geolocation token.
	// This token can be obtained from the LoRa Cloud console.
	GeolocationToken string `protobuf:"bytes,3,opt,name=geolocation_token,json=geolocationToken,proto3" json:"geolocation_token,omitempty"`
	// Geolocation buffer TTL (in seconds).
	// When > 0, uplink RX meta-data will be stored in a buffer so that
	// the meta-data of multiple uplinks can be used for geolocation.
	GeolocationBufferTtl uint32 `protobuf:"varint,4,opt,name=geolocation_buffer_ttl,json=geolocationBufferTTL,proto3" json:"geolocation_buffer_ttl,omitempty"`
	// Geolocation minimum buffer size.
	// When > 0, geolocation will only be performed when the buffer has
	// at least the given size.
	GeolocationMinBufferSize uint32 `` /* 138-byte string literal not displayed */
	// TDOA based geolocation is enabled.
	GeolocationTdoa bool `protobuf:"varint,6,opt,name=geolocation_tdoa,json=geolocationTDOA,proto3" json:"geolocation_tdoa,omitempty"`
	// RSSI based geolocation is enabled.
	GeolocationRssi bool `protobuf:"varint,7,opt,name=geolocation_rssi,json=geolocationRSSI,proto3" json:"geolocation_rssi,omitempty"`
	// GNSS based geolocation is enabled (LR1110).
	GeolocationGnss bool `protobuf:"varint,8,opt,name=geolocation_gnss,json=geolocationGNSS,proto3" json:"geolocation_gnss,omitempty"`
	// GNSS payload field.
	// This holds the name of the field in the decoded payload object which
	// contains the GNSS payload bytes.
	GeolocationGnssPayloadField string `` /* 146-byte string literal not displayed */
	// GNSS use RX time.
	// In case this is set to true, the resolver will use the RX time of the
	// network instead of the timestamp included in the LR1110 payload.
	GeolocationGnssUseRxTime bool `` /* 141-byte string literal not displayed */
	// Wifi based geolocation is enabled.
	GeolocationWifi bool `protobuf:"varint,11,opt,name=geolocation_wifi,json=geolocationWifi,proto3" json:"geolocation_wifi,omitempty"`
	// Wifi payload field.
	// This holds the name of the field in the decoded payload object which
	// contains an array of objects with the following fields:
	// * macAddress - e.g. 01:23:45:67:89:ab
	// * signalStrength - e.g. -51 (optional)
	GeolocationWifiPayloadField string `` /* 147-byte string literal not displayed */
	// Device Application Services enabled.
	Das bool `protobuf:"varint,13,opt,name=das,proto3" json:"das,omitempty"`
	// Device Application Services token.
	// This token can be obtained from the LoRa Cloud console.
	DasToken string `protobuf:"bytes,14,opt,name=das_token,json=dasToken,proto3" json:"das_token,omitempty"`
	// Device Application Services modem port (FPort).
	// ChirpStack Application Server will only forward the FRMPayload to DAS
	// when the uplink FPort is equal to this value.
	DasModemPort uint32 `protobuf:"varint,15,opt,name=das_modem_port,json=dasModemPort,proto3" json:"das_modem_port,omitempty"`
	// Device Application Services GNSS port (FPort).
	// ChirpStack Application Server will forward the FRMPayload to DAS when
	// as GNSS payload when the uplink FPort is equal to this value.
	DasGnssPort uint32 `protobuf:"varint,16,opt,name=das_gnss_port,json=dasGNSSPort,proto3" json:"das_gnss_port,omitempty"`
	// Device Application Services GNSS use RX time.
	// In case this is set to true, the DAS resolver will use the RX time of the
	// network instead of the timestamp included in the LR1110 payload.
	DasGnssUseRxTime bool `protobuf:"varint,17,opt,name=das_gnss_use_rx_time,json=dasGNSSUseRxTime,proto3" json:"das_gnss_use_rx_time,omitempty"`
	// Device Application Services streaming geoloc work-around.
	// This is a temporarily work-around for processing streaming geolocation
	// data. When enabled, stream records (expected in TLV format) are scanned
	// for GNSS data (0x06 or 0x07). If found, the ChirpStack Application Server
	// will make an additional call to the DAS API for resolving the location
	// using the detected payload.
	DasStreamingGeolocWorkaround bool     `` /* 151-byte string literal not displayed */
	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
	XXX_unrecognized             []byte   `json:"-"`
	XXX_sizecache                int32    `json:"-"`
}

func (*LoRaCloudIntegration) Descriptor 

func (*LoRaCloudIntegration) Descriptor() ([]byte, []int)

func (*LoRaCloudIntegration) GetApplicationId 

func (m *LoRaCloudIntegration) GetApplicationId() int64

func (*LoRaCloudIntegration) GetDas 

func (m *LoRaCloudIntegration) GetDas() bool

func (*LoRaCloudIntegration) GetDasGnssPort 

func (m *LoRaCloudIntegration) GetDasGnssPort() uint32

func (*LoRaCloudIntegration) GetDasGnssUseRxTime 

func (m *LoRaCloudIntegration) GetDasGnssUseRxTime() bool

func (*LoRaCloudIntegration) GetDasModemPort 

func (m *LoRaCloudIntegration) GetDasModemPort() uint32

func (*LoRaCloudIntegration) GetDasStreamingGeolocWorkaround 

func (m *LoRaCloudIntegration) GetDasStreamingGeolocWorkaround() bool

func (*LoRaCloudIntegration) GetDasToken 

func (m *LoRaCloudIntegration) GetDasToken() string

func (*LoRaCloudIntegration) GetGeolocation 

func (m *LoRaCloudIntegration) GetGeolocation() bool

func (*LoRaCloudIntegration) GetGeolocationBufferTtl 

func (m *LoRaCloudIntegration) GetGeolocationBufferTtl() uint32

func (*LoRaCloudIntegration) GetGeolocationGnss 

func (m *LoRaCloudIntegration) GetGeolocationGnss() bool

func (*LoRaCloudIntegration) GetGeolocationGnssPayloadField 

func (m *LoRaCloudIntegration) GetGeolocationGnssPayloadField() string

func (*LoRaCloudIntegration) GetGeolocationGnssUseRxTime 

func (m *LoRaCloudIntegration) GetGeolocationGnssUseRxTime() bool

func (*LoRaCloudIntegration) GetGeolocationMinBufferSize 

func (m *LoRaCloudIntegration) GetGeolocationMinBufferSize() uint32

func (*LoRaCloudIntegration) GetGeolocationRssi 

func (m *LoRaCloudIntegration) GetGeolocationRssi() bool

func (*LoRaCloudIntegration) GetGeolocationTdoa 

func (m *LoRaCloudIntegration) GetGeolocationTdoa() bool

func (*LoRaCloudIntegration) GetGeolocationToken 

func (m *LoRaCloudIntegration) GetGeolocationToken() string

func (*LoRaCloudIntegration) GetGeolocationWifi 

func (m *LoRaCloudIntegration) GetGeolocationWifi() bool

func (*LoRaCloudIntegration) GetGeolocationWifiPayloadField 

func (m *LoRaCloudIntegration) GetGeolocationWifiPayloadField() string

func (*LoRaCloudIntegration) ProtoMessage 

func (*LoRaCloudIntegration) ProtoMessage()

func (*LoRaCloudIntegration) Reset 

func (m *LoRaCloudIntegration) Reset()

func (*LoRaCloudIntegration) String 

func (m *LoRaCloudIntegration) String() string

func (*LoRaCloudIntegration) XXX_DiscardUnknown 

func (m *LoRaCloudIntegration) XXX_DiscardUnknown()

func (*LoRaCloudIntegration) XXX_Marshal 

func (m *LoRaCloudIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoRaCloudIntegration) XXX_Merge 

func (m *LoRaCloudIntegration) XXX_Merge(src proto.Message)

func (*LoRaCloudIntegration) XXX_Size 

func (m *LoRaCloudIntegration) XXX_Size() int

func (*LoRaCloudIntegration) XXX_Unmarshal 

func (m *LoRaCloudIntegration) XXX_Unmarshal(b []byte) error

type LoRaWANFilterRequest 

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

func (*LoRaWANFilterRequest) Descriptor 

func (*LoRaWANFilterRequest) Descriptor() ([]byte, []int)

func (*LoRaWANFilterRequest) GetFilter 

func (m *LoRaWANFilterRequest) GetFilter() *Filter

func (*LoRaWANFilterRequest) ProtoMessage 

func (*LoRaWANFilterRequest) ProtoMessage()

func (*LoRaWANFilterRequest) Reset 

func (m *LoRaWANFilterRequest) Reset()

func (*LoRaWANFilterRequest) String 

func (m *LoRaWANFilterRequest) String() string

func (*LoRaWANFilterRequest) XXX_DiscardUnknown 

func (m *LoRaWANFilterRequest) XXX_DiscardUnknown()

func (*LoRaWANFilterRequest) XXX_Marshal 

func (m *LoRaWANFilterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoRaWANFilterRequest) XXX_Merge 

func (m *LoRaWANFilterRequest) XXX_Merge(src proto.Message)

func (*LoRaWANFilterRequest) XXX_Size 

func (m *LoRaWANFilterRequest) XXX_Size() int

func (*LoRaWANFilterRequest) XXX_Unmarshal 

func (m *LoRaWANFilterRequest) XXX_Unmarshal(b []byte) error

type LoRaWANFilterResponse 

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

func (*LoRaWANFilterResponse) Descriptor 

func (*LoRaWANFilterResponse) Descriptor() ([]byte, []int)

func (*LoRaWANFilterResponse) GetFilter 

func (m *LoRaWANFilterResponse) GetFilter() *Filter

func (*LoRaWANFilterResponse) ProtoMessage 

func (*LoRaWANFilterResponse) ProtoMessage()

func (*LoRaWANFilterResponse) Reset 

func (m *LoRaWANFilterResponse) Reset()

func (*LoRaWANFilterResponse) String 

func (m *LoRaWANFilterResponse) String() string

func (*LoRaWANFilterResponse) XXX_DiscardUnknown 

func (m *LoRaWANFilterResponse) XXX_DiscardUnknown()

func (*LoRaWANFilterResponse) XXX_Marshal 

func (m *LoRaWANFilterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoRaWANFilterResponse) XXX_Merge 

func (m *LoRaWANFilterResponse) XXX_Merge(src proto.Message)

func (*LoRaWANFilterResponse) XXX_Size 

func (m *LoRaWANFilterResponse) XXX_Size() int

func (*LoRaWANFilterResponse) XXX_Unmarshal 

func (m *LoRaWANFilterResponse) XXX_Unmarshal(b []byte) error

type LoRaWANModeRequest 

type LoRaWANModeRequest struct {
	Mode string `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`
	// Types that are valid to be assigned to ModeConfig:
	//
	//	*LoRaWANModeRequest_Pf
	//	*LoRaWANModeRequest_Bs
	//	*LoRaWANModeRequest_Ns
	ModeConfig           isLoRaWANModeRequest_ModeConfig `protobuf_oneof:"modeConfig"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

func (*LoRaWANModeRequest) Descriptor 

func (*LoRaWANModeRequest) Descriptor() ([]byte, []int)

func (*LoRaWANModeRequest) GetBs 

func (m *LoRaWANModeRequest) GetBs() *BasicsStation

func (*LoRaWANModeRequest) GetMode 

func (m *LoRaWANModeRequest) GetMode() string

func (*LoRaWANModeRequest) GetModeConfig 

func (m *LoRaWANModeRequest) GetModeConfig() isLoRaWANModeRequest_ModeConfig

func (*LoRaWANModeRequest) GetNs 

func (m *LoRaWANModeRequest) GetNs() *BuiltInNetworkServer

func (*LoRaWANModeRequest) GetPf 

func (m *LoRaWANModeRequest) GetPf() *PacketForwarder

func (*LoRaWANModeRequest) ProtoMessage 

func (*LoRaWANModeRequest) ProtoMessage()

func (*LoRaWANModeRequest) Reset 

func (m *LoRaWANModeRequest) Reset()

func (*LoRaWANModeRequest) String 

func (m *LoRaWANModeRequest) String() string

func (*LoRaWANModeRequest) XXX_DiscardUnknown 

func (m *LoRaWANModeRequest) XXX_DiscardUnknown()

func (*LoRaWANModeRequest) XXX_Marshal 

func (m *LoRaWANModeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoRaWANModeRequest) XXX_Merge 

func (m *LoRaWANModeRequest) XXX_Merge(src proto.Message)

func (*LoRaWANModeRequest) XXX_OneofWrappers 

func (*LoRaWANModeRequest) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*LoRaWANModeRequest) XXX_Size 

func (m *LoRaWANModeRequest) XXX_Size() int

func (*LoRaWANModeRequest) XXX_Unmarshal 

func (m *LoRaWANModeRequest) XXX_Unmarshal(b []byte) error

type LoRaWANModeRequest_Bs 

type LoRaWANModeRequest_Bs struct {
	Bs *BasicsStation `protobuf:"bytes,3,opt,name=bs,json=BS,proto3,oneof"`
}

type LoRaWANModeRequest_Ns 

type LoRaWANModeRequest_Ns struct {
	Ns *BuiltInNetworkServer `protobuf:"bytes,4,opt,name=ns,json=NS,proto3,oneof"`
}

type LoRaWANModeRequest_Pf 

type LoRaWANModeRequest_Pf struct {
	Pf *PacketForwarder `protobuf:"bytes,2,opt,name=pf,json=PF,proto3,oneof"`
}

type LoRaWANModeResponse 

type LoRaWANModeResponse struct {
	Mode string `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`
	// Types that are valid to be assigned to ModeConfig:
	//
	//	*LoRaWANModeResponse_Pf
	//	*LoRaWANModeResponse_Bs
	//	*LoRaWANModeResponse_Ns
	ModeConfig           isLoRaWANModeResponse_ModeConfig `protobuf_oneof:"modeConfig"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (*LoRaWANModeResponse) Descriptor 

func (*LoRaWANModeResponse) Descriptor() ([]byte, []int)

func (*LoRaWANModeResponse) GetBs 

func (m *LoRaWANModeResponse) GetBs() *BasicsStation

func (*LoRaWANModeResponse) GetMode 

func (m *LoRaWANModeResponse) GetMode() string

func (*LoRaWANModeResponse) GetModeConfig 

func (m *LoRaWANModeResponse) GetModeConfig() isLoRaWANModeResponse_ModeConfig

func (*LoRaWANModeResponse) GetNs 

func (m *LoRaWANModeResponse) GetNs() *BuiltInNetworkServer

func (*LoRaWANModeResponse) GetPf 

func (m *LoRaWANModeResponse) GetPf() *PacketForwarder

func (*LoRaWANModeResponse) ProtoMessage 

func (*LoRaWANModeResponse) ProtoMessage()

func (*LoRaWANModeResponse) Reset 

func (m *LoRaWANModeResponse) Reset()

func (*LoRaWANModeResponse) String 

func (m *LoRaWANModeResponse) String() string

func (*LoRaWANModeResponse) XXX_DiscardUnknown 

func (m *LoRaWANModeResponse) XXX_DiscardUnknown()

func (*LoRaWANModeResponse) XXX_Marshal 

func (m *LoRaWANModeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoRaWANModeResponse) XXX_Merge 

func (m *LoRaWANModeResponse) XXX_Merge(src proto.Message)

func (*LoRaWANModeResponse) XXX_OneofWrappers 

func (*LoRaWANModeResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*LoRaWANModeResponse) XXX_Size 

func (m *LoRaWANModeResponse) XXX_Size() int

func (*LoRaWANModeResponse) XXX_Unmarshal 

func (m *LoRaWANModeResponse) XXX_Unmarshal(b []byte) error

type LoRaWANModeResponse_Bs 

type LoRaWANModeResponse_Bs struct {
	Bs *BasicsStation `protobuf:"bytes,3,opt,name=bs,json=BS,proto3,oneof"`
}

type LoRaWANModeResponse_Ns 

type LoRaWANModeResponse_Ns struct {
	Ns *BuiltInNetworkServer `protobuf:"bytes,4,opt,name=ns,json=NS,proto3,oneof"`
}

type LoRaWANModeResponse_Pf 

type LoRaWANModeResponse_Pf struct {
	Pf *PacketForwarder `protobuf:"bytes,2,opt,name=pf,json=PF,proto3,oneof"`
}

type LoRaWANRegionRequest 

type LoRaWANRegionRequest struct {
	RegionId string `protobuf:"bytes,1,opt,name=regionId,proto3" json:"regionId,omitempty"`
	// Types that are valid to be assigned to RegionConfig:
	//
	//	*LoRaWANRegionRequest_Cn470
	//	*LoRaWANRegionRequest_Eu868
	//	*LoRaWANRegionRequest_Us915
	RegionConfig         isLoRaWANRegionRequest_RegionConfig `protobuf_oneof:"regionConfig"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

func (*LoRaWANRegionRequest) Descriptor 

func (*LoRaWANRegionRequest) Descriptor() ([]byte, []int)

func (*LoRaWANRegionRequest) GetCn470 

func (m *LoRaWANRegionRequest) GetCn470() *CN470Config

func (*LoRaWANRegionRequest) GetEu868 

func (m *LoRaWANRegionRequest) GetEu868() *EU868Config

func (*LoRaWANRegionRequest) GetRegionConfig 

func (m *LoRaWANRegionRequest) GetRegionConfig() isLoRaWANRegionRequest_RegionConfig

func (*LoRaWANRegionRequest) GetRegionId 

func (m *LoRaWANRegionRequest) GetRegionId() string

func (*LoRaWANRegionRequest) GetUs915 

func (m *LoRaWANRegionRequest) GetUs915() *US915Config

func (*LoRaWANRegionRequest) ProtoMessage 

func (*LoRaWANRegionRequest) ProtoMessage()

func (*LoRaWANRegionRequest) Reset 

func (m *LoRaWANRegionRequest) Reset()

func (*LoRaWANRegionRequest) String 

func (m *LoRaWANRegionRequest) String() string

func (*LoRaWANRegionRequest) XXX_DiscardUnknown 

func (m *LoRaWANRegionRequest) XXX_DiscardUnknown()

func (*LoRaWANRegionRequest) XXX_Marshal 

func (m *LoRaWANRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoRaWANRegionRequest) XXX_Merge 

func (m *LoRaWANRegionRequest) XXX_Merge(src proto.Message)

func (*LoRaWANRegionRequest) XXX_OneofWrappers 

func (*LoRaWANRegionRequest) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*LoRaWANRegionRequest) XXX_Size 

func (m *LoRaWANRegionRequest) XXX_Size() int

func (*LoRaWANRegionRequest) XXX_Unmarshal 

func (m *LoRaWANRegionRequest) XXX_Unmarshal(b []byte) error

type LoRaWANRegionRequest_Cn470 

type LoRaWANRegionRequest_Cn470 struct {
	Cn470 *CN470Config `protobuf:"bytes,2,opt,name=cn470,json=CN470,proto3,oneof"`
}

type LoRaWANRegionRequest_Eu868 

type LoRaWANRegionRequest_Eu868 struct {
	Eu868 *EU868Config `protobuf:"bytes,3,opt,name=eu868,json=EU868,proto3,oneof"`
}

type LoRaWANRegionRequest_Us915 

type LoRaWANRegionRequest_Us915 struct {
	Us915 *US915Config `protobuf:"bytes,4,opt,name=us915,json=US915,proto3,oneof"`
}

type LoRaWANRegionResponse 

type LoRaWANRegionResponse struct {
	RegionId string `protobuf:"bytes,1,opt,name=regionId,proto3" json:"regionId,omitempty"`
	// Types that are valid to be assigned to RegionConfig:
	//
	//	*LoRaWANRegionResponse_Cn470
	//	*LoRaWANRegionResponse_Eu868
	//	*LoRaWANRegionResponse_Us915
	RegionConfig         isLoRaWANRegionResponse_RegionConfig `protobuf_oneof:"regionConfig"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

func (*LoRaWANRegionResponse) Descriptor 

func (*LoRaWANRegionResponse) Descriptor() ([]byte, []int)

func (*LoRaWANRegionResponse) GetCn470 

func (m *LoRaWANRegionResponse) GetCn470() *CN470Config

func (*LoRaWANRegionResponse) GetEu868 

func (m *LoRaWANRegionResponse) GetEu868() *EU868Config

func (*LoRaWANRegionResponse) GetRegionConfig 

func (m *LoRaWANRegionResponse) GetRegionConfig() isLoRaWANRegionResponse_RegionConfig

func (*LoRaWANRegionResponse) GetRegionId 

func (m *LoRaWANRegionResponse) GetRegionId() string

func (*LoRaWANRegionResponse) GetUs915 

func (m *LoRaWANRegionResponse) GetUs915() *US915Config

func (*LoRaWANRegionResponse) ProtoMessage 

func (*LoRaWANRegionResponse) ProtoMessage()

func (*LoRaWANRegionResponse) Reset 

func (m *LoRaWANRegionResponse) Reset()

func (*LoRaWANRegionResponse) String 

func (m *LoRaWANRegionResponse) String() string

func (*LoRaWANRegionResponse) XXX_DiscardUnknown 

func (m *LoRaWANRegionResponse) XXX_DiscardUnknown()

func (*LoRaWANRegionResponse) XXX_Marshal 

func (m *LoRaWANRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoRaWANRegionResponse) XXX_Merge 

func (m *LoRaWANRegionResponse) XXX_Merge(src proto.Message)

func (*LoRaWANRegionResponse) XXX_OneofWrappers 

func (*LoRaWANRegionResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*LoRaWANRegionResponse) XXX_Size 

func (m *LoRaWANRegionResponse) XXX_Size() int

func (*LoRaWANRegionResponse) XXX_Unmarshal 

func (m *LoRaWANRegionResponse) XXX_Unmarshal(b []byte) error

type LoRaWANRegionResponse_Cn470 

type LoRaWANRegionResponse_Cn470 struct {
	Cn470 *CN470Config `protobuf:"bytes,2,opt,name=cn470,json=CN470,proto3,oneof"`
}

type LoRaWANRegionResponse_Eu868 

type LoRaWANRegionResponse_Eu868 struct {
	Eu868 *EU868Config `protobuf:"bytes,3,opt,name=eu868,json=EU868,proto3,oneof"`
}

type LoRaWANRegionResponse_Us915 

type LoRaWANRegionResponse_Us915 struct {
	Us915 *US915Config `protobuf:"bytes,4,opt,name=us915,json=US915,proto3,oneof"`
}

type LoginRequest 

type LoginRequest struct {
	// Email of the user.
	Email string `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"`
	// Password of the user.
	Password             string   `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*LoginRequest) Descriptor 

func (*LoginRequest) Descriptor() ([]byte, []int)

func (*LoginRequest) GetEmail 

func (m *LoginRequest) GetEmail() string

func (*LoginRequest) GetPassword 

func (m *LoginRequest) GetPassword() string

func (*LoginRequest) ProtoMessage 

func (*LoginRequest) ProtoMessage()

func (*LoginRequest) Reset 

func (m *LoginRequest) Reset()

func (*LoginRequest) String 

func (m *LoginRequest) String() string

func (*LoginRequest) XXX_DiscardUnknown 

func (m *LoginRequest) XXX_DiscardUnknown()

func (*LoginRequest) XXX_Marshal 

func (m *LoginRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoginRequest) XXX_Merge 

func (m *LoginRequest) XXX_Merge(src proto.Message)

func (*LoginRequest) XXX_Size 

func (m *LoginRequest) XXX_Size() int

func (*LoginRequest) XXX_Unmarshal 

func (m *LoginRequest) XXX_Unmarshal(b []byte) error

type LoginResponse 

type LoginResponse struct {
	// The JWT tag to be used to access chirpstack-application-server interfaces.
	Jwt                  string   `protobuf:"bytes,1,opt,name=jwt,proto3" json:"jwt,omitempty"`
	Id                   int64    `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	First                bool     `protobuf:"varint,3,opt,name=first,proto3" json:"first,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*LoginResponse) Descriptor 

func (*LoginResponse) Descriptor() ([]byte, []int)

func (*LoginResponse) GetFirst 

func (m *LoginResponse) GetFirst() bool

func (*LoginResponse) GetId 

func (m *LoginResponse) GetId() int64

func (*LoginResponse) GetJwt 

func (m *LoginResponse) GetJwt() string

func (*LoginResponse) ProtoMessage 

func (*LoginResponse) ProtoMessage()

func (*LoginResponse) Reset 

func (m *LoginResponse) Reset()

func (*LoginResponse) String 

func (m *LoginResponse) String() string

func (*LoginResponse) XXX_DiscardUnknown 

func (m *LoginResponse) XXX_DiscardUnknown()

func (*LoginResponse) XXX_Marshal 

func (m *LoginResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoginResponse) XXX_Merge 

func (m *LoginResponse) XXX_Merge(src proto.Message)

func (*LoginResponse) XXX_Size 

func (m *LoginResponse) XXX_Size() int

func (*LoginResponse) XXX_Unmarshal 

func (m *LoginResponse) XXX_Unmarshal(b []byte) error

type LoraNodeBasic 

type LoraNodeBasic struct {
	Name                 string           `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ManufacturingDate    string           `protobuf:"bytes,2,opt,name=manufacturingDate,json=MFGDate,proto3" json:"manufacturingDate,omitempty"`
	SerialNumber         string           `protobuf:"bytes,3,opt,name=serialNumber,json=SN,proto3" json:"serialNumber,omitempty"`
	Label                string           `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"`
	FVersion             string           `protobuf:"bytes,5,opt,name=fVersion,proto3" json:"fVersion,omitempty"`
	HVersion             string           `protobuf:"bytes,6,opt,name=hVersion,proto3" json:"hVersion,omitempty"`
	Active               bool             `protobuf:"varint,7,opt,name=active,proto3" json:"active,omitempty"`
	Rssi                 int32            `protobuf:"varint,8,opt,name=rssi,proto3" json:"rssi,omitempty"`
	Snr                  int32            `protobuf:"varint,9,opt,name=snr,proto3" json:"snr,omitempty"`
	Battery              string           `protobuf:"bytes,10,opt,name=battery,proto3" json:"battery,omitempty"`
	Location             *common.Location `protobuf:"bytes,11,opt,name=location,proto3" json:"location,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*LoraNodeBasic) Descriptor 

func (*LoraNodeBasic) Descriptor() ([]byte, []int)

func (*LoraNodeBasic) GetActive 

func (m *LoraNodeBasic) GetActive() bool

func (*LoraNodeBasic) GetBattery 

func (m *LoraNodeBasic) GetBattery() string

func (*LoraNodeBasic) GetFVersion 

func (m *LoraNodeBasic) GetFVersion() string

func (*LoraNodeBasic) GetHVersion 

func (m *LoraNodeBasic) GetHVersion() string

func (*LoraNodeBasic) GetLabel 

func (m *LoraNodeBasic) GetLabel() string

func (*LoraNodeBasic) GetLocation 

func (m *LoraNodeBasic) GetLocation() *common.Location

func (*LoraNodeBasic) GetManufacturingDate 

func (m *LoraNodeBasic) GetManufacturingDate() string

func (*LoraNodeBasic) GetName 

func (m *LoraNodeBasic) GetName() string

func (*LoraNodeBasic) GetRssi 

func (m *LoraNodeBasic) GetRssi() int32

func (*LoraNodeBasic) GetSerialNumber 

func (m *LoraNodeBasic) GetSerialNumber() string

func (*LoraNodeBasic) GetSnr 

func (m *LoraNodeBasic) GetSnr() int32

func (*LoraNodeBasic) ProtoMessage 

func (*LoraNodeBasic) ProtoMessage()

func (*LoraNodeBasic) Reset 

func (m *LoraNodeBasic) Reset()

func (*LoraNodeBasic) String 

func (m *LoraNodeBasic) String() string

func (*LoraNodeBasic) XXX_DiscardUnknown 

func (m *LoraNodeBasic) XXX_DiscardUnknown()

func (*LoraNodeBasic) XXX_Marshal 

func (m *LoraNodeBasic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoraNodeBasic) XXX_Merge 

func (m *LoraNodeBasic) XXX_Merge(src proto.Message)

func (*LoraNodeBasic) XXX_Size 

func (m *LoraNodeBasic) XXX_Size() int

func (*LoraNodeBasic) XXX_Unmarshal 

func (m *LoraNodeBasic) XXX_Unmarshal(b []byte) error

type LoraWANConfig 

type LoraWANConfig struct {
	Basic                *LoraNodeBasic `protobuf:"bytes,1,opt,name=basic,proto3" json:"basic,omitempty"`
	DevEui               string         `protobuf:"bytes,2,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	Name                 string         `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	JoinEui              string         `protobuf:"bytes,4,opt,name=join_eui,json=joinEUI,proto3" json:"join_eui,omitempty"`
	Appkey               string         `protobuf:"bytes,5,opt,name=appkey,proto3" json:"appkey,omitempty"`
	MacVersion           string         `protobuf:"bytes,6,opt,name=macVersion,proto3" json:"macVersion,omitempty"`
	SupportJoin          bool           `protobuf:"varint,7,opt,name=support_join,json=supportJoin,proto3" json:"support_join,omitempty"`
	Aport                int32          `protobuf:"varint,8,opt,name=aport,proto3" json:"aport,omitempty"`
	Region               string         `protobuf:"bytes,9,opt,name=region,proto3" json:"region,omitempty"`
	SubBand              int32          `protobuf:"varint,10,opt,name=subBand,proto3" json:"subBand,omitempty"`
	UpInterval           string         `protobuf:"bytes,11,opt,name=up_interval,json=upInterval,proto3" json:"up_interval,omitempty"`
	Txpower              uint32         `protobuf:"varint,12,opt,name=txpower,proto3" json:"txpower,omitempty"`
	Datarate             int32          `protobuf:"varint,13,opt,name=datarate,proto3" json:"datarate,omitempty"`
	Confirm              bool           `protobuf:"varint,14,opt,name=confirm,proto3" json:"confirm,omitempty"`
	Newjoin              bool           `protobuf:"varint,15,opt,name=newjoin,proto3" json:"newjoin,omitempty"`
	Adr                  bool           `protobuf:"varint,16,opt,name=adr,proto3" json:"adr,omitempty"`
	Collect              *CollectConfig `protobuf:"bytes,17,opt,name=collect,proto3" json:"collect,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*LoraWANConfig) Descriptor 

func (*LoraWANConfig) Descriptor() ([]byte, []int)

func (*LoraWANConfig) GetAdr 

func (m *LoraWANConfig) GetAdr() bool

func (*LoraWANConfig) GetAport 

func (m *LoraWANConfig) GetAport() int32

func (*LoraWANConfig) GetAppkey 

func (m *LoraWANConfig) GetAppkey() string

func (*LoraWANConfig) GetBasic 

func (m *LoraWANConfig) GetBasic() *LoraNodeBasic

func (*LoraWANConfig) GetCollect 

func (m *LoraWANConfig) GetCollect() *CollectConfig

func (*LoraWANConfig) GetConfirm 

func (m *LoraWANConfig) GetConfirm() bool

func (*LoraWANConfig) GetDatarate 

func (m *LoraWANConfig) GetDatarate() int32

func (*LoraWANConfig) GetDevEui 

func (m *LoraWANConfig) GetDevEui() string

func (*LoraWANConfig) GetJoinEui 

func (m *LoraWANConfig) GetJoinEui() string

func (*LoraWANConfig) GetMacVersion 

func (m *LoraWANConfig) GetMacVersion() string

func (*LoraWANConfig) GetName 

func (m *LoraWANConfig) GetName() string

func (*LoraWANConfig) GetNewjoin 

func (m *LoraWANConfig) GetNewjoin() bool

func (*LoraWANConfig) GetRegion 

func (m *LoraWANConfig) GetRegion() string

func (*LoraWANConfig) GetSubBand 

func (m *LoraWANConfig) GetSubBand() int32

func (*LoraWANConfig) GetSupportJoin 

func (m *LoraWANConfig) GetSupportJoin() bool

func (*LoraWANConfig) GetTxpower 

func (m *LoraWANConfig) GetTxpower() uint32

func (*LoraWANConfig) GetUpInterval 

func (m *LoraWANConfig) GetUpInterval() string

func (*LoraWANConfig) ProtoMessage 

func (*LoraWANConfig) ProtoMessage()

func (*LoraWANConfig) Reset 

func (m *LoraWANConfig) Reset()

func (*LoraWANConfig) String 

func (m *LoraWANConfig) String() string

func (*LoraWANConfig) XXX_DiscardUnknown 

func (m *LoraWANConfig) XXX_DiscardUnknown()

func (*LoraWANConfig) XXX_Marshal 

func (m *LoraWANConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LoraWANConfig) XXX_Merge 

func (m *LoraWANConfig) XXX_Merge(src proto.Message)

func (*LoraWANConfig) XXX_Size 

func (m *LoraWANConfig) XXX_Size() int

func (*LoraWANConfig) XXX_Unmarshal 

func (m *LoraWANConfig) XXX_Unmarshal(b []byte) error

type LoraWANServiceClient 

type LoraWANServiceClient interface {
	Get(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetGateWayModeRegionResponse, error)
	ConfigGateWayModeRegion(ctx context.Context, in *ConfigGateWayModeRegionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	SetLoRaWANMode(ctx context.Context, in *LoRaWANModeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetLoRaWANMode(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*LoRaWANModeResponse, error)
	SetLoRaWANRegion(ctx context.Context, in *LoRaWANRegionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetLoRaWANRegion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*LoRaWANRegionResponse, error)
	SetLoRaWANFilter(ctx context.Context, in *LoRaWANFilterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetLoRaWANFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*LoRaWANFilterResponse, error)
}

LoraWANServiceClient is the client API for LoraWANService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewLoraWANServiceClient 

func NewLoraWANServiceClient(cc grpc.ClientConnInterface) LoraWANServiceClient

type LoraWANServiceServer 

type LoraWANServiceServer interface {
	Get(context.Context, *emptypb.Empty) (*GetGateWayModeRegionResponse, error)
	ConfigGateWayModeRegion(context.Context, *ConfigGateWayModeRegionRequest) (*emptypb.Empty, error)
	SetLoRaWANMode(context.Context, *LoRaWANModeRequest) (*emptypb.Empty, error)
	GetLoRaWANMode(context.Context, *emptypb.Empty) (*LoRaWANModeResponse, error)
	SetLoRaWANRegion(context.Context, *LoRaWANRegionRequest) (*emptypb.Empty, error)
	GetLoRaWANRegion(context.Context, *emptypb.Empty) (*LoRaWANRegionResponse, error)
	SetLoRaWANFilter(context.Context, *LoRaWANFilterRequest) (*emptypb.Empty, error)
	GetLoRaWANFilter(context.Context, *emptypb.Empty) (*LoRaWANFilterResponse, error)
}

LoraWANServiceServer is the server API for LoraWANService service.

type LorawanRX 

type LorawanRX struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	Sf                   int32    `protobuf:"varint,2,opt,name=sf,proto3" json:"sf,omitempty"`
	Bw                   int64    `protobuf:"varint,3,opt,name=bw,proto3" json:"bw,omitempty"`
	Txpower              int32    `protobuf:"varint,4,opt,name=txpower,proto3" json:"txpower,omitempty"`
	PacketNum            int64    `protobuf:"varint,5,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	Snr                  float64  `protobuf:"fixed64,7,opt,name=snr,proto3" json:"snr,omitempty"`
	Rssi                 int32    `protobuf:"varint,8,opt,name=rssi,proto3" json:"rssi,omitempty"`
	Lostrate             float32  `protobuf:"fixed32,9,opt,name=lostrate,proto3" json:"lostrate,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*LorawanRX) Descriptor 

func (*LorawanRX) Descriptor() ([]byte, []int)

func (*LorawanRX) GetBw 

func (m *LorawanRX) GetBw() int64

func (*LorawanRX) GetFreq 

func (m *LorawanRX) GetFreq() int64

func (*LorawanRX) GetLostrate 

func (m *LorawanRX) GetLostrate() float32

func (*LorawanRX) GetPacketNum 

func (m *LorawanRX) GetPacketNum() int64

func (*LorawanRX) GetRssi 

func (m *LorawanRX) GetRssi() int32

func (*LorawanRX) GetSf 

func (m *LorawanRX) GetSf() int32

func (*LorawanRX) GetSnr 

func (m *LorawanRX) GetSnr() float64

func (*LorawanRX) GetTxpower 

func (m *LorawanRX) GetTxpower() int32

func (*LorawanRX) ProtoMessage 

func (*LorawanRX) ProtoMessage()

func (*LorawanRX) Reset 

func (m *LorawanRX) Reset()

func (*LorawanRX) String 

func (m *LorawanRX) String() string

func (*LorawanRX) XXX_DiscardUnknown 

func (m *LorawanRX) XXX_DiscardUnknown()

func (*LorawanRX) XXX_Marshal 

func (m *LorawanRX) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LorawanRX) XXX_Merge 

func (m *LorawanRX) XXX_Merge(src proto.Message)

func (*LorawanRX) XXX_Size 

func (m *LorawanRX) XXX_Size() int

func (*LorawanRX) XXX_Unmarshal 

func (m *LorawanRX) XXX_Unmarshal(b []byte) error

type LorawanTX 

type LorawanTX struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	Sf                   int32    `protobuf:"varint,2,opt,name=sf,proto3" json:"sf,omitempty"`
	Bw                   int64    `protobuf:"varint,3,opt,name=bw,proto3" json:"bw,omitempty"`
	Txpower              int32    `protobuf:"varint,4,opt,name=txpower,proto3" json:"txpower,omitempty"`
	PacketNum            int64    `protobuf:"varint,5,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	PacketLen            int64    `protobuf:"varint,6,opt,name=packetLen,proto3" json:"packetLen,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*LorawanTX) Descriptor 

func (*LorawanTX) Descriptor() ([]byte, []int)

func (*LorawanTX) GetBw 

func (m *LorawanTX) GetBw() int64

func (*LorawanTX) GetFreq 

func (m *LorawanTX) GetFreq() int64

func (*LorawanTX) GetPacketLen 

func (m *LorawanTX) GetPacketLen() int64

func (*LorawanTX) GetPacketNum 

func (m *LorawanTX) GetPacketNum() int64

func (*LorawanTX) GetSf 

func (m *LorawanTX) GetSf() int32

func (*LorawanTX) GetTxpower 

func (m *LorawanTX) GetTxpower() int32

func (*LorawanTX) ProtoMessage 

func (*LorawanTX) ProtoMessage()

func (*LorawanTX) Reset 

func (m *LorawanTX) Reset()

func (*LorawanTX) String 

func (m *LorawanTX) String() string

func (*LorawanTX) XXX_DiscardUnknown 

func (m *LorawanTX) XXX_DiscardUnknown()

func (*LorawanTX) XXX_Marshal 

func (m *LorawanTX) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LorawanTX) XXX_Merge 

func (m *LorawanTX) XXX_Merge(src proto.Message)

func (*LorawanTX) XXX_Size 

func (m *LorawanTX) XXX_Size() int

func (*LorawanTX) XXX_Unmarshal 

func (m *LorawanTX) XXX_Unmarshal(b []byte) error

type MQTTSettings 

type MQTTSettings struct {
	Protocol string `protobuf:"bytes,1,opt,name=protocol,proto3" json:"protocol,omitempty"`
	// Types that are valid to be assigned to Settings:
	//
	//	*MQTTSettings_Rak
	Settings             isMQTTSettings_Settings `protobuf_oneof:"settings"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*MQTTSettings) Descriptor 

func (*MQTTSettings) Descriptor() ([]byte, []int)

func (*MQTTSettings) GetProtocol 

func (m *MQTTSettings) GetProtocol() string

func (*MQTTSettings) GetRak 

func (m *MQTTSettings) GetRak() *RAKSettings

func (*MQTTSettings) GetSettings 

func (m *MQTTSettings) GetSettings() isMQTTSettings_Settings

func (*MQTTSettings) ProtoMessage 

func (*MQTTSettings) ProtoMessage()

func (*MQTTSettings) Reset 

func (m *MQTTSettings) Reset()

func (*MQTTSettings) String 

func (m *MQTTSettings) String() string

func (*MQTTSettings) XXX_DiscardUnknown 

func (m *MQTTSettings) XXX_DiscardUnknown()

func (*MQTTSettings) XXX_Marshal 

func (m *MQTTSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MQTTSettings) XXX_Merge 

func (m *MQTTSettings) XXX_Merge(src proto.Message)

func (*MQTTSettings) XXX_OneofWrappers 

func (*MQTTSettings) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*MQTTSettings) XXX_Size 

func (m *MQTTSettings) XXX_Size() int

func (*MQTTSettings) XXX_Unmarshal 

func (m *MQTTSettings) XXX_Unmarshal(b []byte) error

type MQTTSettings_Rak 

type MQTTSettings_Rak struct {
	Rak *RAKSettings `protobuf:"bytes,2,opt,name=rak,json=RAK,proto3,oneof"`
}

type Marshaler 

type Marshaler int32
const (
	Marshaler_JSON     Marshaler = 0
	Marshaler_PROTOBUF Marshaler = 1
	Marshaler_JSON_V3  Marshaler = 2
)

func (Marshaler) EnumDescriptor 

func (Marshaler) EnumDescriptor() ([]byte, []int)

func (Marshaler) String 

func (x Marshaler) String() string

type MemoryUsage 

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 (*MemoryUsage) Descriptor 

func (*MemoryUsage) Descriptor() ([]byte, []int)

func (*MemoryUsage) GetTotal 

func (m *MemoryUsage) GetTotal() int64

func (*MemoryUsage) GetUsed 

func (m *MemoryUsage) GetUsed() int64

func (*MemoryUsage) ProtoMessage 

func (*MemoryUsage) ProtoMessage()

func (*MemoryUsage) Reset 

func (m *MemoryUsage) Reset()

func (*MemoryUsage) String 

func (m *MemoryUsage) String() string

func (*MemoryUsage) XXX_DiscardUnknown 

func (m *MemoryUsage) XXX_DiscardUnknown()

func (*MemoryUsage) XXX_Marshal 

func (m *MemoryUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MemoryUsage) XXX_Merge 

func (m *MemoryUsage) XXX_Merge(src proto.Message)

func (*MemoryUsage) XXX_Size 

func (m *MemoryUsage) XXX_Size() int

func (*MemoryUsage) XXX_Unmarshal 

func (m *MemoryUsage) XXX_Unmarshal(b []byte) error

type MoudleCat1 

type MoudleCat1 struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	PublicIp             string   `protobuf:"bytes,2,opt,name=public_ip,json=publicIP,proto3" json:"public_ip,omitempty"`
	Card                 bool     `protobuf:"varint,3,opt,name=card,proto3" json:"card,omitempty"`
	Per                  float32  `protobuf:"fixed32,4,opt,name=per,proto3" json:"per,omitempty"`
	Snr                  int32    `protobuf:"varint,5,opt,name=snr,proto3" json:"snr,omitempty"`
	Operator             string   `protobuf:"bytes,6,opt,name=operator,proto3" json:"operator,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*MoudleCat1) Descriptor 

func (*MoudleCat1) Descriptor() ([]byte, []int)

func (*MoudleCat1) GetCard 

func (m *MoudleCat1) GetCard() bool

func (*MoudleCat1) GetEnable 

func (m *MoudleCat1) GetEnable() bool

func (*MoudleCat1) GetOperator 

func (m *MoudleCat1) GetOperator() string

func (*MoudleCat1) GetPer 

func (m *MoudleCat1) GetPer() float32

func (*MoudleCat1) GetPublicIp 

func (m *MoudleCat1) GetPublicIp() string

func (*MoudleCat1) GetSnr 

func (m *MoudleCat1) GetSnr() int32

func (*MoudleCat1) ProtoMessage 

func (*MoudleCat1) ProtoMessage()

func (*MoudleCat1) Reset 

func (m *MoudleCat1) Reset()

func (*MoudleCat1) String 

func (m *MoudleCat1) String() string

func (*MoudleCat1) XXX_DiscardUnknown 

func (m *MoudleCat1) XXX_DiscardUnknown()

func (*MoudleCat1) XXX_Marshal 

func (m *MoudleCat1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MoudleCat1) XXX_Merge 

func (m *MoudleCat1) XXX_Merge(src proto.Message)

func (*MoudleCat1) XXX_Size 

func (m *MoudleCat1) XXX_Size() int

func (*MoudleCat1) XXX_Unmarshal 

func (m *MoudleCat1) XXX_Unmarshal(b []byte) error

type MulticastGroup 

type MulticastGroup struct {
	// ID (string formatted UUID).
	// This will be generated automatically on create.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Multicast-group name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Multicast address (HEX encoded DevAddr).
	McAddr string `protobuf:"bytes,3,opt,name=mc_addr,json=mcAddr,proto3" json:"mc_addr,omitempty"`
	// Multicast network session key (HEX encoded AES128 key).
	McNwkSKey string `protobuf:"bytes,4,opt,name=mc_nwk_s_key,json=mcNwkSKey,proto3" json:"mc_nwk_s_key,omitempty"`
	// Multicast application session key (HEX encoded AES128 key).
	McAppSKey string `protobuf:"bytes,5,opt,name=mc_app_s_key,json=mcAppSKey,proto3" json:"mc_app_s_key,omitempty"`
	// Frame-counter.
	FCnt uint32 `protobuf:"varint,6,opt,name=f_cnt,json=fCnt,proto3" json:"f_cnt,omitempty"`
	// Multicast type.
	GroupType MulticastGroupType `protobuf:"varint,7,opt,name=group_type,json=groupType,proto3,enum=api.MulticastGroupType" json:"group_type,omitempty"`
	// Data-rate.
	Dr uint32 `protobuf:"varint,8,opt,name=dr,proto3" json:"dr,omitempty"`
	// Frequency (Hz).
	Frequency uint32 `protobuf:"varint,9,opt,name=frequency,proto3" json:"frequency,omitempty"`
	// Ping-slot period.
	// Mandatory for Class-B multicast groups.
	PingSlotPeriod uint32 `protobuf:"varint,10,opt,name=ping_slot_period,json=pingSlotPeriod,proto3" json:"ping_slot_period,omitempty"`
	// Service-profile ID.
	// After creation, this can not be updated.
	ServiceProfileId     string   `protobuf:"bytes,11,opt,name=service_profile_id,json=serviceProfileID,proto3" json:"service_profile_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*MulticastGroup) Descriptor 

func (*MulticastGroup) Descriptor() ([]byte, []int)

func (*MulticastGroup) GetDr 

func (m *MulticastGroup) GetDr() uint32

func (*MulticastGroup) GetFCnt 

func (m *MulticastGroup) GetFCnt() uint32

func (*MulticastGroup) GetFrequency 

func (m *MulticastGroup) GetFrequency() uint32

func (*MulticastGroup) GetGroupType 

func (m *MulticastGroup) GetGroupType() MulticastGroupType

func (*MulticastGroup) GetId 

func (m *MulticastGroup) GetId() string

func (*MulticastGroup) GetMcAddr 

func (m *MulticastGroup) GetMcAddr() string

func (*MulticastGroup) GetMcAppSKey 

func (m *MulticastGroup) GetMcAppSKey() string

func (*MulticastGroup) GetMcNwkSKey 

func (m *MulticastGroup) GetMcNwkSKey() string

func (*MulticastGroup) GetName 

func (m *MulticastGroup) GetName() string

func (*MulticastGroup) GetPingSlotPeriod 

func (m *MulticastGroup) GetPingSlotPeriod() uint32

func (*MulticastGroup) GetServiceProfileId 

func (m *MulticastGroup) GetServiceProfileId() string

func (*MulticastGroup) ProtoMessage 

func (*MulticastGroup) ProtoMessage()

func (*MulticastGroup) Reset 

func (m *MulticastGroup) Reset()

func (*MulticastGroup) String 

func (m *MulticastGroup) String() string

func (*MulticastGroup) XXX_DiscardUnknown 

func (m *MulticastGroup) XXX_DiscardUnknown()

func (*MulticastGroup) XXX_Marshal 

func (m *MulticastGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MulticastGroup) XXX_Merge 

func (m *MulticastGroup) XXX_Merge(src proto.Message)

func (*MulticastGroup) XXX_Size 

func (m *MulticastGroup) XXX_Size() int

func (*MulticastGroup) XXX_Unmarshal 

func (m *MulticastGroup) XXX_Unmarshal(b []byte) error

type MulticastGroupListItem 

type MulticastGroupListItem struct {
	// ID (string formatted UUID).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Multicast-group name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Service-profile ID (string formatted UUID).
	ServiceProfileId string `protobuf:"bytes,3,opt,name=service_profile_id,json=serviceProfileID,proto3" json:"service_profile_id,omitempty"`
	// Service-profile name.
	ServiceProfileName   string   `protobuf:"bytes,4,opt,name=service_profile_name,json=serviceProfileName,proto3" json:"service_profile_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*MulticastGroupListItem) Descriptor 

func (*MulticastGroupListItem) Descriptor() ([]byte, []int)

func (*MulticastGroupListItem) GetId 

func (m *MulticastGroupListItem) GetId() string

func (*MulticastGroupListItem) GetName 

func (m *MulticastGroupListItem) GetName() string

func (*MulticastGroupListItem) GetServiceProfileId 

func (m *MulticastGroupListItem) GetServiceProfileId() string

func (*MulticastGroupListItem) GetServiceProfileName 

func (m *MulticastGroupListItem) GetServiceProfileName() string

func (*MulticastGroupListItem) ProtoMessage 

func (*MulticastGroupListItem) ProtoMessage()

func (*MulticastGroupListItem) Reset 

func (m *MulticastGroupListItem) Reset()

func (*MulticastGroupListItem) String 

func (m *MulticastGroupListItem) String() string

func (*MulticastGroupListItem) XXX_DiscardUnknown 

func (m *MulticastGroupListItem) XXX_DiscardUnknown()

func (*MulticastGroupListItem) XXX_Marshal 

func (m *MulticastGroupListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MulticastGroupListItem) XXX_Merge 

func (m *MulticastGroupListItem) XXX_Merge(src proto.Message)

func (*MulticastGroupListItem) XXX_Size 

func (m *MulticastGroupListItem) XXX_Size() int

func (*MulticastGroupListItem) XXX_Unmarshal 

func (m *MulticastGroupListItem) XXX_Unmarshal(b []byte) error

type MulticastGroupServiceClient 

type MulticastGroupServiceClient interface {
	// Create creates the given multicast-group.
	Create(ctx context.Context, in *CreateMulticastGroupRequest, opts ...grpc.CallOption) (*CreateMulticastGroupResponse, error)
	// Get returns a multicast-group given an ID.
	Get(ctx context.Context, in *GetMulticastGroupRequest, opts ...grpc.CallOption) (*GetMulticastGroupResponse, error)
	// Update updates the given multicast-group.
	Update(ctx context.Context, in *UpdateMulticastGroupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete deletes a multicast-group given an ID.
	Delete(ctx context.Context, in *DeleteMulticastGroupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List lists the available multicast-groups.
	List(ctx context.Context, in *ListMulticastGroupRequest, opts ...grpc.CallOption) (*ListMulticastGroupResponse, error)
	// AddDevice adds the given device to the multicast-group.
	AddDevice(ctx context.Context, in *AddDeviceToMulticastGroupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// RemoveDevice removes the given device from the multicast-group.
	RemoveDevice(ctx context.Context, in *RemoveDeviceFromMulticastGroupRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Enqueue adds the given item to the multicast-queue.
	Enqueue(ctx context.Context, in *EnqueueMulticastQueueItemRequest, opts ...grpc.CallOption) (*EnqueueMulticastQueueItemResponse, error)
	// FlushQueue flushes the multicast-group queue.
	FlushQueue(ctx context.Context, in *FlushMulticastGroupQueueItemsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// ListQueue lists the items in the multicast-group queue.
	ListQueue(ctx context.Context, in *ListMulticastGroupQueueItemsRequest, opts ...grpc.CallOption) (*ListMulticastGroupQueueItemsResponse, error)
}

MulticastGroupServiceClient is the client API for MulticastGroupService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewMulticastGroupServiceClient 

func NewMulticastGroupServiceClient(cc grpc.ClientConnInterface) MulticastGroupServiceClient

type MulticastGroupServiceServer 

type MulticastGroupServiceServer interface {
	// Create creates the given multicast-group.
	Create(context.Context, *CreateMulticastGroupRequest) (*CreateMulticastGroupResponse, error)
	// Get returns a multicast-group given an ID.
	Get(context.Context, *GetMulticastGroupRequest) (*GetMulticastGroupResponse, error)
	// Update updates the given multicast-group.
	Update(context.Context, *UpdateMulticastGroupRequest) (*emptypb.Empty, error)
	// Delete deletes a multicast-group given an ID.
	Delete(context.Context, *DeleteMulticastGroupRequest) (*emptypb.Empty, error)
	// List lists the available multicast-groups.
	List(context.Context, *ListMulticastGroupRequest) (*ListMulticastGroupResponse, error)
	// AddDevice adds the given device to the multicast-group.
	AddDevice(context.Context, *AddDeviceToMulticastGroupRequest) (*emptypb.Empty, error)
	// RemoveDevice removes the given device from the multicast-group.
	RemoveDevice(context.Context, *RemoveDeviceFromMulticastGroupRequest) (*emptypb.Empty, error)
	// Enqueue adds the given item to the multicast-queue.
	Enqueue(context.Context, *EnqueueMulticastQueueItemRequest) (*EnqueueMulticastQueueItemResponse, error)
	// FlushQueue flushes the multicast-group queue.
	FlushQueue(context.Context, *FlushMulticastGroupQueueItemsRequest) (*emptypb.Empty, error)
	// ListQueue lists the items in the multicast-group queue.
	ListQueue(context.Context, *ListMulticastGroupQueueItemsRequest) (*ListMulticastGroupQueueItemsResponse, error)
}

MulticastGroupServiceServer is the server API for MulticastGroupService service.

type MulticastGroupType 

type MulticastGroupType int32
const (
	// Class-C.
	MulticastGroupType_CLASS_C MulticastGroupType = 0
	// Class-B.
	MulticastGroupType_CLASS_B MulticastGroupType = 1
)

func (MulticastGroupType) EnumDescriptor 

func (MulticastGroupType) EnumDescriptor() ([]byte, []int)

func (MulticastGroupType) String 

func (x MulticastGroupType) String() string

type MulticastQueueItem 

type MulticastQueueItem struct {
	// Multicast-group ID (string formatted UUID).
	MulticastGroupId string `protobuf:"bytes,1,opt,name=multicast_group_id,json=multicastGroupID,proto3" json:"multicast_group_id,omitempty"`
	// Downlink frame-counter.
	// This will be automatically set on enqueue.
	FCnt uint32 `protobuf:"varint,2,opt,name=f_cnt,json=fCnt,proto3" json:"f_cnt,omitempty"`
	// FPort used (must be > 0).
	FPort uint32 `protobuf:"varint,3,opt,name=f_port,json=fPort,proto3" json:"f_port,omitempty"`
	// Base64 encoded data.
	Data                 []byte   `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*MulticastQueueItem) Descriptor 

func (*MulticastQueueItem) Descriptor() ([]byte, []int)

func (*MulticastQueueItem) GetData 

func (m *MulticastQueueItem) GetData() []byte

func (*MulticastQueueItem) GetFCnt 

func (m *MulticastQueueItem) GetFCnt() uint32

func (*MulticastQueueItem) GetFPort 

func (m *MulticastQueueItem) GetFPort() uint32

func (*MulticastQueueItem) GetMulticastGroupId 

func (m *MulticastQueueItem) GetMulticastGroupId() string

func (*MulticastQueueItem) ProtoMessage 

func (*MulticastQueueItem) ProtoMessage()

func (*MulticastQueueItem) Reset 

func (m *MulticastQueueItem) Reset()

func (*MulticastQueueItem) String 

func (m *MulticastQueueItem) String() string

func (*MulticastQueueItem) XXX_DiscardUnknown 

func (m *MulticastQueueItem) XXX_DiscardUnknown()

func (*MulticastQueueItem) XXX_Marshal 

func (m *MulticastQueueItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MulticastQueueItem) XXX_Merge 

func (m *MulticastQueueItem) XXX_Merge(src proto.Message)

func (*MulticastQueueItem) XXX_Size 

func (m *MulticastQueueItem) XXX_Size() int

func (*MulticastQueueItem) XXX_Unmarshal 

func (m *MulticastQueueItem) XXX_Unmarshal(b []byte) error

type MyDevicesIntegration 

type MyDevicesIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// MyDevices API endpoint.
	Endpoint             string   `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*MyDevicesIntegration) Descriptor 

func (*MyDevicesIntegration) Descriptor() ([]byte, []int)

func (*MyDevicesIntegration) GetApplicationId 

func (m *MyDevicesIntegration) GetApplicationId() int64

func (*MyDevicesIntegration) GetEndpoint 

func (m *MyDevicesIntegration) GetEndpoint() string

func (*MyDevicesIntegration) ProtoMessage 

func (*MyDevicesIntegration) ProtoMessage()

func (*MyDevicesIntegration) Reset 

func (m *MyDevicesIntegration) Reset()

func (*MyDevicesIntegration) String 

func (m *MyDevicesIntegration) String() string

func (*MyDevicesIntegration) XXX_DiscardUnknown 

func (m *MyDevicesIntegration) XXX_DiscardUnknown()

func (*MyDevicesIntegration) XXX_Marshal 

func (m *MyDevicesIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MyDevicesIntegration) XXX_Merge 

func (m *MyDevicesIntegration) XXX_Merge(src proto.Message)

func (*MyDevicesIntegration) XXX_Size 

func (m *MyDevicesIntegration) XXX_Size() int

func (*MyDevicesIntegration) XXX_Unmarshal 

func (m *MyDevicesIntegration) XXX_Unmarshal(b []byte) error

type NSADR 

type NSADR struct {
	Enable               bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	DrIdMin              int32    `protobuf:"varint,2,opt,name=drIdMin,proto3" json:"drIdMin,omitempty"`
	DrIdMax              int32    `protobuf:"varint,3,opt,name=drIdMax,proto3" json:"drIdMax,omitempty"`
	Margin               int32    `protobuf:"varint,5,opt,name=margin,proto3" json:"margin,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*NSADR) Descriptor 

func (*NSADR) Descriptor() ([]byte, []int)

func (*NSADR) GetDrIdMax 

func (m *NSADR) GetDrIdMax() int32

func (*NSADR) GetDrIdMin 

func (m *NSADR) GetDrIdMin() int32

func (*NSADR) GetEnable 

func (m *NSADR) GetEnable() bool

func (*NSADR) GetMargin 

func (m *NSADR) GetMargin() int32

func (*NSADR) ProtoMessage 

func (*NSADR) ProtoMessage()

func (*NSADR) Reset 

func (m *NSADR) Reset()

func (*NSADR) String 

func (m *NSADR) String() string

func (*NSADR) XXX_DiscardUnknown 

func (m *NSADR) XXX_DiscardUnknown()

func (*NSADR) XXX_Marshal 

func (m *NSADR) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*NSADR) XXX_Merge 

func (m *NSADR) XXX_Merge(src proto.Message)

func (*NSADR) XXX_Size 

func (m *NSADR) XXX_Size() int

func (*NSADR) XXX_Unmarshal 

func (m *NSADR) XXX_Unmarshal(b []byte) error

type NSDwellTimeLimit 

type NSDwellTimeLimit struct {
	Uplink               int32    `protobuf:"varint,1,opt,name=uplink,proto3" json:"uplink,omitempty"`
	Downlink             int32    `protobuf:"varint,2,opt,name=downlink,proto3" json:"downlink,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*NSDwellTimeLimit) Descriptor 

func (*NSDwellTimeLimit) Descriptor() ([]byte, []int)
func (m *NSDwellTimeLimit) GetDownlink() int32
func (m *NSDwellTimeLimit) GetUplink() int32

func (*NSDwellTimeLimit) ProtoMessage 

func (*NSDwellTimeLimit) ProtoMessage()

func (*NSDwellTimeLimit) Reset 

func (m *NSDwellTimeLimit) Reset()

func (*NSDwellTimeLimit) String 

func (m *NSDwellTimeLimit) String() string

func (*NSDwellTimeLimit) XXX_DiscardUnknown 

func (m *NSDwellTimeLimit) XXX_DiscardUnknown()

func (*NSDwellTimeLimit) XXX_Marshal 

func (m *NSDwellTimeLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*NSDwellTimeLimit) XXX_Merge 

func (m *NSDwellTimeLimit) XXX_Merge(src proto.Message)

func (*NSDwellTimeLimit) XXX_Size 

func (m *NSDwellTimeLimit) XXX_Size() int

func (*NSDwellTimeLimit) XXX_Unmarshal 

func (m *NSDwellTimeLimit) XXX_Unmarshal(b []byte) error

type NSRX1 

type NSRX1 struct {
	DrOffset             int32    `protobuf:"varint,1,opt,name=drOffset,proto3" json:"drOffset,omitempty"`
	Delay                int32    `protobuf:"varint,2,opt,name=delay,proto3" json:"delay,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*NSRX1) Descriptor 

func (*NSRX1) Descriptor() ([]byte, []int)

func (*NSRX1) GetDelay 

func (m *NSRX1) GetDelay() int32

func (*NSRX1) GetDrOffset 

func (m *NSRX1) GetDrOffset() int32

func (*NSRX1) ProtoMessage 

func (*NSRX1) ProtoMessage()

func (*NSRX1) Reset 

func (m *NSRX1) Reset()

func (*NSRX1) String 

func (m *NSRX1) String() string

func (*NSRX1) XXX_DiscardUnknown 

func (m *NSRX1) XXX_DiscardUnknown()

func (*NSRX1) XXX_Marshal 

func (m *NSRX1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*NSRX1) XXX_Merge 

func (m *NSRX1) XXX_Merge(src proto.Message)

func (*NSRX1) XXX_Size 

func (m *NSRX1) XXX_Size() int

func (*NSRX1) XXX_Unmarshal 

func (m *NSRX1) XXX_Unmarshal(b []byte) error

type NSRX2 

type NSRX2 struct {
	Freq                 int32    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	DrIndex              int32    `protobuf:"varint,2,opt,name=drIndex,proto3" json:"drIndex,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*NSRX2) Descriptor 

func (*NSRX2) Descriptor() ([]byte, []int)

func (*NSRX2) GetDrIndex 

func (m *NSRX2) GetDrIndex() int32

func (*NSRX2) GetFreq 

func (m *NSRX2) GetFreq() int32

func (*NSRX2) ProtoMessage 

func (*NSRX2) ProtoMessage()

func (*NSRX2) Reset 

func (m *NSRX2) Reset()

func (*NSRX2) String 

func (m *NSRX2) String() string

func (*NSRX2) XXX_DiscardUnknown 

func (m *NSRX2) XXX_DiscardUnknown()

func (*NSRX2) XXX_Marshal 

func (m *NSRX2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*NSRX2) XXX_Merge 

func (m *NSRX2) XXX_Merge(src proto.Message)

func (*NSRX2) XXX_Size 

func (m *NSRX2) XXX_Size() int

func (*NSRX2) XXX_Unmarshal 

func (m *NSRX2) XXX_Unmarshal(b []byte) error

type NTPConfig 

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 (*NTPConfig) Descriptor 

func (*NTPConfig) Descriptor() ([]byte, []int)

func (*NTPConfig) GetNtpServer1 

func (m *NTPConfig) GetNtpServer1() string

func (*NTPConfig) GetNtpServer2 

func (m *NTPConfig) GetNtpServer2() string

func (*NTPConfig) GetNtpServer3 

func (m *NTPConfig) GetNtpServer3() string

func (*NTPConfig) GetNtpServer4 

func (m *NTPConfig) GetNtpServer4() string

func (*NTPConfig) ProtoMessage 

func (*NTPConfig) ProtoMessage()

func (*NTPConfig) Reset 

func (m *NTPConfig) Reset()

func (*NTPConfig) String 

func (m *NTPConfig) String() string

func (*NTPConfig) XXX_DiscardUnknown 

func (m *NTPConfig) XXX_DiscardUnknown()

func (*NTPConfig) XXX_Marshal 

func (m *NTPConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*NTPConfig) XXX_Merge 

func (m *NTPConfig) XXX_Merge(src proto.Message)

func (*NTPConfig) XXX_Size 

func (m *NTPConfig) XXX_Size() int

func (*NTPConfig) XXX_Unmarshal 

func (m *NTPConfig) XXX_Unmarshal(b []byte) error

type NetworkServer 

type NetworkServer struct {
	// Network-server ID.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Network-server name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Network-server server.
	// Format: hostname:ip (e.g. localhost:8000).
	Server string `protobuf:"bytes,3,opt,name=server,proto3" json:"server,omitempty"`
	// CA certificate (optional).
	CaCert string `protobuf:"bytes,4,opt,name=ca_cert,json=caCert,proto3" json:"ca_cert,omitempty"`
	// TLS (client) certificate for connecting to the network-server (optional).
	TlsCert string `protobuf:"bytes,5,opt,name=tls_cert,json=tlsCert,proto3" json:"tls_cert,omitempty"`
	// TLS (client) key for connecting to the network-server (optional).
	TlsKey string `protobuf:"bytes,6,opt,name=tls_key,json=tlsKey,proto3" json:"tls_key,omitempty"`
	// Routing-profile ca certificate (used by the network-server to connect
	// back to the application-server) (optional).
	RoutingProfileCaCert string `protobuf:"bytes,7,opt,name=routing_profile_ca_cert,json=routingProfileCACert,proto3" json:"routing_profile_ca_cert,omitempty"`
	// Routing-profile TLS certificate (used by the network-server to connect
	// back to the application-server) (optional).
	RoutingProfileTlsCert string `` /* 128-byte string literal not displayed */
	// Routing-profile TLS key (used by the network-server to connect
	// back to the application-server) (optional).
	RoutingProfileTlsKey string `protobuf:"bytes,9,opt,name=routing_profile_tls_key,json=routingProfileTLSKey,proto3" json:"routing_profile_tls_key,omitempty"`
	// Enable gateway discovery for this network-server.
	GatewayDiscoveryEnabled bool `` /* 134-byte string literal not displayed */
	// The number of times per day the gateway discovery 'ping' must be
	// broadcasted per gateway.
	GatewayDiscoveryInterval uint32 `` /* 137-byte string literal not displayed */
	// The frequency (Hz) of the gateway discovery 'ping'.
	GatewayDiscoveryTxFrequency uint32 `` /* 148-byte string literal not displayed */
	// The data-rate of the gateway discovery 'ping'.
	GatewayDiscoveryDr   uint32   `protobuf:"varint,13,opt,name=gateway_discovery_dr,json=gatewayDiscoveryDR,proto3" json:"gateway_discovery_dr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*NetworkServer) Descriptor 

func (*NetworkServer) Descriptor() ([]byte, []int)

func (*NetworkServer) GetCaCert 

func (m *NetworkServer) GetCaCert() string

func (*NetworkServer) GetGatewayDiscoveryDr 

func (m *NetworkServer) GetGatewayDiscoveryDr() uint32

func (*NetworkServer) GetGatewayDiscoveryEnabled 

func (m *NetworkServer) GetGatewayDiscoveryEnabled() bool

func (*NetworkServer) GetGatewayDiscoveryInterval 

func (m *NetworkServer) GetGatewayDiscoveryInterval() uint32

func (*NetworkServer) GetGatewayDiscoveryTxFrequency 

func (m *NetworkServer) GetGatewayDiscoveryTxFrequency() uint32

func (*NetworkServer) GetId 

func (m *NetworkServer) GetId() int64

func (*NetworkServer) GetName 

func (m *NetworkServer) GetName() string

func (*NetworkServer) GetRoutingProfileCaCert 

func (m *NetworkServer) GetRoutingProfileCaCert() string

func (*NetworkServer) GetRoutingProfileTlsCert 

func (m *NetworkServer) GetRoutingProfileTlsCert() string

func (*NetworkServer) GetRoutingProfileTlsKey 

func (m *NetworkServer) GetRoutingProfileTlsKey() string

func (*NetworkServer) GetServer 

func (m *NetworkServer) GetServer() string

func (*NetworkServer) GetTlsCert 

func (m *NetworkServer) GetTlsCert() string

func (*NetworkServer) GetTlsKey 

func (m *NetworkServer) GetTlsKey() string

func (*NetworkServer) ProtoMessage 

func (*NetworkServer) ProtoMessage()

func (*NetworkServer) Reset 

func (m *NetworkServer) Reset()

func (*NetworkServer) String 

func (m *NetworkServer) String() string

func (*NetworkServer) XXX_DiscardUnknown 

func (m *NetworkServer) XXX_DiscardUnknown()

func (*NetworkServer) XXX_Marshal 

func (m *NetworkServer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*NetworkServer) XXX_Merge 

func (m *NetworkServer) XXX_Merge(src proto.Message)

func (*NetworkServer) XXX_Size 

func (m *NetworkServer) XXX_Size() int

func (*NetworkServer) XXX_Unmarshal 

func (m *NetworkServer) XXX_Unmarshal(b []byte) error

type NetworkServerListItem 

type NetworkServerListItem struct {
	// Network-server ID.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Network-server name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Network-server server.
	// Format: hostname:ip (e.g. localhost:8000).
	Server string `protobuf:"bytes,3,opt,name=server,proto3" json:"server,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*NetworkServerListItem) Descriptor 

func (*NetworkServerListItem) Descriptor() ([]byte, []int)

func (*NetworkServerListItem) GetCreatedAt 

func (m *NetworkServerListItem) GetCreatedAt() *timestamppb.Timestamp

func (*NetworkServerListItem) GetId 

func (m *NetworkServerListItem) GetId() int64

func (*NetworkServerListItem) GetName 

func (m *NetworkServerListItem) GetName() string

func (*NetworkServerListItem) GetServer 

func (m *NetworkServerListItem) GetServer() string

func (*NetworkServerListItem) GetUpdatedAt 

func (m *NetworkServerListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*NetworkServerListItem) ProtoMessage 

func (*NetworkServerListItem) ProtoMessage()

func (*NetworkServerListItem) Reset 

func (m *NetworkServerListItem) Reset()

func (*NetworkServerListItem) String 

func (m *NetworkServerListItem) String() string

func (*NetworkServerListItem) XXX_DiscardUnknown 

func (m *NetworkServerListItem) XXX_DiscardUnknown()

func (*NetworkServerListItem) XXX_Marshal 

func (m *NetworkServerListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*NetworkServerListItem) XXX_Merge 

func (m *NetworkServerListItem) XXX_Merge(src proto.Message)

func (*NetworkServerListItem) XXX_Size 

func (m *NetworkServerListItem) XXX_Size() int

func (*NetworkServerListItem) XXX_Unmarshal 

func (m *NetworkServerListItem) XXX_Unmarshal(b []byte) error

type NetworkServerServiceClient 

type NetworkServerServiceClient interface {
	// Create creates the given network-server.
	Create(ctx context.Context, in *CreateNetworkServerRequest, opts ...grpc.CallOption) (*CreateNetworkServerResponse, error)
	// Get returns the network-server matching the given id.
	Get(ctx context.Context, in *GetNetworkServerRequest, opts ...grpc.CallOption) (*GetNetworkServerResponse, error)
	// Update updates the given network-server.
	Update(ctx context.Context, in *UpdateNetworkServerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete deletes the network-server matching the given id.
	Delete(ctx context.Context, in *DeleteNetworkServerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List lists the available network-servers.
	List(ctx context.Context, in *ListNetworkServerRequest, opts ...grpc.CallOption) (*ListNetworkServerResponse, error)
}

NetworkServerServiceClient is the client API for NetworkServerService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewNetworkServerServiceClient 

func NewNetworkServerServiceClient(cc grpc.ClientConnInterface) NetworkServerServiceClient

type NetworkServerServiceServer 

type NetworkServerServiceServer interface {
	// Create creates the given network-server.
	Create(context.Context, *CreateNetworkServerRequest) (*CreateNetworkServerResponse, error)
	// Get returns the network-server matching the given id.
	Get(context.Context, *GetNetworkServerRequest) (*GetNetworkServerResponse, error)
	// Update updates the given network-server.
	Update(context.Context, *UpdateNetworkServerRequest) (*emptypb.Empty, error)
	// Delete deletes the network-server matching the given id.
	Delete(context.Context, *DeleteNetworkServerRequest) (*emptypb.Empty, error)
	// List lists the available network-servers.
	List(context.Context, *ListNetworkServerRequest) (*ListNetworkServerResponse, error)
}

NetworkServerServiceServer is the server API for NetworkServerService service.

type NetworkServiceClient 

type NetworkServiceClient interface {
	GetClient(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetClientResponse, error)
	SetClient(ctx context.Context, in *SetClientRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	SetCat1(ctx context.Context, in *Cat1Request, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetCat1(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Cat1Response, error)
	SetEthernet(ctx context.Context, in *EthernetRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetEthernet(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*EthernetResponse, error)
	SetWiFi(ctx context.Context, in *WiFiRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetWiFi(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*WiFiResponse, error)
	GetWiFiList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*WiFiListResponse, error)
	GetWiFiConfiguration(ctx context.Context, in *GetWiFiConfigurationRequest, opts ...grpc.CallOption) (*GetWiFiConfigurationResponse, error)
	GetEncryptList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*EncryptListResponse, error)
}

NetworkServiceClient is the client API for NetworkService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewNetworkServiceClient 

func NewNetworkServiceClient(cc grpc.ClientConnInterface) NetworkServiceClient

type NetworkServiceServer 

type NetworkServiceServer interface {
	GetClient(context.Context, *emptypb.Empty) (*GetClientResponse, error)
	SetClient(context.Context, *SetClientRequest) (*emptypb.Empty, error)
	SetCat1(context.Context, *Cat1Request) (*emptypb.Empty, error)
	GetCat1(context.Context, *emptypb.Empty) (*Cat1Response, error)
	SetEthernet(context.Context, *EthernetRequest) (*emptypb.Empty, error)
	GetEthernet(context.Context, *emptypb.Empty) (*EthernetResponse, error)
	SetWiFi(context.Context, *WiFiRequest) (*emptypb.Empty, error)
	GetWiFi(context.Context, *emptypb.Empty) (*WiFiResponse, error)
	GetWiFiList(context.Context, *emptypb.Empty) (*WiFiListResponse, error)
	GetWiFiConfiguration(context.Context, *GetWiFiConfigurationRequest) (*GetWiFiConfigurationResponse, error)
	GetEncryptList(context.Context, *emptypb.Empty) (*EncryptListResponse, error)
}

NetworkServiceServer is the server API for NetworkService service.

type OTAADevice 

type OTAADevice struct {
	ApplicationId        int64    `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	DevEui               string   `protobuf:"bytes,3,opt,name=dev_eui,json=DEVEUI,proto3" json:"dev_eui,omitempty"`
	Mac                  string   `protobuf:"bytes,4,opt,name=mac,json=MAC,proto3" json:"mac,omitempty"`
	Type                 string   `protobuf:"bytes,5,opt,name=type,json=TYPE,proto3" json:"type,omitempty"`
	SkipFCntCheck        bool     `protobuf:"varint,6,opt,name=skip_f_cnt_check,json=skipFCntCheck,proto3" json:"skip_f_cnt_check,omitempty"`
	AppEui               string   `protobuf:"bytes,7,opt,name=app_eui,json=APPEUI,proto3" json:"app_eui,omitempty"`
	Appkey               string   `protobuf:"bytes,8,opt,name=appkey,json=APPKEY,proto3" json:"appkey,omitempty"`
	IsDisabled           bool     `protobuf:"varint,10,opt,name=is_disabled,json=isDisabled,proto3" json:"is_disabled,omitempty"`
	Description          string   `protobuf:"bytes,11,opt,name=description,proto3" json:"description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*OTAADevice) Descriptor 

func (*OTAADevice) Descriptor() ([]byte, []int)

func (*OTAADevice) GetAppEui 

func (m *OTAADevice) GetAppEui() string

func (*OTAADevice) GetAppkey 

func (m *OTAADevice) GetAppkey() string

func (*OTAADevice) GetApplicationId 

func (m *OTAADevice) GetApplicationId() int64

func (*OTAADevice) GetDescription 

func (m *OTAADevice) GetDescription() string

func (*OTAADevice) GetDevEui 

func (m *OTAADevice) GetDevEui() string

func (*OTAADevice) GetIsDisabled 

func (m *OTAADevice) GetIsDisabled() bool

func (*OTAADevice) GetMac 

func (m *OTAADevice) GetMac() string

func (*OTAADevice) GetName 

func (m *OTAADevice) GetName() string

func (*OTAADevice) GetSkipFCntCheck 

func (m *OTAADevice) GetSkipFCntCheck() bool

func (*OTAADevice) GetType 

func (m *OTAADevice) GetType() string

func (*OTAADevice) ProtoMessage 

func (*OTAADevice) ProtoMessage()

func (*OTAADevice) Reset 

func (m *OTAADevice) Reset()

func (*OTAADevice) String 

func (m *OTAADevice) String() string

func (*OTAADevice) XXX_DiscardUnknown 

func (m *OTAADevice) XXX_DiscardUnknown()

func (*OTAADevice) XXX_Marshal 

func (m *OTAADevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OTAADevice) XXX_Merge 

func (m *OTAADevice) XXX_Merge(src proto.Message)

func (*OTAADevice) XXX_Size 

func (m *OTAADevice) XXX_Size() int

func (*OTAADevice) XXX_Unmarshal 

func (m *OTAADevice) XXX_Unmarshal(b []byte) error

type OTPBLOCK 

type OTPBLOCK struct {
	Id                   int32    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Addr                 int32    `protobuf:"varint,2,opt,name=addr,proto3" json:"addr,omitempty"`
	SetStatus            bool     `protobuf:"varint,3,opt,name=set_status,json=setStatus,proto3" json:"set_status,omitempty"`
	Data                 []uint32 `protobuf:"varint,4,rep,packed,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*OTPBLOCK) Descriptor 

func (*OTPBLOCK) Descriptor() ([]byte, []int)

func (*OTPBLOCK) GetAddr 

func (m *OTPBLOCK) GetAddr() int32

func (*OTPBLOCK) GetData 

func (m *OTPBLOCK) GetData() []uint32

func (*OTPBLOCK) GetId 

func (m *OTPBLOCK) GetId() int32

func (*OTPBLOCK) GetSetStatus 

func (m *OTPBLOCK) GetSetStatus() bool

func (*OTPBLOCK) ProtoMessage 

func (*OTPBLOCK) ProtoMessage()

func (*OTPBLOCK) Reset 

func (m *OTPBLOCK) Reset()

func (*OTPBLOCK) String 

func (m *OTPBLOCK) String() string

func (*OTPBLOCK) XXX_DiscardUnknown 

func (m *OTPBLOCK) XXX_DiscardUnknown()

func (*OTPBLOCK) XXX_Marshal 

func (m *OTPBLOCK) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OTPBLOCK) XXX_Merge 

func (m *OTPBLOCK) XXX_Merge(src proto.Message)

func (*OTPBLOCK) XXX_Size 

func (m *OTPBLOCK) XXX_Size() int

func (*OTPBLOCK) XXX_Unmarshal 

func (m *OTPBLOCK) XXX_Unmarshal(b []byte) error

type OTPServiceClient 

type OTPServiceClient interface {
	// Get data for a particular user.
	Get(ctx context.Context, in *GetOTPRequest, opts ...grpc.CallOption) (*GetOTPResponse, error)
	Set(ctx context.Context, in *SetOTPRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	List(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListOTPResponse, error)
	SET_SECURE_OTP_BLOCK0(ctx context.Context, in *BLOCK0Request, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GET_SECURE_OTP_BLOCK0(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*BLOCK0Response, error)
	EncryptSN(ctx context.Context, in *EncryptSNRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetEncryptSN(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*EncryptSNResponse, error)
}

OTPServiceClient is the client API for OTPService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewOTPServiceClient 

func NewOTPServiceClient(cc grpc.ClientConnInterface) OTPServiceClient

type OTPServiceServer 

type OTPServiceServer interface {
	// Get data for a particular user.
	Get(context.Context, *GetOTPRequest) (*GetOTPResponse, error)
	Set(context.Context, *SetOTPRequest) (*emptypb.Empty, error)
	List(context.Context, *emptypb.Empty) (*ListOTPResponse, error)
	SET_SECURE_OTP_BLOCK0(context.Context, *BLOCK0Request) (*emptypb.Empty, error)
	GET_SECURE_OTP_BLOCK0(context.Context, *emptypb.Empty) (*BLOCK0Response, error)
	EncryptSN(context.Context, *EncryptSNRequest) (*emptypb.Empty, error)
	GetEncryptSN(context.Context, *emptypb.Empty) (*EncryptSNResponse, error)
}

OTPServiceServer is the server API for OTPService service.

type OpenIDConnect 

type OpenIDConnect struct {
	// Enable OpenID Connect authentication.
	Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// Login url.
	LoginUrl string `protobuf:"bytes,2,opt,name=login_url,json=loginURL,proto3" json:"login_url,omitempty"`
	// Login label.
	LoginLabel string `protobuf:"bytes,3,opt,name=login_label,json=loginLabel,proto3" json:"login_label,omitempty"`
	// Logout url.
	LogoutUrl            string   `protobuf:"bytes,4,opt,name=logout_url,json=logoutURL,proto3" json:"logout_url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*OpenIDConnect) Descriptor 

func (*OpenIDConnect) Descriptor() ([]byte, []int)

func (*OpenIDConnect) GetEnabled 

func (m *OpenIDConnect) GetEnabled() bool

func (*OpenIDConnect) GetLoginLabel 

func (m *OpenIDConnect) GetLoginLabel() string

func (*OpenIDConnect) GetLoginUrl 

func (m *OpenIDConnect) GetLoginUrl() string

func (*OpenIDConnect) GetLogoutUrl 

func (m *OpenIDConnect) GetLogoutUrl() string

func (*OpenIDConnect) ProtoMessage 

func (*OpenIDConnect) ProtoMessage()

func (*OpenIDConnect) Reset 

func (m *OpenIDConnect) Reset()

func (*OpenIDConnect) String 

func (m *OpenIDConnect) String() string

func (*OpenIDConnect) XXX_DiscardUnknown 

func (m *OpenIDConnect) XXX_DiscardUnknown()

func (*OpenIDConnect) XXX_Marshal 

func (m *OpenIDConnect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OpenIDConnect) XXX_Merge 

func (m *OpenIDConnect) XXX_Merge(src proto.Message)

func (*OpenIDConnect) XXX_Size 

func (m *OpenIDConnect) XXX_Size() int

func (*OpenIDConnect) XXX_Unmarshal 

func (m *OpenIDConnect) XXX_Unmarshal(b []byte) error

type OpenIDConnectLoginRequest 

type OpenIDConnectLoginRequest struct {
	// OpenID Connect callback code.
	Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	// OpenID Connect callback state.
	State                string   `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*OpenIDConnectLoginRequest) Descriptor 

func (*OpenIDConnectLoginRequest) Descriptor() ([]byte, []int)

func (*OpenIDConnectLoginRequest) GetCode 

func (m *OpenIDConnectLoginRequest) GetCode() string

func (*OpenIDConnectLoginRequest) GetState 

func (m *OpenIDConnectLoginRequest) GetState() string

func (*OpenIDConnectLoginRequest) ProtoMessage 

func (*OpenIDConnectLoginRequest) ProtoMessage()

func (*OpenIDConnectLoginRequest) Reset 

func (m *OpenIDConnectLoginRequest) Reset()

func (*OpenIDConnectLoginRequest) String 

func (m *OpenIDConnectLoginRequest) String() string

func (*OpenIDConnectLoginRequest) XXX_DiscardUnknown 

func (m *OpenIDConnectLoginRequest) XXX_DiscardUnknown()

func (*OpenIDConnectLoginRequest) XXX_Marshal 

func (m *OpenIDConnectLoginRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OpenIDConnectLoginRequest) XXX_Merge 

func (m *OpenIDConnectLoginRequest) XXX_Merge(src proto.Message)

func (*OpenIDConnectLoginRequest) XXX_Size 

func (m *OpenIDConnectLoginRequest) XXX_Size() int

func (*OpenIDConnectLoginRequest) XXX_Unmarshal 

func (m *OpenIDConnectLoginRequest) XXX_Unmarshal(b []byte) error

type OpenIDConnectLoginResponse 

type OpenIDConnectLoginResponse struct {
	// JWT token to use for authentication.
	JwtToken             string   `protobuf:"bytes,1,opt,name=jwt_token,json=jwtToken,proto3" json:"jwt_token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*OpenIDConnectLoginResponse) Descriptor 

func (*OpenIDConnectLoginResponse) Descriptor() ([]byte, []int)

func (*OpenIDConnectLoginResponse) GetJwtToken 

func (m *OpenIDConnectLoginResponse) GetJwtToken() string

func (*OpenIDConnectLoginResponse) ProtoMessage 

func (*OpenIDConnectLoginResponse) ProtoMessage()

func (*OpenIDConnectLoginResponse) Reset 

func (m *OpenIDConnectLoginResponse) Reset()

func (*OpenIDConnectLoginResponse) String 

func (m *OpenIDConnectLoginResponse) String() string

func (*OpenIDConnectLoginResponse) XXX_DiscardUnknown 

func (m *OpenIDConnectLoginResponse) XXX_DiscardUnknown()

func (*OpenIDConnectLoginResponse) XXX_Marshal 

func (m *OpenIDConnectLoginResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OpenIDConnectLoginResponse) XXX_Merge 

func (m *OpenIDConnectLoginResponse) XXX_Merge(src proto.Message)

func (*OpenIDConnectLoginResponse) XXX_Size 

func (m *OpenIDConnectLoginResponse) XXX_Size() int

func (*OpenIDConnectLoginResponse) XXX_Unmarshal 

func (m *OpenIDConnectLoginResponse) XXX_Unmarshal(b []byte) error

type Organization 

type Organization struct {
	// Organization ID.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Organization name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Organization display name.
	DisplayName string `protobuf:"bytes,3,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// Can the organization create and "own" Gateways?
	CanHaveGateways bool `protobuf:"varint,4,opt,name=can_have_gateways,json=canHaveGateways,proto3" json:"can_have_gateways,omitempty"`
	// Max. gateway count for organization.
	// When set to 0, the organization can have unlimited gateways.
	MaxGatewayCount uint32 `protobuf:"varint,5,opt,name=max_gateway_count,json=maxGatewayCount,proto3" json:"max_gateway_count,omitempty"`
	// Max. device count for organization.
	// When set to 0, the organization can have unlimited devices.
	MaxDeviceCount       uint32   `protobuf:"varint,6,opt,name=max_device_count,json=maxDeviceCount,proto3" json:"max_device_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*Organization) Descriptor 

func (*Organization) Descriptor() ([]byte, []int)

func (*Organization) GetCanHaveGateways 

func (m *Organization) GetCanHaveGateways() bool

func (*Organization) GetDisplayName 

func (m *Organization) GetDisplayName() string

func (*Organization) GetId 

func (m *Organization) GetId() int64

func (*Organization) GetMaxDeviceCount 

func (m *Organization) GetMaxDeviceCount() uint32

func (*Organization) GetMaxGatewayCount 

func (m *Organization) GetMaxGatewayCount() uint32

func (*Organization) GetName 

func (m *Organization) GetName() string

func (*Organization) ProtoMessage 

func (*Organization) ProtoMessage()

func (*Organization) Reset 

func (m *Organization) Reset()

func (*Organization) String 

func (m *Organization) String() string

func (*Organization) XXX_DiscardUnknown 

func (m *Organization) XXX_DiscardUnknown()

func (*Organization) XXX_Marshal 

func (m *Organization) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Organization) XXX_Merge 

func (m *Organization) XXX_Merge(src proto.Message)

func (*Organization) XXX_Size 

func (m *Organization) XXX_Size() int

func (*Organization) XXX_Unmarshal 

func (m *Organization) XXX_Unmarshal(b []byte) error
type OrganizationLink struct {
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Organization name.
	OrganizationName string `protobuf:"bytes,2,opt,name=organization_name,json=organizationName,proto3" json:"organization_name,omitempty"`
	// User is admin within the context of this organization.
	// There is no need to set the is_device_admin and is_gateway_admin flags.
	IsAdmin bool `protobuf:"varint,3,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// User is able to modify device related resources (applications,
	// device-profiles, devices, multicast-groups).
	IsDeviceAdmin bool `protobuf:"varint,6,opt,name=is_device_admin,json=isDeviceAdmin,proto3" json:"is_device_admin,omitempty"`
	// User is able to modify gateways.
	IsGatewayAdmin bool `protobuf:"varint,7,opt,name=is_gateway_admin,json=isGatewayAdmin,proto3" json:"is_gateway_admin,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

Defines an organization to which an user is associated.

func (*OrganizationLink) Descriptor 

func (*OrganizationLink) Descriptor() ([]byte, []int)

func (*OrganizationLink) GetCreatedAt 

func (m *OrganizationLink) GetCreatedAt() *timestamppb.Timestamp

func (*OrganizationLink) GetIsAdmin 

func (m *OrganizationLink) GetIsAdmin() bool

func (*OrganizationLink) GetIsDeviceAdmin 

func (m *OrganizationLink) GetIsDeviceAdmin() bool

func (*OrganizationLink) GetIsGatewayAdmin 

func (m *OrganizationLink) GetIsGatewayAdmin() bool

func (*OrganizationLink) GetOrganizationId 

func (m *OrganizationLink) GetOrganizationId() int64

func (*OrganizationLink) GetOrganizationName 

func (m *OrganizationLink) GetOrganizationName() string

func (*OrganizationLink) GetUpdatedAt 

func (m *OrganizationLink) GetUpdatedAt() *timestamppb.Timestamp

func (*OrganizationLink) ProtoMessage 

func (*OrganizationLink) ProtoMessage()

func (*OrganizationLink) Reset 

func (m *OrganizationLink) Reset()

func (*OrganizationLink) String 

func (m *OrganizationLink) String() string

func (*OrganizationLink) XXX_DiscardUnknown 

func (m *OrganizationLink) XXX_DiscardUnknown()

func (*OrganizationLink) XXX_Marshal 

func (m *OrganizationLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OrganizationLink) XXX_Merge 

func (m *OrganizationLink) XXX_Merge(src proto.Message)

func (*OrganizationLink) XXX_Size 

func (m *OrganizationLink) XXX_Size() int

func (*OrganizationLink) XXX_Unmarshal 

func (m *OrganizationLink) XXX_Unmarshal(b []byte) error

type OrganizationListItem 

type OrganizationListItem struct {
	// Organization ID.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Organization name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Organization display name.
	DisplayName string `protobuf:"bytes,3,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// Can the organization create and "own" Gateways?
	CanHaveGateways bool `protobuf:"varint,4,opt,name=can_have_gateways,json=canHaveGateways,proto3" json:"can_have_gateways,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*OrganizationListItem) Descriptor 

func (*OrganizationListItem) Descriptor() ([]byte, []int)

func (*OrganizationListItem) GetCanHaveGateways 

func (m *OrganizationListItem) GetCanHaveGateways() bool

func (*OrganizationListItem) GetCreatedAt 

func (m *OrganizationListItem) GetCreatedAt() *timestamppb.Timestamp

func (*OrganizationListItem) GetDisplayName 

func (m *OrganizationListItem) GetDisplayName() string

func (*OrganizationListItem) GetId 

func (m *OrganizationListItem) GetId() int64

func (*OrganizationListItem) GetName 

func (m *OrganizationListItem) GetName() string

func (*OrganizationListItem) GetUpdatedAt 

func (m *OrganizationListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*OrganizationListItem) ProtoMessage 

func (*OrganizationListItem) ProtoMessage()

func (*OrganizationListItem) Reset 

func (m *OrganizationListItem) Reset()

func (*OrganizationListItem) String 

func (m *OrganizationListItem) String() string

func (*OrganizationListItem) XXX_DiscardUnknown 

func (m *OrganizationListItem) XXX_DiscardUnknown()

func (*OrganizationListItem) XXX_Marshal 

func (m *OrganizationListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OrganizationListItem) XXX_Merge 

func (m *OrganizationListItem) XXX_Merge(src proto.Message)

func (*OrganizationListItem) XXX_Size 

func (m *OrganizationListItem) XXX_Size() int

func (*OrganizationListItem) XXX_Unmarshal 

func (m *OrganizationListItem) XXX_Unmarshal(b []byte) error

type OrganizationServiceClient 

type OrganizationServiceClient interface {
	// Get organization list.
	List(ctx context.Context, in *ListOrganizationRequest, opts ...grpc.CallOption) (*ListOrganizationResponse, error)
	// Get data for a particular organization.
	Get(ctx context.Context, in *GetOrganizationRequest, opts ...grpc.CallOption) (*GetOrganizationResponse, error)
	// Create a new organization.
	Create(ctx context.Context, in *CreateOrganizationRequest, opts ...grpc.CallOption) (*CreateOrganizationResponse, error)
	// Update an existing organization.
	Update(ctx context.Context, in *UpdateOrganizationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete an organization.
	Delete(ctx context.Context, in *DeleteOrganizationRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Get organization's user list.
	ListUsers(ctx context.Context, in *ListOrganizationUsersRequest, opts ...grpc.CallOption) (*ListOrganizationUsersResponse, error)
	// Get data for a particular organization user.
	GetUser(ctx context.Context, in *GetOrganizationUserRequest, opts ...grpc.CallOption) (*GetOrganizationUserResponse, error)
	// Add a new user to an organization.
	AddUser(ctx context.Context, in *AddOrganizationUserRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update a user in an organization.
	UpdateUser(ctx context.Context, in *UpdateOrganizationUserRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete a user from an organization.
	DeleteUser(ctx context.Context, in *DeleteOrganizationUserRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

OrganizationServiceClient is the client API for OrganizationService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewOrganizationServiceClient 

func NewOrganizationServiceClient(cc grpc.ClientConnInterface) OrganizationServiceClient

type OrganizationServiceServer 

type OrganizationServiceServer interface {
	// Get organization list.
	List(context.Context, *ListOrganizationRequest) (*ListOrganizationResponse, error)
	// Get data for a particular organization.
	Get(context.Context, *GetOrganizationRequest) (*GetOrganizationResponse, error)
	// Create a new organization.
	Create(context.Context, *CreateOrganizationRequest) (*CreateOrganizationResponse, error)
	// Update an existing organization.
	Update(context.Context, *UpdateOrganizationRequest) (*emptypb.Empty, error)
	// Delete an organization.
	Delete(context.Context, *DeleteOrganizationRequest) (*emptypb.Empty, error)
	// Get organization's user list.
	ListUsers(context.Context, *ListOrganizationUsersRequest) (*ListOrganizationUsersResponse, error)
	// Get data for a particular organization user.
	GetUser(context.Context, *GetOrganizationUserRequest) (*GetOrganizationUserResponse, error)
	// Add a new user to an organization.
	AddUser(context.Context, *AddOrganizationUserRequest) (*emptypb.Empty, error)
	// Update a user in an organization.
	UpdateUser(context.Context, *UpdateOrganizationUserRequest) (*emptypb.Empty, error)
	// Delete a user from an organization.
	DeleteUser(context.Context, *DeleteOrganizationUserRequest) (*emptypb.Empty, error)
}

OrganizationServiceServer is the server API for OrganizationService service.

type OrganizationUser 

type OrganizationUser struct {
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// User ID.
	UserId int64 `protobuf:"varint,2,opt,name=user_id,json=userID,proto3" json:"user_id,omitempty"`
	// User is admin within the context of the organization.
	// There is no need to set the is_device_admin and is_gateway_admin flags.
	IsAdmin bool `protobuf:"varint,3,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// User is able to modify device related resources (applications,
	// device-profiles, devices, multicast-groups).
	IsDeviceAdmin bool `protobuf:"varint,5,opt,name=is_device_admin,json=isDeviceAdmin,proto3" json:"is_device_admin,omitempty"`
	// User is able to modify gateways.
	IsGatewayAdmin bool `protobuf:"varint,6,opt,name=is_gateway_admin,json=isGatewayAdmin,proto3" json:"is_gateway_admin,omitempty"`
	// Email (only used on get).
	Email                string   `protobuf:"bytes,4,opt,name=email,proto3" json:"email,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*OrganizationUser) Descriptor 

func (*OrganizationUser) Descriptor() ([]byte, []int)

func (*OrganizationUser) GetEmail 

func (m *OrganizationUser) GetEmail() string

func (*OrganizationUser) GetIsAdmin 

func (m *OrganizationUser) GetIsAdmin() bool

func (*OrganizationUser) GetIsDeviceAdmin 

func (m *OrganizationUser) GetIsDeviceAdmin() bool

func (*OrganizationUser) GetIsGatewayAdmin 

func (m *OrganizationUser) GetIsGatewayAdmin() bool

func (*OrganizationUser) GetOrganizationId 

func (m *OrganizationUser) GetOrganizationId() int64

func (*OrganizationUser) GetUserId 

func (m *OrganizationUser) GetUserId() int64

func (*OrganizationUser) ProtoMessage 

func (*OrganizationUser) ProtoMessage()

func (*OrganizationUser) Reset 

func (m *OrganizationUser) Reset()

func (*OrganizationUser) String 

func (m *OrganizationUser) String() string

func (*OrganizationUser) XXX_DiscardUnknown 

func (m *OrganizationUser) XXX_DiscardUnknown()

func (*OrganizationUser) XXX_Marshal 

func (m *OrganizationUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OrganizationUser) XXX_Merge 

func (m *OrganizationUser) XXX_Merge(src proto.Message)

func (*OrganizationUser) XXX_Size 

func (m *OrganizationUser) XXX_Size() int

func (*OrganizationUser) XXX_Unmarshal 

func (m *OrganizationUser) XXX_Unmarshal(b []byte) error

type OrganizationUserListItem 

type OrganizationUserListItem struct {
	// User ID.
	// This is not used on create, you must set the user email address
	// associated with the user to add an user to an organization.
	UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userID,proto3" json:"user_id,omitempty"`
	// Email.
	Email string `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
	// User is admin within the context of the organization.
	// There is no need to set the is_device_admin and is_gateway_admin flags.
	IsAdmin bool `protobuf:"varint,3,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// User is able to modify device related resources (applications,
	// device-profiles, devices, multicast-groups).
	IsDeviceAdmin bool `protobuf:"varint,6,opt,name=is_device_admin,json=isDeviceAdmin,proto3" json:"is_device_admin,omitempty"`
	// User is able to modify gateways.
	IsGatewayAdmin bool `protobuf:"varint,7,opt,name=is_gateway_admin,json=isGatewayAdmin,proto3" json:"is_gateway_admin,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*OrganizationUserListItem) Descriptor 

func (*OrganizationUserListItem) Descriptor() ([]byte, []int)

func (*OrganizationUserListItem) GetCreatedAt 

func (m *OrganizationUserListItem) GetCreatedAt() *timestamppb.Timestamp

func (*OrganizationUserListItem) GetEmail 

func (m *OrganizationUserListItem) GetEmail() string

func (*OrganizationUserListItem) GetIsAdmin 

func (m *OrganizationUserListItem) GetIsAdmin() bool

func (*OrganizationUserListItem) GetIsDeviceAdmin 

func (m *OrganizationUserListItem) GetIsDeviceAdmin() bool

func (*OrganizationUserListItem) GetIsGatewayAdmin 

func (m *OrganizationUserListItem) GetIsGatewayAdmin() bool

func (*OrganizationUserListItem) GetUpdatedAt 

func (m *OrganizationUserListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*OrganizationUserListItem) GetUserId 

func (m *OrganizationUserListItem) GetUserId() int64

func (*OrganizationUserListItem) ProtoMessage 

func (*OrganizationUserListItem) ProtoMessage()

func (*OrganizationUserListItem) Reset 

func (m *OrganizationUserListItem) Reset()

func (*OrganizationUserListItem) String 

func (m *OrganizationUserListItem) String() string

func (*OrganizationUserListItem) XXX_DiscardUnknown 

func (m *OrganizationUserListItem) XXX_DiscardUnknown()

func (*OrganizationUserListItem) XXX_Marshal 

func (m *OrganizationUserListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OrganizationUserListItem) XXX_Merge 

func (m *OrganizationUserListItem) XXX_Merge(src proto.Message)

func (*OrganizationUserListItem) XXX_Size 

func (m *OrganizationUserListItem) XXX_Size() int

func (*OrganizationUserListItem) XXX_Unmarshal 

func (m *OrganizationUserListItem) XXX_Unmarshal(b []byte) error

type PFProtocol 

type PFProtocol struct {
	// UDP_GWMP MQTT
	Type          string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	StatsInterval int32  `protobuf:"varint,2,opt,name=statsInterval,proto3" json:"statsInterval,omitempty"`
	// Types that are valid to be assigned to Settings:
	//
	//	*PFProtocol_Gwmp
	//	*PFProtocol_Mqtt
	Settings             isPFProtocol_Settings `protobuf_oneof:"settings"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*PFProtocol) Descriptor 

func (*PFProtocol) Descriptor() ([]byte, []int)

func (*PFProtocol) GetGwmp 

func (m *PFProtocol) GetGwmp() *GWMPSSettings

func (*PFProtocol) GetMqtt 

func (m *PFProtocol) GetMqtt() *MQTTSettings

func (*PFProtocol) GetSettings 

func (m *PFProtocol) GetSettings() isPFProtocol_Settings

func (*PFProtocol) GetStatsInterval 

func (m *PFProtocol) GetStatsInterval() int32

func (*PFProtocol) GetType 

func (m *PFProtocol) GetType() string

func (*PFProtocol) ProtoMessage 

func (*PFProtocol) ProtoMessage()

func (*PFProtocol) Reset 

func (m *PFProtocol) Reset()

func (*PFProtocol) String 

func (m *PFProtocol) String() string

func (*PFProtocol) XXX_DiscardUnknown 

func (m *PFProtocol) XXX_DiscardUnknown()

func (*PFProtocol) XXX_Marshal 

func (m *PFProtocol) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PFProtocol) XXX_Merge 

func (m *PFProtocol) XXX_Merge(src proto.Message)

func (*PFProtocol) XXX_OneofWrappers 

func (*PFProtocol) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*PFProtocol) XXX_Size 

func (m *PFProtocol) XXX_Size() int

func (*PFProtocol) XXX_Unmarshal 

func (m *PFProtocol) XXX_Unmarshal(b []byte) error

type PFProtocol_Gwmp 

type PFProtocol_Gwmp struct {
	Gwmp *GWMPSSettings `protobuf:"bytes,3,opt,name=gwmp,json=GWMP,proto3,oneof"`
}

type PFProtocol_Mqtt 

type PFProtocol_Mqtt struct {
	Mqtt *MQTTSettings `protobuf:"bytes,4,opt,name=mqtt,json=MQTT,proto3,oneof"`
}

type PacketForwarder 

type PacketForwarder struct {
	Protocol             *PFProtocol `protobuf:"bytes,1,opt,name=protocol,proto3" json:"protocol,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*PacketForwarder) Descriptor 

func (*PacketForwarder) Descriptor() ([]byte, []int)

func (*PacketForwarder) GetProtocol 

func (m *PacketForwarder) GetProtocol() *PFProtocol

func (*PacketForwarder) ProtoMessage 

func (*PacketForwarder) ProtoMessage()

func (*PacketForwarder) Reset 

func (m *PacketForwarder) Reset()

func (*PacketForwarder) String 

func (m *PacketForwarder) String() string

func (*PacketForwarder) XXX_DiscardUnknown 

func (m *PacketForwarder) XXX_DiscardUnknown()

func (*PacketForwarder) XXX_Marshal 

func (m *PacketForwarder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PacketForwarder) XXX_Merge 

func (m *PacketForwarder) XXX_Merge(src proto.Message)

func (*PacketForwarder) XXX_Size 

func (m *PacketForwarder) XXX_Size() int

func (*PacketForwarder) XXX_Unmarshal 

func (m *PacketForwarder) XXX_Unmarshal(b []byte) error

type PilotThingsIntegration 

type PilotThingsIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// Server URL
	Server string `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"`
	// Authentication token
	Token                string   `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*PilotThingsIntegration) Descriptor 

func (*PilotThingsIntegration) Descriptor() ([]byte, []int)

func (*PilotThingsIntegration) GetApplicationId 

func (m *PilotThingsIntegration) GetApplicationId() int64

func (*PilotThingsIntegration) GetServer 

func (m *PilotThingsIntegration) GetServer() string

func (*PilotThingsIntegration) GetToken 

func (m *PilotThingsIntegration) GetToken() string

func (*PilotThingsIntegration) ProtoMessage 

func (*PilotThingsIntegration) ProtoMessage()

func (*PilotThingsIntegration) Reset 

func (m *PilotThingsIntegration) Reset()

func (*PilotThingsIntegration) String 

func (m *PilotThingsIntegration) String() string

func (*PilotThingsIntegration) XXX_DiscardUnknown 

func (m *PilotThingsIntegration) XXX_DiscardUnknown()

func (*PilotThingsIntegration) XXX_Marshal 

func (m *PilotThingsIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PilotThingsIntegration) XXX_Merge 

func (m *PilotThingsIntegration) XXX_Merge(src proto.Message)

func (*PilotThingsIntegration) XXX_Size 

func (m *PilotThingsIntegration) XXX_Size() int

func (*PilotThingsIntegration) XXX_Unmarshal 

func (m *PilotThingsIntegration) XXX_Unmarshal(b []byte) error

type PingRX 

type PingRX struct {
	// Gateway ID (HEX encoded).
	GatewayId string `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayID,proto3" json:"gateway_id,omitempty"`
	// RSSI.
	Rssi int32 `protobuf:"varint,2,opt,name=rssi,proto3" json:"rssi,omitempty"`
	// LoRa SNR.
	LoraSnr float64 `protobuf:"fixed64,3,opt,name=lora_snr,json=loRaSNR,proto3" json:"lora_snr,omitempty"`
	// Latitude of the gateway -90.0 to 90.0.
	Latitude float64 `protobuf:"fixed64,4,opt,name=latitude,proto3" json:"latitude,omitempty"`
	// Longitude of the gateway -180.0 to 180.0.
	Longitude float64 `protobuf:"fixed64,5,opt,name=longitude,proto3" json:"longitude,omitempty"`
	// Altitude of the gateway in meters.
	Altitude             float64  `protobuf:"fixed64,6,opt,name=altitude,proto3" json:"altitude,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*PingRX) Descriptor 

func (*PingRX) Descriptor() ([]byte, []int)

func (*PingRX) GetAltitude 

func (m *PingRX) GetAltitude() float64

func (*PingRX) GetGatewayId 

func (m *PingRX) GetGatewayId() string

func (*PingRX) GetLatitude 

func (m *PingRX) GetLatitude() float64

func (*PingRX) GetLongitude 

func (m *PingRX) GetLongitude() float64

func (*PingRX) GetLoraSnr 

func (m *PingRX) GetLoraSnr() float64

func (*PingRX) GetRssi 

func (m *PingRX) GetRssi() int32

func (*PingRX) ProtoMessage 

func (*PingRX) ProtoMessage()

func (*PingRX) Reset 

func (m *PingRX) Reset()

func (*PingRX) String 

func (m *PingRX) String() string

func (*PingRX) XXX_DiscardUnknown 

func (m *PingRX) XXX_DiscardUnknown()

func (*PingRX) XXX_Marshal 

func (m *PingRX) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PingRX) XXX_Merge 

func (m *PingRX) XXX_Merge(src proto.Message)

func (*PingRX) XXX_Size 

func (m *PingRX) XXX_Size() int

func (*PingRX) XXX_Unmarshal 

func (m *PingRX) XXX_Unmarshal(b []byte) error

type PingRequest 

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 (*PingRequest) Descriptor 

func (*PingRequest) Descriptor() ([]byte, []int)

func (*PingRequest) GetNic 

func (m *PingRequest) GetNic() string

func (*PingRequest) GetUrl 

func (m *PingRequest) GetUrl() string

func (*PingRequest) ProtoMessage 

func (*PingRequest) ProtoMessage()

func (*PingRequest) Reset 

func (m *PingRequest) Reset()

func (*PingRequest) String 

func (m *PingRequest) String() string

func (*PingRequest) XXX_DiscardUnknown 

func (m *PingRequest) XXX_DiscardUnknown()

func (*PingRequest) XXX_Marshal 

func (m *PingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PingRequest) XXX_Merge 

func (m *PingRequest) XXX_Merge(src proto.Message)

func (*PingRequest) XXX_Size 

func (m *PingRequest) XXX_Size() int

func (*PingRequest) XXX_Unmarshal 

func (m *PingRequest) XXX_Unmarshal(b []byte) error

type ProfileResponse 

type ProfileResponse struct {
	// User object.
	User *User `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// Organizations to which the user is associated.
	Organizations        []*OrganizationLink `protobuf:"bytes,3,rep,name=organizations,proto3" json:"organizations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (*ProfileResponse) Descriptor 

func (*ProfileResponse) Descriptor() ([]byte, []int)

func (*ProfileResponse) GetOrganizations 

func (m *ProfileResponse) GetOrganizations() []*OrganizationLink

func (*ProfileResponse) GetUser 

func (m *ProfileResponse) GetUser() *User

func (*ProfileResponse) ProtoMessage 

func (*ProfileResponse) ProtoMessage()

func (*ProfileResponse) Reset 

func (m *ProfileResponse) Reset()

func (*ProfileResponse) String 

func (m *ProfileResponse) String() string

func (*ProfileResponse) XXX_DiscardUnknown 

func (m *ProfileResponse) XXX_DiscardUnknown()

func (*ProfileResponse) XXX_Marshal 

func (m *ProfileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ProfileResponse) XXX_Merge 

func (m *ProfileResponse) XXX_Merge(src proto.Message)

func (*ProfileResponse) XXX_Size 

func (m *ProfileResponse) XXX_Size() int

func (*ProfileResponse) XXX_Unmarshal 

func (m *ProfileResponse) XXX_Unmarshal(b []byte) error

type QtcodeCreateDeviceRequest 

type QtcodeCreateDeviceRequest struct {
	// Device object to create.
	Device               *Device     `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Otaa                 *OTAADevice `protobuf:"bytes,2,opt,name=otaa,json=OTAA,proto3" json:"otaa,omitempty"`
	Abp                  *ABPDevice  `protobuf:"bytes,3,opt,name=abp,json=ABP,proto3" json:"abp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*QtcodeCreateDeviceRequest) Descriptor 

func (*QtcodeCreateDeviceRequest) Descriptor() ([]byte, []int)

func (*QtcodeCreateDeviceRequest) GetAbp 

func (m *QtcodeCreateDeviceRequest) GetAbp() *ABPDevice

func (*QtcodeCreateDeviceRequest) GetDevice 

func (m *QtcodeCreateDeviceRequest) GetDevice() *Device

func (*QtcodeCreateDeviceRequest) GetOtaa 

func (m *QtcodeCreateDeviceRequest) GetOtaa() *OTAADevice

func (*QtcodeCreateDeviceRequest) ProtoMessage 

func (*QtcodeCreateDeviceRequest) ProtoMessage()

func (*QtcodeCreateDeviceRequest) Reset 

func (m *QtcodeCreateDeviceRequest) Reset()

func (*QtcodeCreateDeviceRequest) String 

func (m *QtcodeCreateDeviceRequest) String() string

func (*QtcodeCreateDeviceRequest) XXX_DiscardUnknown 

func (m *QtcodeCreateDeviceRequest) XXX_DiscardUnknown()

func (*QtcodeCreateDeviceRequest) XXX_Marshal 

func (m *QtcodeCreateDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QtcodeCreateDeviceRequest) XXX_Merge 

func (m *QtcodeCreateDeviceRequest) XXX_Merge(src proto.Message)

func (*QtcodeCreateDeviceRequest) XXX_Size 

func (m *QtcodeCreateDeviceRequest) XXX_Size() int

func (*QtcodeCreateDeviceRequest) XXX_Unmarshal 

func (m *QtcodeCreateDeviceRequest) XXX_Unmarshal(b []byte) error

type QtcodeCreateDeviceResponse 

type QtcodeCreateDeviceResponse struct {
	// Device object to create.
	Empty                *emptypb.Empty `protobuf:"bytes,1,opt,name=empty,proto3" json:"empty,omitempty"`
	Message              string         `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	Status               string         `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*QtcodeCreateDeviceResponse) Descriptor 

func (*QtcodeCreateDeviceResponse) Descriptor() ([]byte, []int)

func (*QtcodeCreateDeviceResponse) GetEmpty 

func (m *QtcodeCreateDeviceResponse) GetEmpty() *emptypb.Empty

func (*QtcodeCreateDeviceResponse) GetMessage 

func (m *QtcodeCreateDeviceResponse) GetMessage() string

func (*QtcodeCreateDeviceResponse) GetStatus 

func (m *QtcodeCreateDeviceResponse) GetStatus() string

func (*QtcodeCreateDeviceResponse) ProtoMessage 

func (*QtcodeCreateDeviceResponse) ProtoMessage()

func (*QtcodeCreateDeviceResponse) Reset 

func (m *QtcodeCreateDeviceResponse) Reset()

func (*QtcodeCreateDeviceResponse) String 

func (m *QtcodeCreateDeviceResponse) String() string

func (*QtcodeCreateDeviceResponse) XXX_DiscardUnknown 

func (m *QtcodeCreateDeviceResponse) XXX_DiscardUnknown()

func (*QtcodeCreateDeviceResponse) XXX_Marshal 

func (m *QtcodeCreateDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QtcodeCreateDeviceResponse) XXX_Merge 

func (m *QtcodeCreateDeviceResponse) XXX_Merge(src proto.Message)

func (*QtcodeCreateDeviceResponse) XXX_Size 

func (m *QtcodeCreateDeviceResponse) XXX_Size() int

func (*QtcodeCreateDeviceResponse) XXX_Unmarshal 

func (m *QtcodeCreateDeviceResponse) XXX_Unmarshal(b []byte) error

type QueryResponse 

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 (*QueryResponse) Descriptor 

func (*QueryResponse) Descriptor() ([]byte, []int)

func (*QueryResponse) GetSystem 

func (m *QueryResponse) GetSystem() *SystemInfo

func (*QueryResponse) ProtoMessage 

func (*QueryResponse) ProtoMessage()

func (*QueryResponse) Reset 

func (m *QueryResponse) Reset()

func (*QueryResponse) String 

func (m *QueryResponse) String() string

func (*QueryResponse) XXX_DiscardUnknown 

func (m *QueryResponse) XXX_DiscardUnknown()

func (*QueryResponse) XXX_Marshal 

func (m *QueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryResponse) XXX_Merge 

func (m *QueryResponse) XXX_Merge(src proto.Message)

func (*QueryResponse) XXX_Size 

func (m *QueryResponse) XXX_Size() int

func (*QueryResponse) XXX_Unmarshal 

func (m *QueryResponse) XXX_Unmarshal(b []byte) error

type QuitRequest 

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

func (*QuitRequest) Descriptor 

func (*QuitRequest) Descriptor() ([]byte, []int)

func (*QuitRequest) GetJwt 

func (m *QuitRequest) GetJwt() string

func (*QuitRequest) ProtoMessage 

func (*QuitRequest) ProtoMessage()

func (*QuitRequest) Reset 

func (m *QuitRequest) Reset()

func (*QuitRequest) String 

func (m *QuitRequest) String() string

func (*QuitRequest) XXX_DiscardUnknown 

func (m *QuitRequest) XXX_DiscardUnknown()

func (*QuitRequest) XXX_Marshal 

func (m *QuitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QuitRequest) XXX_Merge 

func (m *QuitRequest) XXX_Merge(src proto.Message)

func (*QuitRequest) XXX_Size 

func (m *QuitRequest) XXX_Size() int

func (*QuitRequest) XXX_Unmarshal 

func (m *QuitRequest) XXX_Unmarshal(b []byte) error

type RAKSettings 

type RAKSettings struct {
	Server               string     `protobuf:"bytes,1,opt,name=server,proto3" json:"server,omitempty"`
	Port                 int32      `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Version              string     `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	Qos                  int32      `protobuf:"varint,4,opt,name=qos,proto3" json:"qos,omitempty"`
	KeepaliveInterval    int32      `protobuf:"varint,5,opt,name=keepaliveInterval,proto3" json:"keepaliveInterval,omitempty"`
	Ssl                  *SSLConfig `protobuf:"bytes,6,opt,name=ssl,proto3" json:"ssl,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (*RAKSettings) Descriptor 

func (*RAKSettings) Descriptor() ([]byte, []int)

func (*RAKSettings) GetKeepaliveInterval 

func (m *RAKSettings) GetKeepaliveInterval() int32

func (*RAKSettings) GetPort 

func (m *RAKSettings) GetPort() int32

func (*RAKSettings) GetQos 

func (m *RAKSettings) GetQos() int32

func (*RAKSettings) GetServer 

func (m *RAKSettings) GetServer() string

func (*RAKSettings) GetSsl 

func (m *RAKSettings) GetSsl() *SSLConfig

func (*RAKSettings) GetVersion 

func (m *RAKSettings) GetVersion() string

func (*RAKSettings) ProtoMessage 

func (*RAKSettings) ProtoMessage()

func (*RAKSettings) Reset 

func (m *RAKSettings) Reset()

func (*RAKSettings) String 

func (m *RAKSettings) String() string

func (*RAKSettings) XXX_DiscardUnknown 

func (m *RAKSettings) XXX_DiscardUnknown()

func (*RAKSettings) XXX_Marshal 

func (m *RAKSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RAKSettings) XXX_Merge 

func (m *RAKSettings) XXX_Merge(src proto.Message)

func (*RAKSettings) XXX_Size 

func (m *RAKSettings) XXX_Size() int

func (*RAKSettings) XXX_Unmarshal 

func (m *RAKSettings) XXX_Unmarshal(b []byte) error

type RS485ModbusConfig 

type RS485ModbusConfig struct {
	Baudrate             uint32   `protobuf:"varint,1,opt,name=baudrate,proto3" json:"baudrate,omitempty"`
	Databits             int32    `protobuf:"varint,2,opt,name=databits,proto3" json:"databits,omitempty"`
	Stopbit              string   `protobuf:"bytes,3,opt,name=stopbit,proto3" json:"stopbit,omitempty"`
	Parity               string   `protobuf:"bytes,4,opt,name=parity,proto3" json:"parity,omitempty"`
	Retry                int32    `protobuf:"varint,5,opt,name=retry,proto3" json:"retry,omitempty"`
	W                    []string `protobuf:"bytes,6,rep,name=w,proto3" json:"w,omitempty"`
	R                    string   `protobuf:"bytes,7,opt,name=r,proto3" json:"r,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*RS485ModbusConfig) Descriptor 

func (*RS485ModbusConfig) Descriptor() ([]byte, []int)

func (*RS485ModbusConfig) GetBaudrate 

func (m *RS485ModbusConfig) GetBaudrate() uint32

func (*RS485ModbusConfig) GetDatabits 

func (m *RS485ModbusConfig) GetDatabits() int32

func (*RS485ModbusConfig) GetParity 

func (m *RS485ModbusConfig) GetParity() string

func (*RS485ModbusConfig) GetR 

func (m *RS485ModbusConfig) GetR() string

func (*RS485ModbusConfig) GetRetry 

func (m *RS485ModbusConfig) GetRetry() int32

func (*RS485ModbusConfig) GetStopbit 

func (m *RS485ModbusConfig) GetStopbit() string

func (*RS485ModbusConfig) GetW 

func (m *RS485ModbusConfig) GetW() []string

func (*RS485ModbusConfig) ProtoMessage 

func (*RS485ModbusConfig) ProtoMessage()

func (*RS485ModbusConfig) Reset 

func (m *RS485ModbusConfig) Reset()

func (*RS485ModbusConfig) String 

func (m *RS485ModbusConfig) String() string

func (*RS485ModbusConfig) XXX_DiscardUnknown 

func (m *RS485ModbusConfig) XXX_DiscardUnknown()

func (*RS485ModbusConfig) XXX_Marshal 

func (m *RS485ModbusConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RS485ModbusConfig) XXX_Merge 

func (m *RS485ModbusConfig) XXX_Merge(src proto.Message)

func (*RS485ModbusConfig) XXX_Size 

func (m *RS485ModbusConfig) XXX_Size() int

func (*RS485ModbusConfig) XXX_Unmarshal 

func (m *RS485ModbusConfig) XXX_Unmarshal(b []byte) error

type RXWindow 

type RXWindow int32
const (
	RXWindow_RX1 RXWindow = 0
	RXWindow_RX2 RXWindow = 1
)

func (RXWindow) EnumDescriptor 

func (RXWindow) EnumDescriptor() ([]byte, []int)

func (RXWindow) String 

func (x RXWindow) String() string

type RatePolicy 

type RatePolicy int32
const (
	// Drop
	RatePolicy_DROP RatePolicy = 0
	// Mark
	RatePolicy_MARK RatePolicy = 1
)

func (RatePolicy) EnumDescriptor 

func (RatePolicy) EnumDescriptor() ([]byte, []int)

func (RatePolicy) String 

func (x RatePolicy) String() string

type RemoveDeviceFromMulticastGroupRequest 

type RemoveDeviceFromMulticastGroupRequest struct {
	// Multicast-group ID (string formatted UUID).
	MulticastGroupId string `protobuf:"bytes,1,opt,name=multicast_group_id,json=multicastGroupID,proto3" json:"multicast_group_id,omitempty"`
	// Device EUI (HEX encoded string).
	DevEui               string   `protobuf:"bytes,2,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*RemoveDeviceFromMulticastGroupRequest) Descriptor 

func (*RemoveDeviceFromMulticastGroupRequest) Descriptor() ([]byte, []int)

func (*RemoveDeviceFromMulticastGroupRequest) GetDevEui 

func (m *RemoveDeviceFromMulticastGroupRequest) GetDevEui() string

func (*RemoveDeviceFromMulticastGroupRequest) GetMulticastGroupId 

func (m *RemoveDeviceFromMulticastGroupRequest) GetMulticastGroupId() string

func (*RemoveDeviceFromMulticastGroupRequest) ProtoMessage 

func (*RemoveDeviceFromMulticastGroupRequest) ProtoMessage()

func (*RemoveDeviceFromMulticastGroupRequest) Reset 

func (m *RemoveDeviceFromMulticastGroupRequest) Reset()

func (*RemoveDeviceFromMulticastGroupRequest) String 

func (m *RemoveDeviceFromMulticastGroupRequest) String() string

func (*RemoveDeviceFromMulticastGroupRequest) XXX_DiscardUnknown 

func (m *RemoveDeviceFromMulticastGroupRequest) XXX_DiscardUnknown()

func (*RemoveDeviceFromMulticastGroupRequest) XXX_Marshal 

func (m *RemoveDeviceFromMulticastGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RemoveDeviceFromMulticastGroupRequest) XXX_Merge 

func (m *RemoveDeviceFromMulticastGroupRequest) XXX_Merge(src proto.Message)

func (*RemoveDeviceFromMulticastGroupRequest) XXX_Size 

func (m *RemoveDeviceFromMulticastGroupRequest) XXX_Size() int

func (*RemoveDeviceFromMulticastGroupRequest) XXX_Unmarshal 

func (m *RemoveDeviceFromMulticastGroupRequest) XXX_Unmarshal(b []byte) error

type RestoreRequest 

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 (*RestoreRequest) Descriptor 

func (*RestoreRequest) Descriptor() ([]byte, []int)

func (*RestoreRequest) GetVersion 

func (m *RestoreRequest) GetVersion() string

func (*RestoreRequest) ProtoMessage 

func (*RestoreRequest) ProtoMessage()

func (*RestoreRequest) Reset 

func (m *RestoreRequest) Reset()

func (*RestoreRequest) String 

func (m *RestoreRequest) String() string

func (*RestoreRequest) XXX_DiscardUnknown 

func (m *RestoreRequest) XXX_DiscardUnknown()

func (*RestoreRequest) XXX_Marshal 

func (m *RestoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RestoreRequest) XXX_Merge 

func (m *RestoreRequest) XXX_Merge(src proto.Message)

func (*RestoreRequest) XXX_Size 

func (m *RestoreRequest) XXX_Size() int

func (*RestoreRequest) XXX_Unmarshal 

func (m *RestoreRequest) XXX_Unmarshal(b []byte) error

type RssiTcomp 

type RssiTcomp struct {
	Coeffa               float32  `protobuf:"fixed32,1,opt,name=coeffa,json=coeff_a,proto3" json:"coeffa,omitempty"`
	Coeffb               float32  `protobuf:"fixed32,2,opt,name=coeffb,json=coeff_b,proto3" json:"coeffb,omitempty"`
	Coeffc               float32  `protobuf:"fixed32,3,opt,name=coeffc,json=coeff_c,proto3" json:"coeffc,omitempty"`
	Coeffd               float32  `protobuf:"fixed32,4,opt,name=coeffd,json=coeff_d,proto3" json:"coeffd,omitempty"`
	Coeffe               float32  `protobuf:"fixed32,5,opt,name=coeffe,json=coeff_e,proto3" json:"coeffe,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*RssiTcomp) Descriptor 

func (*RssiTcomp) Descriptor() ([]byte, []int)

func (*RssiTcomp) GetCoeffa 

func (m *RssiTcomp) GetCoeffa() float32

func (*RssiTcomp) GetCoeffb 

func (m *RssiTcomp) GetCoeffb() float32

func (*RssiTcomp) GetCoeffc 

func (m *RssiTcomp) GetCoeffc() float32

func (*RssiTcomp) GetCoeffd 

func (m *RssiTcomp) GetCoeffd() float32

func (*RssiTcomp) GetCoeffe 

func (m *RssiTcomp) GetCoeffe() float32

func (*RssiTcomp) ProtoMessage 

func (*RssiTcomp) ProtoMessage()

func (*RssiTcomp) Reset 

func (m *RssiTcomp) Reset()

func (*RssiTcomp) String 

func (m *RssiTcomp) String() string

func (*RssiTcomp) XXX_DiscardUnknown 

func (m *RssiTcomp) XXX_DiscardUnknown()

func (*RssiTcomp) XXX_Marshal 

func (m *RssiTcomp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RssiTcomp) XXX_Merge 

func (m *RssiTcomp) XXX_Merge(src proto.Message)

func (*RssiTcomp) XXX_Size 

func (m *RssiTcomp) XXX_Size() int

func (*RssiTcomp) XXX_Unmarshal 

func (m *RssiTcomp) XXX_Unmarshal(b []byte) error

type SSLConfig 

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

func (*SSLConfig) Descriptor 

func (*SSLConfig) Descriptor() ([]byte, []int)

func (*SSLConfig) GetMode 

func (m *SSLConfig) GetMode() string

func (*SSLConfig) ProtoMessage 

func (*SSLConfig) ProtoMessage()

func (*SSLConfig) Reset 

func (m *SSLConfig) Reset()

func (*SSLConfig) String 

func (m *SSLConfig) String() string

func (*SSLConfig) XXX_DiscardUnknown 

func (m *SSLConfig) XXX_DiscardUnknown()

func (*SSLConfig) XXX_Marshal 

func (m *SSLConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SSLConfig) XXX_Merge 

func (m *SSLConfig) XXX_Merge(src proto.Message)

func (*SSLConfig) XXX_Size 

func (m *SSLConfig) XXX_Size() int

func (*SSLConfig) XXX_Unmarshal 

func (m *SSLConfig) XXX_Unmarshal(b []byte) error

type ServiceProfile 

type ServiceProfile struct {
	// Service-profile ID (UUID string).
	// This will be automatically set on create.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Service-profile name.
	Name string `protobuf:"bytes,21,opt,name=name,proto3" json:"name,omitempty"`
	// Organization ID to which the service-profile is assigned.
	OrganizationId int64 `protobuf:"varint,22,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Network-server ID on which the service-profile is provisioned.
	NetworkServerId int64 `protobuf:"varint,23,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	// Token bucket filling rate, including ACKs (packet/h).
	UlRate uint32 `protobuf:"varint,2,opt,name=ul_rate,json=ulRate,proto3" json:"ul_rate,omitempty"`
	// Token bucket burst size.
	UlBucketSize uint32 `protobuf:"varint,3,opt,name=ul_bucket_size,json=ulBucketSize,proto3" json:"ul_bucket_size,omitempty"`
	// Drop or mark when exceeding ULRate.
	UlRatePolicy RatePolicy `protobuf:"varint,4,opt,name=ul_rate_policy,json=ulRatePolicy,proto3,enum=api.RatePolicy" json:"ul_rate_policy,omitempty"`
	// Token bucket filling rate, including ACKs (packet/h).
	DlRate uint32 `protobuf:"varint,5,opt,name=dl_rate,json=dlRate,proto3" json:"dl_rate,omitempty"`
	// Token bucket burst size.
	DlBucketSize uint32 `protobuf:"varint,6,opt,name=dl_bucket_size,json=dlBucketSize,proto3" json:"dl_bucket_size,omitempty"`
	// Drop or mark when exceeding DLRate.
	DlRatePolicy RatePolicy `protobuf:"varint,7,opt,name=dl_rate_policy,json=dlRatePolicy,proto3,enum=api.RatePolicy" json:"dl_rate_policy,omitempty"`
	// GW metadata (RSSI, SNR, GW geoloc., etc.) are added to the packet sent to AS.
	AddGwMetadata bool `protobuf:"varint,8,opt,name=add_gw_metadata,json=addGWMetaData,proto3" json:"add_gw_metadata,omitempty"`
	// Frequency to initiate an End-Device status request (request/day).
	DevStatusReqFreq uint32 `protobuf:"varint,9,opt,name=dev_status_req_freq,json=devStatusReqFreq,proto3" json:"dev_status_req_freq,omitempty"`
	// Report End-Device battery level to AS.
	ReportDevStatusBattery bool `` /* 133-byte string literal not displayed */
	// Report End-Device margin to AS.
	ReportDevStatusMargin bool `` /* 130-byte string literal not displayed */
	// Minimum allowed data rate. Used for ADR.
	DrMin uint32 `protobuf:"varint,12,opt,name=dr_min,json=drMin,proto3" json:"dr_min,omitempty"`
	// Maximum allowed data rate. Used for ADR.
	DrMax uint32 `protobuf:"varint,13,opt,name=dr_max,json=drMax,proto3" json:"dr_max,omitempty"`
	// Channel mask. sNS does not have to obey (i.e., informative).
	ChannelMask []byte `protobuf:"bytes,14,opt,name=channel_mask,json=channelMask,proto3" json:"channel_mask,omitempty"`
	// Passive Roaming allowed.
	PrAllowed bool `protobuf:"varint,15,opt,name=pr_allowed,json=prAllowed,proto3" json:"pr_allowed,omitempty"`
	// Handover Roaming allowed.
	HrAllowed bool `protobuf:"varint,16,opt,name=hr_allowed,json=hrAllowed,proto3" json:"hr_allowed,omitempty"`
	// Roaming Activation allowed.
	RaAllowed bool `protobuf:"varint,17,opt,name=ra_allowed,json=raAllowed,proto3" json:"ra_allowed,omitempty"`
	// Enable network geolocation service.
	NwkGeoLoc bool `protobuf:"varint,18,opt,name=nwk_geo_loc,json=nwkGeoLoc,proto3" json:"nwk_geo_loc,omitempty"`
	// Target Packet Error Rate.
	TargetPer uint32 `protobuf:"varint,19,opt,name=target_per,json=targetPER,proto3" json:"target_per,omitempty"`
	// Minimum number of receiving GWs (informative).
	MinGwDiversity       uint32   `protobuf:"varint,20,opt,name=min_gw_diversity,json=minGWDiversity,proto3" json:"min_gw_diversity,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ServiceProfile) Descriptor 

func (*ServiceProfile) Descriptor() ([]byte, []int)

func (*ServiceProfile) GetAddGwMetadata 

func (m *ServiceProfile) GetAddGwMetadata() bool

func (*ServiceProfile) GetChannelMask 

func (m *ServiceProfile) GetChannelMask() []byte

func (*ServiceProfile) GetDevStatusReqFreq 

func (m *ServiceProfile) GetDevStatusReqFreq() uint32

func (*ServiceProfile) GetDlBucketSize 

func (m *ServiceProfile) GetDlBucketSize() uint32

func (*ServiceProfile) GetDlRate 

func (m *ServiceProfile) GetDlRate() uint32

func (*ServiceProfile) GetDlRatePolicy 

func (m *ServiceProfile) GetDlRatePolicy() RatePolicy

func (*ServiceProfile) GetDrMax 

func (m *ServiceProfile) GetDrMax() uint32

func (*ServiceProfile) GetDrMin 

func (m *ServiceProfile) GetDrMin() uint32

func (*ServiceProfile) GetHrAllowed 

func (m *ServiceProfile) GetHrAllowed() bool

func (*ServiceProfile) GetId 

func (m *ServiceProfile) GetId() string

func (*ServiceProfile) GetMinGwDiversity 

func (m *ServiceProfile) GetMinGwDiversity() uint32

func (*ServiceProfile) GetName 

func (m *ServiceProfile) GetName() string

func (*ServiceProfile) GetNetworkServerId 

func (m *ServiceProfile) GetNetworkServerId() int64

func (*ServiceProfile) GetNwkGeoLoc 

func (m *ServiceProfile) GetNwkGeoLoc() bool

func (*ServiceProfile) GetOrganizationId 

func (m *ServiceProfile) GetOrganizationId() int64

func (*ServiceProfile) GetPrAllowed 

func (m *ServiceProfile) GetPrAllowed() bool

func (*ServiceProfile) GetRaAllowed 

func (m *ServiceProfile) GetRaAllowed() bool

func (*ServiceProfile) GetReportDevStatusBattery 

func (m *ServiceProfile) GetReportDevStatusBattery() bool

func (*ServiceProfile) GetReportDevStatusMargin 

func (m *ServiceProfile) GetReportDevStatusMargin() bool

func (*ServiceProfile) GetTargetPer 

func (m *ServiceProfile) GetTargetPer() uint32

func (*ServiceProfile) GetUlBucketSize 

func (m *ServiceProfile) GetUlBucketSize() uint32

func (*ServiceProfile) GetUlRate 

func (m *ServiceProfile) GetUlRate() uint32

func (*ServiceProfile) GetUlRatePolicy 

func (m *ServiceProfile) GetUlRatePolicy() RatePolicy

func (*ServiceProfile) ProtoMessage 

func (*ServiceProfile) ProtoMessage()

func (*ServiceProfile) Reset 

func (m *ServiceProfile) Reset()

func (*ServiceProfile) String 

func (m *ServiceProfile) String() string

func (*ServiceProfile) XXX_DiscardUnknown 

func (m *ServiceProfile) XXX_DiscardUnknown()

func (*ServiceProfile) XXX_Marshal 

func (m *ServiceProfile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ServiceProfile) XXX_Merge 

func (m *ServiceProfile) XXX_Merge(src proto.Message)

func (*ServiceProfile) XXX_Size 

func (m *ServiceProfile) XXX_Size() int

func (*ServiceProfile) XXX_Unmarshal 

func (m *ServiceProfile) XXX_Unmarshal(b []byte) error

type ServiceProfileListItem 

type ServiceProfileListItem struct {
	// Service-profile ID (UUID string).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Service-profile name.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Organization ID of the service-profile.
	OrganizationId int64 `protobuf:"varint,3,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// Network-server ID of the service-profile.
	NetworkServerId int64 `protobuf:"varint,4,opt,name=network_server_id,json=networkServerID,proto3" json:"network_server_id,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Network-server name of the service-profile.
	NetworkServerName    string   `protobuf:"bytes,7,opt,name=network_server_name,json=networkServerName,proto3" json:"network_server_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ServiceProfileListItem) Descriptor 

func (*ServiceProfileListItem) Descriptor() ([]byte, []int)

func (*ServiceProfileListItem) GetCreatedAt 

func (m *ServiceProfileListItem) GetCreatedAt() *timestamppb.Timestamp

func (*ServiceProfileListItem) GetId 

func (m *ServiceProfileListItem) GetId() string

func (*ServiceProfileListItem) GetName 

func (m *ServiceProfileListItem) GetName() string

func (*ServiceProfileListItem) GetNetworkServerId 

func (m *ServiceProfileListItem) GetNetworkServerId() int64

func (*ServiceProfileListItem) GetNetworkServerName 

func (m *ServiceProfileListItem) GetNetworkServerName() string

func (*ServiceProfileListItem) GetOrganizationId 

func (m *ServiceProfileListItem) GetOrganizationId() int64

func (*ServiceProfileListItem) GetUpdatedAt 

func (m *ServiceProfileListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*ServiceProfileListItem) ProtoMessage 

func (*ServiceProfileListItem) ProtoMessage()

func (*ServiceProfileListItem) Reset 

func (m *ServiceProfileListItem) Reset()

func (*ServiceProfileListItem) String 

func (m *ServiceProfileListItem) String() string

func (*ServiceProfileListItem) XXX_DiscardUnknown 

func (m *ServiceProfileListItem) XXX_DiscardUnknown()

func (*ServiceProfileListItem) XXX_Marshal 

func (m *ServiceProfileListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ServiceProfileListItem) XXX_Merge 

func (m *ServiceProfileListItem) XXX_Merge(src proto.Message)

func (*ServiceProfileListItem) XXX_Size 

func (m *ServiceProfileListItem) XXX_Size() int

func (*ServiceProfileListItem) XXX_Unmarshal 

func (m *ServiceProfileListItem) XXX_Unmarshal(b []byte) error

type ServiceProfileServiceClient 

type ServiceProfileServiceClient interface {
	// Create creates the given service-profile.
	Create(ctx context.Context, in *CreateServiceProfileRequest, opts ...grpc.CallOption) (*CreateServiceProfileResponse, error)
	// Get returns the service-profile matching the given id.
	Get(ctx context.Context, in *GetServiceProfileRequest, opts ...grpc.CallOption) (*GetServiceProfileResponse, error)
	// Update updates the given serviceprofile.
	Update(ctx context.Context, in *UpdateServiceProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete deletes the service-profile matching the given id.
	Delete(ctx context.Context, in *DeleteServiceProfileRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// List lists the available service-profiles.
	List(ctx context.Context, in *ListServiceProfileRequest, opts ...grpc.CallOption) (*ListServiceProfileResponse, error)
}

ServiceProfileServiceClient is the client API for ServiceProfileService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewServiceProfileServiceClient 

func NewServiceProfileServiceClient(cc grpc.ClientConnInterface) ServiceProfileServiceClient

type ServiceProfileServiceServer 

type ServiceProfileServiceServer interface {
	// Create creates the given service-profile.
	Create(context.Context, *CreateServiceProfileRequest) (*CreateServiceProfileResponse, error)
	// Get returns the service-profile matching the given id.
	Get(context.Context, *GetServiceProfileRequest) (*GetServiceProfileResponse, error)
	// Update updates the given serviceprofile.
	Update(context.Context, *UpdateServiceProfileRequest) (*emptypb.Empty, error)
	// Delete deletes the service-profile matching the given id.
	Delete(context.Context, *DeleteServiceProfileRequest) (*emptypb.Empty, error)
	// List lists the available service-profiles.
	List(context.Context, *ListServiceProfileRequest) (*ListServiceProfileResponse, error)
}

ServiceProfileServiceServer is the server API for ServiceProfileService service.

type SetClientRequest 

type SetClientRequest struct {
	Eth                  *Ethernet   `protobuf:"bytes,2,opt,name=eth,proto3" json:"eth,omitempty"`
	Cat1                 *MoudleCat1 `protobuf:"bytes,3,opt,name=cat1,proto3" json:"cat1,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*SetClientRequest) Descriptor 

func (*SetClientRequest) Descriptor() ([]byte, []int)

func (*SetClientRequest) GetCat1 

func (m *SetClientRequest) GetCat1() *MoudleCat1

func (*SetClientRequest) GetEth 

func (m *SetClientRequest) GetEth() *Ethernet

func (*SetClientRequest) ProtoMessage 

func (*SetClientRequest) ProtoMessage()

func (*SetClientRequest) Reset 

func (m *SetClientRequest) Reset()

func (*SetClientRequest) String 

func (m *SetClientRequest) String() string

func (*SetClientRequest) XXX_DiscardUnknown 

func (m *SetClientRequest) XXX_DiscardUnknown()

func (*SetClientRequest) XXX_Marshal 

func (m *SetClientRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetClientRequest) XXX_Merge 

func (m *SetClientRequest) XXX_Merge(src proto.Message)

func (*SetClientRequest) XXX_Size 

func (m *SetClientRequest) XXX_Size() int

func (*SetClientRequest) XXX_Unmarshal 

func (m *SetClientRequest) XXX_Unmarshal(b []byte) error

type SetLogsRequest 

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

func (*SetLogsRequest) Descriptor 

func (*SetLogsRequest) Descriptor() ([]byte, []int)

func (*SetLogsRequest) GetLogLevel 

func (m *SetLogsRequest) GetLogLevel() string

func (*SetLogsRequest) ProtoMessage 

func (*SetLogsRequest) ProtoMessage()

func (*SetLogsRequest) Reset 

func (m *SetLogsRequest) Reset()

func (*SetLogsRequest) String 

func (m *SetLogsRequest) String() string

func (*SetLogsRequest) XXX_DiscardUnknown 

func (m *SetLogsRequest) XXX_DiscardUnknown()

func (*SetLogsRequest) XXX_Marshal 

func (m *SetLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetLogsRequest) XXX_Merge 

func (m *SetLogsRequest) XXX_Merge(src proto.Message)

func (*SetLogsRequest) XXX_Size 

func (m *SetLogsRequest) XXX_Size() int

func (*SetLogsRequest) XXX_Unmarshal 

func (m *SetLogsRequest) XXX_Unmarshal(b []byte) error

type SetLorawanTxRequest 

type SetLorawanTxRequest struct {
	Disable              bool       `protobuf:"varint,2,opt,name=disable,proto3" json:"disable,omitempty"`
	Config               *LorawanTX `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (*SetLorawanTxRequest) Descriptor 

func (*SetLorawanTxRequest) Descriptor() ([]byte, []int)

func (*SetLorawanTxRequest) GetConfig 

func (m *SetLorawanTxRequest) GetConfig() *LorawanTX

func (*SetLorawanTxRequest) GetDisable 

func (m *SetLorawanTxRequest) GetDisable() bool

func (*SetLorawanTxRequest) ProtoMessage 

func (*SetLorawanTxRequest) ProtoMessage()

func (*SetLorawanTxRequest) Reset 

func (m *SetLorawanTxRequest) Reset()

func (*SetLorawanTxRequest) String 

func (m *SetLorawanTxRequest) String() string

func (*SetLorawanTxRequest) XXX_DiscardUnknown 

func (m *SetLorawanTxRequest) XXX_DiscardUnknown()

func (*SetLorawanTxRequest) XXX_Marshal 

func (m *SetLorawanTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetLorawanTxRequest) XXX_Merge 

func (m *SetLorawanTxRequest) XXX_Merge(src proto.Message)

func (*SetLorawanTxRequest) XXX_Size 

func (m *SetLorawanTxRequest) XXX_Size() int

func (*SetLorawanTxRequest) XXX_Unmarshal 

func (m *SetLorawanTxRequest) XXX_Unmarshal(b []byte) error

type SetNTPRequest 

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 (*SetNTPRequest) Descriptor 

func (*SetNTPRequest) Descriptor() ([]byte, []int)

func (*SetNTPRequest) GetSync 

func (m *SetNTPRequest) GetSync() *NTPConfig

func (*SetNTPRequest) GetTest 

func (m *SetNTPRequest) GetTest() *NTPConfig

func (*SetNTPRequest) GetType 

func (m *SetNTPRequest) GetType() isSetNTPRequest_Type

func (*SetNTPRequest) ProtoMessage 

func (*SetNTPRequest) ProtoMessage()

func (*SetNTPRequest) Reset 

func (m *SetNTPRequest) Reset()

func (*SetNTPRequest) String 

func (m *SetNTPRequest) String() string

func (*SetNTPRequest) XXX_DiscardUnknown 

func (m *SetNTPRequest) XXX_DiscardUnknown()

func (*SetNTPRequest) XXX_Marshal 

func (m *SetNTPRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetNTPRequest) XXX_Merge 

func (m *SetNTPRequest) XXX_Merge(src proto.Message)

func (*SetNTPRequest) XXX_OneofWrappers 

func (*SetNTPRequest) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*SetNTPRequest) XXX_Size 

func (m *SetNTPRequest) XXX_Size() int

func (*SetNTPRequest) XXX_Unmarshal 

func (m *SetNTPRequest) XXX_Unmarshal(b []byte) error

type SetNTPRequest_Sync 

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

type SetNTPRequest_Test 

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

type SetNoderedRequest 

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 (*SetNoderedRequest) Descriptor 

func (*SetNoderedRequest) Descriptor() ([]byte, []int)

func (*SetNoderedRequest) GetEnable 

func (m *SetNoderedRequest) GetEnable() bool

func (*SetNoderedRequest) ProtoMessage 

func (*SetNoderedRequest) ProtoMessage()

func (*SetNoderedRequest) Reset 

func (m *SetNoderedRequest) Reset()

func (*SetNoderedRequest) String 

func (m *SetNoderedRequest) String() string

func (*SetNoderedRequest) XXX_DiscardUnknown 

func (m *SetNoderedRequest) XXX_DiscardUnknown()

func (*SetNoderedRequest) XXX_Marshal 

func (m *SetNoderedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetNoderedRequest) XXX_Merge 

func (m *SetNoderedRequest) XXX_Merge(src proto.Message)

func (*SetNoderedRequest) XXX_Size 

func (m *SetNoderedRequest) XXX_Size() int

func (*SetNoderedRequest) XXX_Unmarshal 

func (m *SetNoderedRequest) XXX_Unmarshal(b []byte) error

type SetOTPRequest 

type SetOTPRequest struct {
	Id                   int32    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Data                 []byte   `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*SetOTPRequest) Descriptor 

func (*SetOTPRequest) Descriptor() ([]byte, []int)

func (*SetOTPRequest) GetData 

func (m *SetOTPRequest) GetData() []byte

func (*SetOTPRequest) GetId 

func (m *SetOTPRequest) GetId() int32

func (*SetOTPRequest) ProtoMessage 

func (*SetOTPRequest) ProtoMessage()

func (*SetOTPRequest) Reset 

func (m *SetOTPRequest) Reset()

func (*SetOTPRequest) String 

func (m *SetOTPRequest) String() string

func (*SetOTPRequest) XXX_DiscardUnknown 

func (m *SetOTPRequest) XXX_DiscardUnknown()

func (*SetOTPRequest) XXX_Marshal 

func (m *SetOTPRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetOTPRequest) XXX_Merge 

func (m *SetOTPRequest) XXX_Merge(src proto.Message)

func (*SetOTPRequest) XXX_Size 

func (m *SetOTPRequest) XXX_Size() int

func (*SetOTPRequest) XXX_Unmarshal 

func (m *SetOTPRequest) XXX_Unmarshal(b []byte) error

type SetServerRequest 

type SetServerRequest struct {
	WifiAP               *WiFiAP  `protobuf:"bytes,1,opt,name=wifiAP,proto3" json:"wifiAP,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*SetServerRequest) Descriptor 

func (*SetServerRequest) Descriptor() ([]byte, []int)

func (*SetServerRequest) GetWifiAP 

func (m *SetServerRequest) GetWifiAP() *WiFiAP

func (*SetServerRequest) ProtoMessage 

func (*SetServerRequest) ProtoMessage()

func (*SetServerRequest) Reset 

func (m *SetServerRequest) Reset()

func (*SetServerRequest) String 

func (m *SetServerRequest) String() string

func (*SetServerRequest) XXX_DiscardUnknown 

func (m *SetServerRequest) XXX_DiscardUnknown()

func (*SetServerRequest) XXX_Marshal 

func (m *SetServerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetServerRequest) XXX_Merge 

func (m *SetServerRequest) XXX_Merge(src proto.Message)

func (*SetServerRequest) XXX_Size 

func (m *SetServerRequest) XXX_Size() int

func (*SetServerRequest) XXX_Unmarshal 

func (m *SetServerRequest) XXX_Unmarshal(b []byte) error

type SetSystemTimeRequest 

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 (*SetSystemTimeRequest) Descriptor 

func (*SetSystemTimeRequest) Descriptor() ([]byte, []int)

func (*SetSystemTimeRequest) GetTimestamp 

func (m *SetSystemTimeRequest) GetTimestamp() *timestamppb.Timestamp

func (*SetSystemTimeRequest) ProtoMessage 

func (*SetSystemTimeRequest) ProtoMessage()

func (*SetSystemTimeRequest) Reset 

func (m *SetSystemTimeRequest) Reset()

func (*SetSystemTimeRequest) String 

func (m *SetSystemTimeRequest) String() string

func (*SetSystemTimeRequest) XXX_DiscardUnknown 

func (m *SetSystemTimeRequest) XXX_DiscardUnknown()

func (*SetSystemTimeRequest) XXX_Marshal 

func (m *SetSystemTimeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetSystemTimeRequest) XXX_Merge 

func (m *SetSystemTimeRequest) XXX_Merge(src proto.Message)

func (*SetSystemTimeRequest) XXX_Size 

func (m *SetSystemTimeRequest) XXX_Size() int

func (*SetSystemTimeRequest) XXX_Unmarshal 

func (m *SetSystemTimeRequest) XXX_Unmarshal(b []byte) error

type SetTimezoneResquest 

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 (*SetTimezoneResquest) Descriptor 

func (*SetTimezoneResquest) Descriptor() ([]byte, []int)

func (*SetTimezoneResquest) GetTimezone 

func (m *SetTimezoneResquest) GetTimezone() string

func (*SetTimezoneResquest) ProtoMessage 

func (*SetTimezoneResquest) ProtoMessage()

func (*SetTimezoneResquest) Reset 

func (m *SetTimezoneResquest) Reset()

func (*SetTimezoneResquest) String 

func (m *SetTimezoneResquest) String() string

func (*SetTimezoneResquest) XXX_DiscardUnknown 

func (m *SetTimezoneResquest) XXX_DiscardUnknown()

func (*SetTimezoneResquest) XXX_Marshal 

func (m *SetTimezoneResquest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetTimezoneResquest) XXX_Merge 

func (m *SetTimezoneResquest) XXX_Merge(src proto.Message)

func (*SetTimezoneResquest) XXX_Size 

func (m *SetTimezoneResquest) XXX_Size() int

func (*SetTimezoneResquest) XXX_Unmarshal 

func (m *SetTimezoneResquest) XXX_Unmarshal(b []byte) error

type SetVPNRequest 

type SetVPNRequest struct {
	Enable bool `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"`
	// Types that are valid to be assigned to Vpn:
	//
	//	*SetVPNRequest_Pptp
	//	*SetVPNRequest_L2Tp
	//	*SetVPNRequest_Ipsec
	Vpn                  isSetVPNRequest_Vpn `protobuf_oneof:"vpn"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (*SetVPNRequest) Descriptor 

func (*SetVPNRequest) Descriptor() ([]byte, []int)

func (*SetVPNRequest) GetEnable 

func (m *SetVPNRequest) GetEnable() bool

func (*SetVPNRequest) GetIpsec 

func (m *SetVPNRequest) GetIpsec() *VPN_IPSec

func (*SetVPNRequest) GetL2Tp 

func (m *SetVPNRequest) GetL2Tp() *VPN_L2TP

func (*SetVPNRequest) GetPptp 

func (m *SetVPNRequest) GetPptp() *VPN_PPTP

func (*SetVPNRequest) GetVpn 

func (m *SetVPNRequest) GetVpn() isSetVPNRequest_Vpn

func (*SetVPNRequest) ProtoMessage 

func (*SetVPNRequest) ProtoMessage()

func (*SetVPNRequest) Reset 

func (m *SetVPNRequest) Reset()

func (*SetVPNRequest) String 

func (m *SetVPNRequest) String() string

func (*SetVPNRequest) XXX_DiscardUnknown 

func (m *SetVPNRequest) XXX_DiscardUnknown()

func (*SetVPNRequest) XXX_Marshal 

func (m *SetVPNRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SetVPNRequest) XXX_Merge 

func (m *SetVPNRequest) XXX_Merge(src proto.Message)

func (*SetVPNRequest) XXX_OneofWrappers 

func (*SetVPNRequest) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*SetVPNRequest) XXX_Size 

func (m *SetVPNRequest) XXX_Size() int

func (*SetVPNRequest) XXX_Unmarshal 

func (m *SetVPNRequest) XXX_Unmarshal(b []byte) error

type SetVPNRequest_Ipsec 

type SetVPNRequest_Ipsec struct {
	Ipsec *VPN_IPSec `protobuf:"bytes,3,opt,name=ipsec,json=IPSec,proto3,oneof"`
}

type SetVPNRequest_L2Tp 

type SetVPNRequest_L2Tp struct {
	L2Tp *VPN_L2TP `protobuf:"bytes,2,opt,name=l2tp,json=L2TP,proto3,oneof"`
}

type SetVPNRequest_Pptp 

type SetVPNRequest_Pptp struct {
	Pptp *VPN_PPTP `protobuf:"bytes,1,opt,name=pptp,json=PPTP,proto3,oneof"`
}

type SettingsResponse 

type SettingsResponse struct {
	// Branding settings.
	Branding *Branding `protobuf:"bytes,2,opt,name=branding,proto3" json:"branding,omitempty"`
	// OpenID Connect settings.
	OpenidConnect        *OpenIDConnect `protobuf:"bytes,3,opt,name=openid_connect,json=openidConnect,proto3" json:"openid_connect,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*SettingsResponse) Descriptor 

func (*SettingsResponse) Descriptor() ([]byte, []int)

func (*SettingsResponse) GetBranding 

func (m *SettingsResponse) GetBranding() *Branding

func (*SettingsResponse) GetOpenidConnect 

func (m *SettingsResponse) GetOpenidConnect() *OpenIDConnect

func (*SettingsResponse) ProtoMessage 

func (*SettingsResponse) ProtoMessage()

func (*SettingsResponse) Reset 

func (m *SettingsResponse) Reset()

func (*SettingsResponse) String 

func (m *SettingsResponse) String() string

func (*SettingsResponse) XXX_DiscardUnknown 

func (m *SettingsResponse) XXX_DiscardUnknown()

func (*SettingsResponse) XXX_Marshal 

func (m *SettingsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SettingsResponse) XXX_Merge 

func (m *SettingsResponse) XXX_Merge(src proto.Message)

func (*SettingsResponse) XXX_Size 

func (m *SettingsResponse) XXX_Size() int

func (*SettingsResponse) XXX_Unmarshal 

func (m *SettingsResponse) XXX_Unmarshal(b []byte) error

type ShellCommandRequest 

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

func (*ShellCommandRequest) Descriptor 

func (*ShellCommandRequest) Descriptor() ([]byte, []int)

func (*ShellCommandRequest) GetCmd 

func (m *ShellCommandRequest) GetCmd() string

func (*ShellCommandRequest) ProtoMessage 

func (*ShellCommandRequest) ProtoMessage()

func (*ShellCommandRequest) Reset 

func (m *ShellCommandRequest) Reset()

func (*ShellCommandRequest) String 

func (m *ShellCommandRequest) String() string

func (*ShellCommandRequest) XXX_DiscardUnknown 

func (m *ShellCommandRequest) XXX_DiscardUnknown()

func (*ShellCommandRequest) XXX_Marshal 

func (m *ShellCommandRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ShellCommandRequest) XXX_Merge 

func (m *ShellCommandRequest) XXX_Merge(src proto.Message)

func (*ShellCommandRequest) XXX_Size 

func (m *ShellCommandRequest) XXX_Size() int

func (*ShellCommandRequest) XXX_Unmarshal 

func (m *ShellCommandRequest) XXX_Unmarshal(b []byte) error

type ShellCommandResponse 

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

func (*ShellCommandResponse) Descriptor 

func (*ShellCommandResponse) Descriptor() ([]byte, []int)

func (*ShellCommandResponse) GetResult 

func (m *ShellCommandResponse) GetResult() string

func (*ShellCommandResponse) ProtoMessage 

func (*ShellCommandResponse) ProtoMessage()

func (*ShellCommandResponse) Reset 

func (m *ShellCommandResponse) Reset()

func (*ShellCommandResponse) String 

func (m *ShellCommandResponse) String() string

func (*ShellCommandResponse) XXX_DiscardUnknown 

func (m *ShellCommandResponse) XXX_DiscardUnknown()

func (*ShellCommandResponse) XXX_Marshal 

func (m *ShellCommandResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ShellCommandResponse) XXX_Merge 

func (m *ShellCommandResponse) XXX_Merge(src proto.Message)

func (*ShellCommandResponse) XXX_Size 

func (m *ShellCommandResponse) XXX_Size() int

func (*ShellCommandResponse) XXX_Unmarshal 

func (m *ShellCommandResponse) XXX_Unmarshal(b []byte) error

type SoftwareInformation 

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 (*SoftwareInformation) Descriptor 

func (*SoftwareInformation) Descriptor() ([]byte, []int)

func (*SoftwareInformation) GetDate 

func (m *SoftwareInformation) GetDate() string

func (*SoftwareInformation) GetName 

func (m *SoftwareInformation) GetName() string

func (*SoftwareInformation) GetPath 

func (m *SoftwareInformation) GetPath() string

func (*SoftwareInformation) GetVersion 

func (m *SoftwareInformation) GetVersion() string

func (*SoftwareInformation) ProtoMessage 

func (*SoftwareInformation) ProtoMessage()

func (*SoftwareInformation) Reset 

func (m *SoftwareInformation) Reset()

func (*SoftwareInformation) String 

func (m *SoftwareInformation) String() string

func (*SoftwareInformation) XXX_DiscardUnknown 

func (m *SoftwareInformation) XXX_DiscardUnknown()

func (*SoftwareInformation) XXX_Marshal 

func (m *SoftwareInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SoftwareInformation) XXX_Merge 

func (m *SoftwareInformation) XXX_Merge(src proto.Message)

func (*SoftwareInformation) XXX_Size 

func (m *SoftwareInformation) XXX_Size() int

func (*SoftwareInformation) XXX_Unmarshal 

func (m *SoftwareInformation) XXX_Unmarshal(b []byte) error

type StatisticsServiceClient 

type StatisticsServiceClient interface {
	// Get user list.
	StreamDeviceStats(ctx context.Context, in *DeviceStatsRequest, opts ...grpc.CallOption) (StatisticsService_StreamDeviceStatsClient, error)
	// Get data for a particular user.
	StreamGatewayStats(ctx context.Context, in *GatewayStatsRequest, opts ...grpc.CallOption) (StatisticsService_StreamGatewayStatsClient, error)
	DeviceStats(ctx context.Context, in *DeviceStatsRequest, opts ...grpc.CallOption) (*DeviceStatsResponse, error)
	// Get data for a particular user.
	GatewayStats(ctx context.Context, in *GatewayStatsRequest, opts ...grpc.CallOption) (*GatewayStatsResponse, error)
}

StatisticsServiceClient is the client API for StatisticsService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewStatisticsServiceClient 

func NewStatisticsServiceClient(cc grpc.ClientConnInterface) StatisticsServiceClient

type StatisticsServiceServer 

type StatisticsServiceServer interface {
	// Get user list.
	StreamDeviceStats(*DeviceStatsRequest, StatisticsService_StreamDeviceStatsServer) error
	// Get data for a particular user.
	StreamGatewayStats(*GatewayStatsRequest, StatisticsService_StreamGatewayStatsServer) error
	DeviceStats(context.Context, *DeviceStatsRequest) (*DeviceStatsResponse, error)
	// Get data for a particular user.
	GatewayStats(context.Context, *GatewayStatsRequest) (*GatewayStatsResponse, error)
}

StatisticsServiceServer is the server API for StatisticsService service.

type StatisticsService_StreamDeviceStatsClient 

type StatisticsService_StreamDeviceStatsClient interface {
	Recv() (*StreamDeviceStatsResponse, error)
	grpc.ClientStream
}

type StatisticsService_StreamDeviceStatsServer 

type StatisticsService_StreamDeviceStatsServer interface {
	Send(*StreamDeviceStatsResponse) error
	grpc.ServerStream
}

type StatisticsService_StreamGatewayStatsClient 

type StatisticsService_StreamGatewayStatsClient interface {
	Recv() (*StreamGatewayStatsResponse, error)
	grpc.ClientStream
}

type StatisticsService_StreamGatewayStatsServer 

type StatisticsService_StreamGatewayStatsServer interface {
	Send(*StreamGatewayStatsResponse) error
	grpc.ServerStream
}

type StreamDeviceEventLogsRequest 

type StreamDeviceEventLogsRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamDeviceEventLogsRequest) Descriptor 

func (*StreamDeviceEventLogsRequest) Descriptor() ([]byte, []int)

func (*StreamDeviceEventLogsRequest) GetDevEui 

func (m *StreamDeviceEventLogsRequest) GetDevEui() string

func (*StreamDeviceEventLogsRequest) ProtoMessage 

func (*StreamDeviceEventLogsRequest) ProtoMessage()

func (*StreamDeviceEventLogsRequest) Reset 

func (m *StreamDeviceEventLogsRequest) Reset()

func (*StreamDeviceEventLogsRequest) String 

func (m *StreamDeviceEventLogsRequest) String() string

func (*StreamDeviceEventLogsRequest) XXX_DiscardUnknown 

func (m *StreamDeviceEventLogsRequest) XXX_DiscardUnknown()

func (*StreamDeviceEventLogsRequest) XXX_Marshal 

func (m *StreamDeviceEventLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamDeviceEventLogsRequest) XXX_Merge 

func (m *StreamDeviceEventLogsRequest) XXX_Merge(src proto.Message)

func (*StreamDeviceEventLogsRequest) XXX_Size 

func (m *StreamDeviceEventLogsRequest) XXX_Size() int

func (*StreamDeviceEventLogsRequest) XXX_Unmarshal 

func (m *StreamDeviceEventLogsRequest) XXX_Unmarshal(b []byte) error

type StreamDeviceEventLogsResponse 

type StreamDeviceEventLogsResponse struct {
	// The event type.
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// The event payload in JSON encoding.
	PayloadJson          string   `protobuf:"bytes,2,opt,name=payload_json,json=payloadJSON,proto3" json:"payload_json,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamDeviceEventLogsResponse) Descriptor 

func (*StreamDeviceEventLogsResponse) Descriptor() ([]byte, []int)

func (*StreamDeviceEventLogsResponse) GetPayloadJson 

func (m *StreamDeviceEventLogsResponse) GetPayloadJson() string

func (*StreamDeviceEventLogsResponse) GetType 

func (m *StreamDeviceEventLogsResponse) GetType() string

func (*StreamDeviceEventLogsResponse) ProtoMessage 

func (*StreamDeviceEventLogsResponse) ProtoMessage()

func (*StreamDeviceEventLogsResponse) Reset 

func (m *StreamDeviceEventLogsResponse) Reset()

func (*StreamDeviceEventLogsResponse) String 

func (m *StreamDeviceEventLogsResponse) String() string

func (*StreamDeviceEventLogsResponse) XXX_DiscardUnknown 

func (m *StreamDeviceEventLogsResponse) XXX_DiscardUnknown()

func (*StreamDeviceEventLogsResponse) XXX_Marshal 

func (m *StreamDeviceEventLogsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamDeviceEventLogsResponse) XXX_Merge 

func (m *StreamDeviceEventLogsResponse) XXX_Merge(src proto.Message)

func (*StreamDeviceEventLogsResponse) XXX_Size 

func (m *StreamDeviceEventLogsResponse) XXX_Size() int

func (*StreamDeviceEventLogsResponse) XXX_Unmarshal 

func (m *StreamDeviceEventLogsResponse) XXX_Unmarshal(b []byte) error

type StreamDeviceFrameLogsRequest 

type StreamDeviceFrameLogsRequest struct {
	// Device EUI (HEX encoded).
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamDeviceFrameLogsRequest) Descriptor 

func (*StreamDeviceFrameLogsRequest) Descriptor() ([]byte, []int)

func (*StreamDeviceFrameLogsRequest) GetDevEui 

func (m *StreamDeviceFrameLogsRequest) GetDevEui() string

func (*StreamDeviceFrameLogsRequest) ProtoMessage 

func (*StreamDeviceFrameLogsRequest) ProtoMessage()

func (*StreamDeviceFrameLogsRequest) Reset 

func (m *StreamDeviceFrameLogsRequest) Reset()

func (*StreamDeviceFrameLogsRequest) String 

func (m *StreamDeviceFrameLogsRequest) String() string

func (*StreamDeviceFrameLogsRequest) XXX_DiscardUnknown 

func (m *StreamDeviceFrameLogsRequest) XXX_DiscardUnknown()

func (*StreamDeviceFrameLogsRequest) XXX_Marshal 

func (m *StreamDeviceFrameLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamDeviceFrameLogsRequest) XXX_Merge 

func (m *StreamDeviceFrameLogsRequest) XXX_Merge(src proto.Message)

func (*StreamDeviceFrameLogsRequest) XXX_Size 

func (m *StreamDeviceFrameLogsRequest) XXX_Size() int

func (*StreamDeviceFrameLogsRequest) XXX_Unmarshal 

func (m *StreamDeviceFrameLogsRequest) XXX_Unmarshal(b []byte) error

type StreamDeviceFrameLogsResponse 

type StreamDeviceFrameLogsResponse struct {
	// Types that are valid to be assigned to Frame:
	//
	//	*StreamDeviceFrameLogsResponse_UplinkFrame
	//	*StreamDeviceFrameLogsResponse_DownlinkFrame
	Frame                isStreamDeviceFrameLogsResponse_Frame `protobuf_oneof:"frame"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (*StreamDeviceFrameLogsResponse) Descriptor 

func (*StreamDeviceFrameLogsResponse) Descriptor() ([]byte, []int)

func (*StreamDeviceFrameLogsResponse) GetDownlinkFrame 

func (m *StreamDeviceFrameLogsResponse) GetDownlinkFrame() *DownlinkFrameLogForDevice

func (*StreamDeviceFrameLogsResponse) GetFrame 

func (m *StreamDeviceFrameLogsResponse) GetFrame() isStreamDeviceFrameLogsResponse_Frame

func (*StreamDeviceFrameLogsResponse) GetUplinkFrame 

func (m *StreamDeviceFrameLogsResponse) GetUplinkFrame() *UplinkFrameLogForDevice

func (*StreamDeviceFrameLogsResponse) ProtoMessage 

func (*StreamDeviceFrameLogsResponse) ProtoMessage()

func (*StreamDeviceFrameLogsResponse) Reset 

func (m *StreamDeviceFrameLogsResponse) Reset()

func (*StreamDeviceFrameLogsResponse) String 

func (m *StreamDeviceFrameLogsResponse) String() string

func (*StreamDeviceFrameLogsResponse) XXX_DiscardUnknown 

func (m *StreamDeviceFrameLogsResponse) XXX_DiscardUnknown()

func (*StreamDeviceFrameLogsResponse) XXX_Marshal 

func (m *StreamDeviceFrameLogsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamDeviceFrameLogsResponse) XXX_Merge 

func (m *StreamDeviceFrameLogsResponse) XXX_Merge(src proto.Message)

func (*StreamDeviceFrameLogsResponse) XXX_OneofWrappers 

func (*StreamDeviceFrameLogsResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*StreamDeviceFrameLogsResponse) XXX_Size 

func (m *StreamDeviceFrameLogsResponse) XXX_Size() int

func (*StreamDeviceFrameLogsResponse) XXX_Unmarshal 

func (m *StreamDeviceFrameLogsResponse) XXX_Unmarshal(b []byte) error

type StreamDeviceFrameLogsResponse_DownlinkFrame 

type StreamDeviceFrameLogsResponse_DownlinkFrame struct {
	DownlinkFrame *DownlinkFrameLogForDevice `protobuf:"bytes,2,opt,name=downlink_frame,json=downlinkFrame,proto3,oneof"`
}

type StreamDeviceFrameLogsResponse_UplinkFrame 

type StreamDeviceFrameLogsResponse_UplinkFrame struct {
	UplinkFrame *UplinkFrameLogForDevice `protobuf:"bytes,1,opt,name=uplink_frame,json=uplinkFrame,proto3,oneof"`
}

type StreamDeviceScanningReponse 

type StreamDeviceScanningReponse struct {
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamDeviceScanningReponse) Descriptor 

func (*StreamDeviceScanningReponse) Descriptor() ([]byte, []int)

func (*StreamDeviceScanningReponse) GetDevEui 

func (m *StreamDeviceScanningReponse) GetDevEui() string

func (*StreamDeviceScanningReponse) ProtoMessage 

func (*StreamDeviceScanningReponse) ProtoMessage()

func (*StreamDeviceScanningReponse) Reset 

func (m *StreamDeviceScanningReponse) Reset()

func (*StreamDeviceScanningReponse) String 

func (m *StreamDeviceScanningReponse) String() string

func (*StreamDeviceScanningReponse) XXX_DiscardUnknown 

func (m *StreamDeviceScanningReponse) XXX_DiscardUnknown()

func (*StreamDeviceScanningReponse) XXX_Marshal 

func (m *StreamDeviceScanningReponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamDeviceScanningReponse) XXX_Merge 

func (m *StreamDeviceScanningReponse) XXX_Merge(src proto.Message)

func (*StreamDeviceScanningReponse) XXX_Size 

func (m *StreamDeviceScanningReponse) XXX_Size() int

func (*StreamDeviceScanningReponse) XXX_Unmarshal 

func (m *StreamDeviceScanningReponse) XXX_Unmarshal(b []byte) error

type StreamDeviceScanningRequest 

type StreamDeviceScanningRequest struct {
	DevEuiTail           string   `protobuf:"bytes,1,opt,name=devEuiTail,json=devEUITail,proto3" json:"devEuiTail,omitempty"`
	TimeOutMs            int32    `protobuf:"varint,2,opt,name=timeOutMs,proto3" json:"timeOutMs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamDeviceScanningRequest) Descriptor 

func (*StreamDeviceScanningRequest) Descriptor() ([]byte, []int)

func (*StreamDeviceScanningRequest) GetDevEuiTail 

func (m *StreamDeviceScanningRequest) GetDevEuiTail() string

func (*StreamDeviceScanningRequest) GetTimeOutMs 

func (m *StreamDeviceScanningRequest) GetTimeOutMs() int32

func (*StreamDeviceScanningRequest) ProtoMessage 

func (*StreamDeviceScanningRequest) ProtoMessage()

func (*StreamDeviceScanningRequest) Reset 

func (m *StreamDeviceScanningRequest) Reset()

func (*StreamDeviceScanningRequest) String 

func (m *StreamDeviceScanningRequest) String() string

func (*StreamDeviceScanningRequest) XXX_DiscardUnknown 

func (m *StreamDeviceScanningRequest) XXX_DiscardUnknown()

func (*StreamDeviceScanningRequest) XXX_Marshal 

func (m *StreamDeviceScanningRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamDeviceScanningRequest) XXX_Merge 

func (m *StreamDeviceScanningRequest) XXX_Merge(src proto.Message)

func (*StreamDeviceScanningRequest) XXX_Size 

func (m *StreamDeviceScanningRequest) XXX_Size() int

func (*StreamDeviceScanningRequest) XXX_Unmarshal 

func (m *StreamDeviceScanningRequest) XXX_Unmarshal(b []byte) error

type StreamDeviceStatsResponse 

type StreamDeviceStatsResponse struct {
	Stats                *gw.DeviceStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*StreamDeviceStatsResponse) Descriptor 

func (*StreamDeviceStatsResponse) Descriptor() ([]byte, []int)

func (*StreamDeviceStatsResponse) GetStats 

func (m *StreamDeviceStatsResponse) GetStats() *gw.DeviceStats

func (*StreamDeviceStatsResponse) ProtoMessage 

func (*StreamDeviceStatsResponse) ProtoMessage()

func (*StreamDeviceStatsResponse) Reset 

func (m *StreamDeviceStatsResponse) Reset()

func (*StreamDeviceStatsResponse) String 

func (m *StreamDeviceStatsResponse) String() string

func (*StreamDeviceStatsResponse) XXX_DiscardUnknown 

func (m *StreamDeviceStatsResponse) XXX_DiscardUnknown()

func (*StreamDeviceStatsResponse) XXX_Marshal 

func (m *StreamDeviceStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamDeviceStatsResponse) XXX_Merge 

func (m *StreamDeviceStatsResponse) XXX_Merge(src proto.Message)

func (*StreamDeviceStatsResponse) XXX_Size 

func (m *StreamDeviceStatsResponse) XXX_Size() int

func (*StreamDeviceStatsResponse) XXX_Unmarshal 

func (m *StreamDeviceStatsResponse) XXX_Unmarshal(b []byte) error

type StreamGatewayFrameLogsRequest 

type StreamGatewayFrameLogsRequest struct {
	// Gateway ID (HEX encoded).
	GatewayId            string   `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayID,proto3" json:"gateway_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamGatewayFrameLogsRequest) Descriptor 

func (*StreamGatewayFrameLogsRequest) Descriptor() ([]byte, []int)

func (*StreamGatewayFrameLogsRequest) GetGatewayId 

func (m *StreamGatewayFrameLogsRequest) GetGatewayId() string

func (*StreamGatewayFrameLogsRequest) ProtoMessage 

func (*StreamGatewayFrameLogsRequest) ProtoMessage()

func (*StreamGatewayFrameLogsRequest) Reset 

func (m *StreamGatewayFrameLogsRequest) Reset()

func (*StreamGatewayFrameLogsRequest) String 

func (m *StreamGatewayFrameLogsRequest) String() string

func (*StreamGatewayFrameLogsRequest) XXX_DiscardUnknown 

func (m *StreamGatewayFrameLogsRequest) XXX_DiscardUnknown()

func (*StreamGatewayFrameLogsRequest) XXX_Marshal 

func (m *StreamGatewayFrameLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamGatewayFrameLogsRequest) XXX_Merge 

func (m *StreamGatewayFrameLogsRequest) XXX_Merge(src proto.Message)

func (*StreamGatewayFrameLogsRequest) XXX_Size 

func (m *StreamGatewayFrameLogsRequest) XXX_Size() int

func (*StreamGatewayFrameLogsRequest) XXX_Unmarshal 

func (m *StreamGatewayFrameLogsRequest) XXX_Unmarshal(b []byte) error

type StreamGatewayFrameLogsResponse 

type StreamGatewayFrameLogsResponse struct {
	// Types that are valid to be assigned to Frame:
	//
	//	*StreamGatewayFrameLogsResponse_UplinkFrame
	//	*StreamGatewayFrameLogsResponse_DownlinkFrame
	Frame                isStreamGatewayFrameLogsResponse_Frame `protobuf_oneof:"frame"`
	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
	XXX_unrecognized     []byte                                 `json:"-"`
	XXX_sizecache        int32                                  `json:"-"`
}

func (*StreamGatewayFrameLogsResponse) Descriptor 

func (*StreamGatewayFrameLogsResponse) Descriptor() ([]byte, []int)

func (*StreamGatewayFrameLogsResponse) GetDownlinkFrame 

func (m *StreamGatewayFrameLogsResponse) GetDownlinkFrame() *DownlinkFrameLog

func (*StreamGatewayFrameLogsResponse) GetFrame 

func (m *StreamGatewayFrameLogsResponse) GetFrame() isStreamGatewayFrameLogsResponse_Frame

func (*StreamGatewayFrameLogsResponse) GetUplinkFrame 

func (m *StreamGatewayFrameLogsResponse) GetUplinkFrame() *UplinkFrameLog

func (*StreamGatewayFrameLogsResponse) ProtoMessage 

func (*StreamGatewayFrameLogsResponse) ProtoMessage()

func (*StreamGatewayFrameLogsResponse) Reset 

func (m *StreamGatewayFrameLogsResponse) Reset()

func (*StreamGatewayFrameLogsResponse) String 

func (m *StreamGatewayFrameLogsResponse) String() string

func (*StreamGatewayFrameLogsResponse) XXX_DiscardUnknown 

func (m *StreamGatewayFrameLogsResponse) XXX_DiscardUnknown()

func (*StreamGatewayFrameLogsResponse) XXX_Marshal 

func (m *StreamGatewayFrameLogsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamGatewayFrameLogsResponse) XXX_Merge 

func (m *StreamGatewayFrameLogsResponse) XXX_Merge(src proto.Message)

func (*StreamGatewayFrameLogsResponse) XXX_OneofWrappers 

func (*StreamGatewayFrameLogsResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*StreamGatewayFrameLogsResponse) XXX_Size 

func (m *StreamGatewayFrameLogsResponse) XXX_Size() int

func (*StreamGatewayFrameLogsResponse) XXX_Unmarshal 

func (m *StreamGatewayFrameLogsResponse) XXX_Unmarshal(b []byte) error

type StreamGatewayFrameLogsResponse_DownlinkFrame 

type StreamGatewayFrameLogsResponse_DownlinkFrame struct {
	DownlinkFrame *DownlinkFrameLog `protobuf:"bytes,2,opt,name=downlink_frame,json=downlinkFrame,proto3,oneof"`
}

type StreamGatewayFrameLogsResponse_UplinkFrame 

type StreamGatewayFrameLogsResponse_UplinkFrame struct {
	UplinkFrame *UplinkFrameLog `protobuf:"bytes,1,opt,name=uplink_frame,json=uplinkFrame,proto3,oneof"`
}

type StreamGatewayStatsResponse 

type StreamGatewayStatsResponse struct {
	Stats                *gw.GatewayStatitics `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*StreamGatewayStatsResponse) Descriptor 

func (*StreamGatewayStatsResponse) Descriptor() ([]byte, []int)

func (*StreamGatewayStatsResponse) GetStats 

func (m *StreamGatewayStatsResponse) GetStats() *gw.GatewayStatitics

func (*StreamGatewayStatsResponse) ProtoMessage 

func (*StreamGatewayStatsResponse) ProtoMessage()

func (*StreamGatewayStatsResponse) Reset 

func (m *StreamGatewayStatsResponse) Reset()

func (*StreamGatewayStatsResponse) String 

func (m *StreamGatewayStatsResponse) String() string

func (*StreamGatewayStatsResponse) XXX_DiscardUnknown 

func (m *StreamGatewayStatsResponse) XXX_DiscardUnknown()

func (*StreamGatewayStatsResponse) XXX_Marshal 

func (m *StreamGatewayStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamGatewayStatsResponse) XXX_Merge 

func (m *StreamGatewayStatsResponse) XXX_Merge(src proto.Message)

func (*StreamGatewayStatsResponse) XXX_Size 

func (m *StreamGatewayStatsResponse) XXX_Size() int

func (*StreamGatewayStatsResponse) XXX_Unmarshal 

func (m *StreamGatewayStatsResponse) XXX_Unmarshal(b []byte) error

type StreamImportDeviceListResponse 

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 (*StreamImportDeviceListResponse) Descriptor 

func (*StreamImportDeviceListResponse) Descriptor() ([]byte, []int)

func (*StreamImportDeviceListResponse) GetCsv 

func (m *StreamImportDeviceListResponse) GetCsv() *FileUpload

func (*StreamImportDeviceListResponse) ProtoMessage 

func (*StreamImportDeviceListResponse) ProtoMessage()

func (*StreamImportDeviceListResponse) Reset 

func (m *StreamImportDeviceListResponse) Reset()

func (*StreamImportDeviceListResponse) String 

func (m *StreamImportDeviceListResponse) String() string

func (*StreamImportDeviceListResponse) XXX_DiscardUnknown 

func (m *StreamImportDeviceListResponse) XXX_DiscardUnknown()

func (*StreamImportDeviceListResponse) XXX_Marshal 

func (m *StreamImportDeviceListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamImportDeviceListResponse) XXX_Merge 

func (m *StreamImportDeviceListResponse) XXX_Merge(src proto.Message)

func (*StreamImportDeviceListResponse) XXX_Size 

func (m *StreamImportDeviceListResponse) XXX_Size() int

func (*StreamImportDeviceListResponse) XXX_Unmarshal 

func (m *StreamImportDeviceListResponse) XXX_Unmarshal(b []byte) error

type StreamInstallResponse 

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 (*StreamInstallResponse) Descriptor 

func (*StreamInstallResponse) Descriptor() ([]byte, []int)

func (*StreamInstallResponse) GetLogs 

func (m *StreamInstallResponse) GetLogs() string

func (*StreamInstallResponse) ProtoMessage 

func (*StreamInstallResponse) ProtoMessage()

func (*StreamInstallResponse) Reset 

func (m *StreamInstallResponse) Reset()

func (*StreamInstallResponse) String 

func (m *StreamInstallResponse) String() string

func (*StreamInstallResponse) XXX_DiscardUnknown 

func (m *StreamInstallResponse) XXX_DiscardUnknown()

func (*StreamInstallResponse) XXX_Marshal 

func (m *StreamInstallResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamInstallResponse) XXX_Merge 

func (m *StreamInstallResponse) XXX_Merge(src proto.Message)

func (*StreamInstallResponse) XXX_Size 

func (m *StreamInstallResponse) XXX_Size() int

func (*StreamInstallResponse) XXX_Unmarshal 

func (m *StreamInstallResponse) XXX_Unmarshal(b []byte) error

type StreamLogsResponse 

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

func (*StreamLogsResponse) Descriptor 

func (*StreamLogsResponse) Descriptor() ([]byte, []int)

func (*StreamLogsResponse) GetLogLevel 

func (m *StreamLogsResponse) GetLogLevel() string

func (*StreamLogsResponse) GetLogs 

func (m *StreamLogsResponse) GetLogs() string

func (*StreamLogsResponse) ProtoMessage 

func (*StreamLogsResponse) ProtoMessage()

func (*StreamLogsResponse) Reset 

func (m *StreamLogsResponse) Reset()

func (*StreamLogsResponse) String 

func (m *StreamLogsResponse) String() string

func (*StreamLogsResponse) XXX_DiscardUnknown 

func (m *StreamLogsResponse) XXX_DiscardUnknown()

func (*StreamLogsResponse) XXX_Marshal 

func (m *StreamLogsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamLogsResponse) XXX_Merge 

func (m *StreamLogsResponse) XXX_Merge(src proto.Message)

func (*StreamLogsResponse) XXX_Size 

func (m *StreamLogsResponse) XXX_Size() int

func (*StreamLogsResponse) XXX_Unmarshal 

func (m *StreamLogsResponse) XXX_Unmarshal(b []byte) error

type StreamLorawanRxRequest 

type StreamLorawanRxRequest struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamLorawanRxRequest) Descriptor 

func (*StreamLorawanRxRequest) Descriptor() ([]byte, []int)

func (*StreamLorawanRxRequest) GetFreq 

func (m *StreamLorawanRxRequest) GetFreq() int64

func (*StreamLorawanRxRequest) ProtoMessage 

func (*StreamLorawanRxRequest) ProtoMessage()

func (*StreamLorawanRxRequest) Reset 

func (m *StreamLorawanRxRequest) Reset()

func (*StreamLorawanRxRequest) String 

func (m *StreamLorawanRxRequest) String() string

func (*StreamLorawanRxRequest) XXX_DiscardUnknown 

func (m *StreamLorawanRxRequest) XXX_DiscardUnknown()

func (*StreamLorawanRxRequest) XXX_Marshal 

func (m *StreamLorawanRxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamLorawanRxRequest) XXX_Merge 

func (m *StreamLorawanRxRequest) XXX_Merge(src proto.Message)

func (*StreamLorawanRxRequest) XXX_Size 

func (m *StreamLorawanRxRequest) XXX_Size() int

func (*StreamLorawanRxRequest) XXX_Unmarshal 

func (m *StreamLorawanRxRequest) XXX_Unmarshal(b []byte) error

type StreamLorawanRxResponse 

type StreamLorawanRxResponse struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	Sf                   int32    `protobuf:"varint,2,opt,name=sf,proto3" json:"sf,omitempty"`
	Bw                   int64    `protobuf:"varint,3,opt,name=bw,proto3" json:"bw,omitempty"`
	Txpower              int32    `protobuf:"varint,4,opt,name=txpower,proto3" json:"txpower,omitempty"`
	PacketNum            int64    `protobuf:"varint,5,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	Snr                  float64  `protobuf:"fixed64,7,opt,name=snr,proto3" json:"snr,omitempty"`
	Rssi                 int32    `protobuf:"varint,8,opt,name=rssi,proto3" json:"rssi,omitempty"`
	Lostrate             float64  `protobuf:"fixed64,9,opt,name=lostrate,proto3" json:"lostrate,omitempty"`
	Logs                 string   `protobuf:"bytes,10,opt,name=logs,proto3" json:"logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamLorawanRxResponse) Descriptor 

func (*StreamLorawanRxResponse) Descriptor() ([]byte, []int)

func (*StreamLorawanRxResponse) GetBw 

func (m *StreamLorawanRxResponse) GetBw() int64

func (*StreamLorawanRxResponse) GetFreq 

func (m *StreamLorawanRxResponse) GetFreq() int64

func (*StreamLorawanRxResponse) GetLogs 

func (m *StreamLorawanRxResponse) GetLogs() string

func (*StreamLorawanRxResponse) GetLostrate 

func (m *StreamLorawanRxResponse) GetLostrate() float64

func (*StreamLorawanRxResponse) GetPacketNum 

func (m *StreamLorawanRxResponse) GetPacketNum() int64

func (*StreamLorawanRxResponse) GetRssi 

func (m *StreamLorawanRxResponse) GetRssi() int32

func (*StreamLorawanRxResponse) GetSf 

func (m *StreamLorawanRxResponse) GetSf() int32

func (*StreamLorawanRxResponse) GetSnr 

func (m *StreamLorawanRxResponse) GetSnr() float64

func (*StreamLorawanRxResponse) GetTxpower 

func (m *StreamLorawanRxResponse) GetTxpower() int32

func (*StreamLorawanRxResponse) ProtoMessage 

func (*StreamLorawanRxResponse) ProtoMessage()

func (*StreamLorawanRxResponse) Reset 

func (m *StreamLorawanRxResponse) Reset()

func (*StreamLorawanRxResponse) String 

func (m *StreamLorawanRxResponse) String() string

func (*StreamLorawanRxResponse) XXX_DiscardUnknown 

func (m *StreamLorawanRxResponse) XXX_DiscardUnknown()

func (*StreamLorawanRxResponse) XXX_Marshal 

func (m *StreamLorawanRxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamLorawanRxResponse) XXX_Merge 

func (m *StreamLorawanRxResponse) XXX_Merge(src proto.Message)

func (*StreamLorawanRxResponse) XXX_Size 

func (m *StreamLorawanRxResponse) XXX_Size() int

func (*StreamLorawanRxResponse) XXX_Unmarshal 

func (m *StreamLorawanRxResponse) XXX_Unmarshal(b []byte) error

type StreamLorawanTxResponse 

type StreamLorawanTxResponse struct {
	PacketNum            int64    `protobuf:"varint,1,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamLorawanTxResponse) Descriptor 

func (*StreamLorawanTxResponse) Descriptor() ([]byte, []int)

func (*StreamLorawanTxResponse) GetPacketNum 

func (m *StreamLorawanTxResponse) GetPacketNum() int64

func (*StreamLorawanTxResponse) ProtoMessage 

func (*StreamLorawanTxResponse) ProtoMessage()

func (*StreamLorawanTxResponse) Reset 

func (m *StreamLorawanTxResponse) Reset()

func (*StreamLorawanTxResponse) String 

func (m *StreamLorawanTxResponse) String() string

func (*StreamLorawanTxResponse) XXX_DiscardUnknown 

func (m *StreamLorawanTxResponse) XXX_DiscardUnknown()

func (*StreamLorawanTxResponse) XXX_Marshal 

func (m *StreamLorawanTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamLorawanTxResponse) XXX_Merge 

func (m *StreamLorawanTxResponse) XXX_Merge(src proto.Message)

func (*StreamLorawanTxResponse) XXX_Size 

func (m *StreamLorawanTxResponse) XXX_Size() int

func (*StreamLorawanTxResponse) XXX_Unmarshal 

func (m *StreamLorawanTxResponse) XXX_Unmarshal(b []byte) error

type StreamNFCRequest 

type StreamNFCRequest struct {
	Payload              string   `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Type                 string   `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*StreamNFCRequest) Descriptor 

func (*StreamNFCRequest) Descriptor() ([]byte, []int)

func (*StreamNFCRequest) GetPayload 

func (m *StreamNFCRequest) GetPayload() string

func (*StreamNFCRequest) GetType 

func (m *StreamNFCRequest) GetType() string

func (*StreamNFCRequest) ProtoMessage 

func (*StreamNFCRequest) ProtoMessage()

func (*StreamNFCRequest) Reset 

func (m *StreamNFCRequest) Reset()

func (*StreamNFCRequest) String 

func (m *StreamNFCRequest) String() string

func (*StreamNFCRequest) XXX_DiscardUnknown 

func (m *StreamNFCRequest) XXX_DiscardUnknown()

func (*StreamNFCRequest) XXX_Marshal 

func (m *StreamNFCRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamNFCRequest) XXX_Merge 

func (m *StreamNFCRequest) XXX_Merge(src proto.Message)

func (*StreamNFCRequest) XXX_Size 

func (m *StreamNFCRequest) XXX_Size() int

func (*StreamNFCRequest) XXX_Unmarshal 

func (m *StreamNFCRequest) XXX_Unmarshal(b []byte) error

type StreamNFCResponse 

type StreamNFCResponse struct {
	Progress int32 `protobuf:"varint,1,opt,name=progress,proto3" json:"progress,omitempty"`
	// Types that are valid to be assigned to Opt:
	//
	//	*StreamNFCResponse_Empty
	//	*StreamNFCResponse_Payload
	//	*StreamNFCResponse_Errors
	Opt                  isStreamNFCResponse_Opt `protobuf_oneof:"opt"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*StreamNFCResponse) Descriptor 

func (*StreamNFCResponse) Descriptor() ([]byte, []int)

func (*StreamNFCResponse) GetEmpty 

func (m *StreamNFCResponse) GetEmpty() *emptypb.Empty

func (*StreamNFCResponse) GetErrors 

func (m *StreamNFCResponse) GetErrors() string

func (*StreamNFCResponse) GetOpt 

func (m *StreamNFCResponse) GetOpt() isStreamNFCResponse_Opt

func (*StreamNFCResponse) GetPayload 

func (m *StreamNFCResponse) GetPayload() string

func (*StreamNFCResponse) GetProgress 

func (m *StreamNFCResponse) GetProgress() int32

func (*StreamNFCResponse) ProtoMessage 

func (*StreamNFCResponse) ProtoMessage()

func (*StreamNFCResponse) Reset 

func (m *StreamNFCResponse) Reset()

func (*StreamNFCResponse) String 

func (m *StreamNFCResponse) String() string

func (*StreamNFCResponse) XXX_DiscardUnknown 

func (m *StreamNFCResponse) XXX_DiscardUnknown()

func (*StreamNFCResponse) XXX_Marshal 

func (m *StreamNFCResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamNFCResponse) XXX_Merge 

func (m *StreamNFCResponse) XXX_Merge(src proto.Message)

func (*StreamNFCResponse) XXX_OneofWrappers 

func (*StreamNFCResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*StreamNFCResponse) XXX_Size 

func (m *StreamNFCResponse) XXX_Size() int

func (*StreamNFCResponse) XXX_Unmarshal 

func (m *StreamNFCResponse) XXX_Unmarshal(b []byte) error

type StreamNFCResponse_Empty 

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

type StreamNFCResponse_Errors 

type StreamNFCResponse_Errors struct {
	Errors string `protobuf:"bytes,4,opt,name=errors,proto3,oneof"`
}

type StreamNFCResponse_Payload 

type StreamNFCResponse_Payload struct {
	Payload string `protobuf:"bytes,3,opt,name=payload,proto3,oneof"`
}

type StreamNTPResponse 

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 (*StreamNTPResponse) Descriptor 

func (*StreamNTPResponse) Descriptor() ([]byte, []int)

func (*StreamNTPResponse) GetLogs 

func (m *StreamNTPResponse) GetLogs() string

func (*StreamNTPResponse) ProtoMessage 

func (*StreamNTPResponse) ProtoMessage()

func (*StreamNTPResponse) Reset 

func (m *StreamNTPResponse) Reset()

func (*StreamNTPResponse) String 

func (m *StreamNTPResponse) String() string

func (*StreamNTPResponse) XXX_DiscardUnknown 

func (m *StreamNTPResponse) XXX_DiscardUnknown()

func (*StreamNTPResponse) XXX_Marshal 

func (m *StreamNTPResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamNTPResponse) XXX_Merge 

func (m *StreamNTPResponse) XXX_Merge(src proto.Message)

func (*StreamNTPResponse) XXX_Size 

func (m *StreamNTPResponse) XXX_Size() int

func (*StreamNTPResponse) XXX_Unmarshal 

func (m *StreamNTPResponse) XXX_Unmarshal(b []byte) error

type StreamPingResponse 

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 (*StreamPingResponse) Descriptor 

func (*StreamPingResponse) Descriptor() ([]byte, []int)

func (*StreamPingResponse) GetLogs 

func (m *StreamPingResponse) GetLogs() string

func (*StreamPingResponse) ProtoMessage 

func (*StreamPingResponse) ProtoMessage()

func (*StreamPingResponse) Reset 

func (m *StreamPingResponse) Reset()

func (*StreamPingResponse) String 

func (m *StreamPingResponse) String() string

func (*StreamPingResponse) XXX_DiscardUnknown 

func (m *StreamPingResponse) XXX_DiscardUnknown()

func (*StreamPingResponse) XXX_Marshal 

func (m *StreamPingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamPingResponse) XXX_Merge 

func (m *StreamPingResponse) XXX_Merge(src proto.Message)

func (*StreamPingResponse) XXX_Size 

func (m *StreamPingResponse) XXX_Size() int

func (*StreamPingResponse) XXX_Unmarshal 

func (m *StreamPingResponse) XXX_Unmarshal(b []byte) error

type StreamSystemTimeResponse 

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 (*StreamSystemTimeResponse) Descriptor 

func (*StreamSystemTimeResponse) Descriptor() ([]byte, []int)

func (*StreamSystemTimeResponse) GetTimestamp 

func (m *StreamSystemTimeResponse) GetTimestamp() *timestamppb.Timestamp

func (*StreamSystemTimeResponse) ProtoMessage 

func (*StreamSystemTimeResponse) ProtoMessage()

func (*StreamSystemTimeResponse) Reset 

func (m *StreamSystemTimeResponse) Reset()

func (*StreamSystemTimeResponse) String 

func (m *StreamSystemTimeResponse) String() string

func (*StreamSystemTimeResponse) XXX_DiscardUnknown 

func (m *StreamSystemTimeResponse) XXX_DiscardUnknown()

func (*StreamSystemTimeResponse) XXX_Marshal 

func (m *StreamSystemTimeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamSystemTimeResponse) XXX_Merge 

func (m *StreamSystemTimeResponse) XXX_Merge(src proto.Message)

func (*StreamSystemTimeResponse) XXX_Size 

func (m *StreamSystemTimeResponse) XXX_Size() int

func (*StreamSystemTimeResponse) XXX_Unmarshal 

func (m *StreamSystemTimeResponse) XXX_Unmarshal(b []byte) error

type StreamUpgradeLogResponse 

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 (*StreamUpgradeLogResponse) Descriptor 

func (*StreamUpgradeLogResponse) Descriptor() ([]byte, []int)

func (*StreamUpgradeLogResponse) GetLogs 

func (m *StreamUpgradeLogResponse) GetLogs() string

func (*StreamUpgradeLogResponse) ProtoMessage 

func (*StreamUpgradeLogResponse) ProtoMessage()

func (*StreamUpgradeLogResponse) Reset 

func (m *StreamUpgradeLogResponse) Reset()

func (*StreamUpgradeLogResponse) String 

func (m *StreamUpgradeLogResponse) String() string

func (*StreamUpgradeLogResponse) XXX_DiscardUnknown 

func (m *StreamUpgradeLogResponse) XXX_DiscardUnknown()

func (*StreamUpgradeLogResponse) XXX_Marshal 

func (m *StreamUpgradeLogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*StreamUpgradeLogResponse) XXX_Merge 

func (m *StreamUpgradeLogResponse) XXX_Merge(src proto.Message)

func (*StreamUpgradeLogResponse) XXX_Size 

func (m *StreamUpgradeLogResponse) XXX_Size() int

func (*StreamUpgradeLogResponse) XXX_Unmarshal 

func (m *StreamUpgradeLogResponse) XXX_Unmarshal(b []byte) error

type SystemInfo 

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 (*SystemInfo) Descriptor 

func (*SystemInfo) Descriptor() ([]byte, []int)

func (*SystemInfo) GetCat1 

func (m *SystemInfo) GetCat1() *MoudleCat1

func (*SystemInfo) GetCpuUsg 

func (m *SystemInfo) GetCpuUsg() float32

func (*SystemInfo) GetEth 

func (m *SystemInfo) GetEth() *Ethernet

func (*SystemInfo) GetGatewayID 

func (m *SystemInfo) GetGatewayID() string

func (*SystemInfo) GetLora 

func (m *SystemInfo) GetLora() *GatewayLoraInfo

func (*SystemInfo) GetManufacturingDate 

func (m *SystemInfo) GetManufacturingDate() string

func (*SystemInfo) GetMemUsg 

func (m *SystemInfo) GetMemUsg() *MemoryUsage

func (*SystemInfo) GetProductName 

func (m *SystemInfo) GetProductName() string

func (*SystemInfo) GetProductSerialNumber 

func (m *SystemInfo) GetProductSerialNumber() string

func (*SystemInfo) GetTimestamp 

func (m *SystemInfo) GetTimestamp() *timestamppb.Timestamp

func (*SystemInfo) GetVersion 

func (m *SystemInfo) GetVersion() string

func (*SystemInfo) GetWifiAP 

func (m *SystemInfo) GetWifiAP() *WiFiAP

func (*SystemInfo) ProtoMessage 

func (*SystemInfo) ProtoMessage()

func (*SystemInfo) Reset 

func (m *SystemInfo) Reset()

func (*SystemInfo) String 

func (m *SystemInfo) String() string

func (*SystemInfo) XXX_DiscardUnknown 

func (m *SystemInfo) XXX_DiscardUnknown()

func (*SystemInfo) XXX_Marshal 

func (m *SystemInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*SystemInfo) XXX_Merge 

func (m *SystemInfo) XXX_Merge(src proto.Message)

func (*SystemInfo) XXX_Size 

func (m *SystemInfo) XXX_Size() int

func (*SystemInfo) XXX_Unmarshal 

func (m *SystemInfo) XXX_Unmarshal(b []byte) error

type SystemServiceClient 

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)
}

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.

func NewSystemServiceClient 

func NewSystemServiceClient(cc grpc.ClientConnInterface) SystemServiceClient

type SystemServiceServer 

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)
}

SystemServiceServer is the server API for SystemService service.

type SystemService_StreamUpgradeLogClient 

type SystemService_StreamUpgradeLogClient interface {
	Recv() (*StreamUpgradeLogResponse, error)
	grpc.ClientStream
}

type SystemService_StreamUpgradeLogServer 

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

type TXFreqItem 

type TXFreqItem struct {
	Min                  int32    `protobuf:"varint,1,opt,name=min,proto3" json:"min,omitempty"`
	Max                  int32    `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TXFreqItem) Descriptor 

func (*TXFreqItem) Descriptor() ([]byte, []int)

func (*TXFreqItem) GetMax 

func (m *TXFreqItem) GetMax() int32

func (*TXFreqItem) GetMin 

func (m *TXFreqItem) GetMin() int32

func (*TXFreqItem) ProtoMessage 

func (*TXFreqItem) ProtoMessage()

func (*TXFreqItem) Reset 

func (m *TXFreqItem) Reset()

func (*TXFreqItem) String 

func (m *TXFreqItem) String() string

func (*TXFreqItem) XXX_DiscardUnknown 

func (m *TXFreqItem) XXX_DiscardUnknown()

func (*TXFreqItem) XXX_Marshal 

func (m *TXFreqItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TXFreqItem) XXX_Merge 

func (m *TXFreqItem) XXX_Merge(src proto.Message)

func (*TXFreqItem) XXX_Size 

func (m *TXFreqItem) XXX_Size() int

func (*TXFreqItem) XXX_Unmarshal 

func (m *TXFreqItem) XXX_Unmarshal(b []byte) error

type ThingsBoardIntegration 

type ThingsBoardIntegration struct {
	// Application ID.
	ApplicationId int64 `protobuf:"varint,1,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	// ThingsBoard server endpoint, e.g. https://example.com
	Server               string   `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ThingsBoardIntegration) Descriptor 

func (*ThingsBoardIntegration) Descriptor() ([]byte, []int)

func (*ThingsBoardIntegration) GetApplicationId 

func (m *ThingsBoardIntegration) GetApplicationId() int64

func (*ThingsBoardIntegration) GetServer 

func (m *ThingsBoardIntegration) GetServer() string

func (*ThingsBoardIntegration) ProtoMessage 

func (*ThingsBoardIntegration) ProtoMessage()

func (*ThingsBoardIntegration) Reset 

func (m *ThingsBoardIntegration) Reset()

func (*ThingsBoardIntegration) String 

func (m *ThingsBoardIntegration) String() string

func (*ThingsBoardIntegration) XXX_DiscardUnknown 

func (m *ThingsBoardIntegration) XXX_DiscardUnknown()

func (*ThingsBoardIntegration) XXX_Marshal 

func (m *ThingsBoardIntegration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ThingsBoardIntegration) XXX_Merge 

func (m *ThingsBoardIntegration) XXX_Merge(src proto.Message)

func (*ThingsBoardIntegration) XXX_Size 

func (m *ThingsBoardIntegration) XXX_Size() int

func (*ThingsBoardIntegration) XXX_Unmarshal 

func (m *ThingsBoardIntegration) XXX_Unmarshal(b []byte) error

type Timezone 

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 (*Timezone) Descriptor 

func (*Timezone) Descriptor() ([]byte, []int)

func (*Timezone) GetKey 

func (m *Timezone) GetKey() string

func (*Timezone) GetValue 

func (m *Timezone) GetValue() []string

func (*Timezone) ProtoMessage 

func (*Timezone) ProtoMessage()

func (*Timezone) Reset 

func (m *Timezone) Reset()

func (*Timezone) String 

func (m *Timezone) String() string

func (*Timezone) XXX_DiscardUnknown 

func (m *Timezone) XXX_DiscardUnknown()

func (*Timezone) XXX_Marshal 

func (m *Timezone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Timezone) XXX_Merge 

func (m *Timezone) XXX_Merge(src proto.Message)

func (*Timezone) XXX_Size 

func (m *Timezone) XXX_Size() int

func (*Timezone) XXX_Unmarshal 

func (m *Timezone) XXX_Unmarshal(b []byte) error

type ToolsServiceClient 

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)
}

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.

func NewToolsServiceClient 

func NewToolsServiceClient(cc grpc.ClientConnInterface) ToolsServiceClient

type ToolsServiceServer 

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
}

ToolsServiceServer is the server API for ToolsService service.

type ToolsService_StreamImportDeviceListClient 

type ToolsService_StreamImportDeviceListClient interface {
	Recv() (*StreamImportDeviceListResponse, error)
	grpc.ClientStream
}

type ToolsService_StreamImportDeviceListServer 

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

type ToolsService_StreamInstallClient 

type ToolsService_StreamInstallClient interface {
	Recv() (*StreamInstallResponse, error)
	grpc.ClientStream
}

type ToolsService_StreamInstallServer 

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

type ToolsService_StreamNTPClient 

type ToolsService_StreamNTPClient interface {
	Recv() (*StreamNTPResponse, error)
	grpc.ClientStream
}

type ToolsService_StreamNTPServer 

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

type ToolsService_StreamPingClient 

type ToolsService_StreamPingClient interface {
	Recv() (*StreamPingResponse, error)
	grpc.ClientStream
}

type ToolsService_StreamPingServer 

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

type TxGainLutItem 

type TxGainLutItem struct {
	Rfpower              int64    `protobuf:"varint,1,opt,name=rfpower,json=rf_power,proto3" json:"rfpower,omitempty"`
	Pagain               int64    `protobuf:"varint,2,opt,name=pagain,json=pa_gain,proto3" json:"pagain,omitempty"`
	Pwridx               int64    `protobuf:"varint,3,opt,name=pwridx,json=pwr_idx,proto3" json:"pwridx,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TxGainLutItem) Descriptor 

func (*TxGainLutItem) Descriptor() ([]byte, []int)

func (*TxGainLutItem) GetPagain 

func (m *TxGainLutItem) GetPagain() int64

func (*TxGainLutItem) GetPwridx 

func (m *TxGainLutItem) GetPwridx() int64

func (*TxGainLutItem) GetRfpower 

func (m *TxGainLutItem) GetRfpower() int64

func (*TxGainLutItem) ProtoMessage 

func (*TxGainLutItem) ProtoMessage()

func (*TxGainLutItem) Reset 

func (m *TxGainLutItem) Reset()

func (*TxGainLutItem) String 

func (m *TxGainLutItem) String() string

func (*TxGainLutItem) XXX_DiscardUnknown 

func (m *TxGainLutItem) XXX_DiscardUnknown()

func (*TxGainLutItem) XXX_Marshal 

func (m *TxGainLutItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxGainLutItem) XXX_Merge 

func (m *TxGainLutItem) XXX_Merge(src proto.Message)

func (*TxGainLutItem) XXX_Size 

func (m *TxGainLutItem) XXX_Size() int

func (*TxGainLutItem) XXX_Unmarshal 

func (m *TxGainLutItem) XXX_Unmarshal(b []byte) error

type US915Config 

type US915Config struct {
	LoraWanPublic        bool        `protobuf:"varint,1,opt,name=loraWanPublic,proto3" json:"loraWanPublic,omitempty"`
	SubBandId            int32       `protobuf:"varint,2,opt,name=subBandId,proto3" json:"subBandId,omitempty"`
	TxFreq               *TXFreqItem `protobuf:"bytes,3,opt,name=txFreq,proto3" json:"txFreq,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*US915Config) Descriptor 

func (*US915Config) Descriptor() ([]byte, []int)

func (*US915Config) GetLoraWanPublic 

func (m *US915Config) GetLoraWanPublic() bool

func (*US915Config) GetSubBandId 

func (m *US915Config) GetSubBandId() int32

func (*US915Config) GetTxFreq 

func (m *US915Config) GetTxFreq() *TXFreqItem

func (*US915Config) ProtoMessage 

func (*US915Config) ProtoMessage()

func (*US915Config) Reset 

func (m *US915Config) Reset()

func (*US915Config) String 

func (m *US915Config) String() string

func (*US915Config) XXX_DiscardUnknown 

func (m *US915Config) XXX_DiscardUnknown()

func (*US915Config) XXX_Marshal 

func (m *US915Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*US915Config) XXX_Merge 

func (m *US915Config) XXX_Merge(src proto.Message)

func (*US915Config) XXX_Size 

func (m *US915Config) XXX_Size() int

func (*US915Config) XXX_Unmarshal 

func (m *US915Config) XXX_Unmarshal(b []byte) error

type UnimplementedApplicationServiceServer 

type UnimplementedApplicationServiceServer struct {
}

UnimplementedApplicationServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedApplicationServiceServer) Create 

func (*UnimplementedApplicationServiceServer) Create(ctx context.Context, req *CreateApplicationRequest) (*CreateApplicationResponse, error)

func (*UnimplementedApplicationServiceServer) CreateAWSSNSIntegration 

func (*UnimplementedApplicationServiceServer) CreateAWSSNSIntegration(ctx context.Context, req *CreateAWSSNSIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreateAzureServiceBusIntegration 

func (*UnimplementedApplicationServiceServer) CreateAzureServiceBusIntegration(ctx context.Context, req *CreateAzureServiceBusIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreateGCPPubSubIntegration 

func (*UnimplementedApplicationServiceServer) CreateGCPPubSubIntegration(ctx context.Context, req *CreateGCPPubSubIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreateHTTPIntegration 

func (*UnimplementedApplicationServiceServer) CreateHTTPIntegration(ctx context.Context, req *CreateHTTPIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreateInfluxDBIntegration 

func (*UnimplementedApplicationServiceServer) CreateInfluxDBIntegration(ctx context.Context, req *CreateInfluxDBIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreateLoRaCloudIntegration 

func (*UnimplementedApplicationServiceServer) CreateLoRaCloudIntegration(ctx context.Context, req *CreateLoRaCloudIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreateMyDevicesIntegration 

func (*UnimplementedApplicationServiceServer) CreateMyDevicesIntegration(ctx context.Context, req *CreateMyDevicesIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreatePilotThingsIntegration 

func (*UnimplementedApplicationServiceServer) CreatePilotThingsIntegration(ctx context.Context, req *CreatePilotThingsIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) CreateThingsBoardIntegration 

func (*UnimplementedApplicationServiceServer) CreateThingsBoardIntegration(ctx context.Context, req *CreateThingsBoardIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) Delete 

func (*UnimplementedApplicationServiceServer) Delete(ctx context.Context, req *DeleteApplicationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteAWSSNSIntegration 

func (*UnimplementedApplicationServiceServer) DeleteAWSSNSIntegration(ctx context.Context, req *DeleteAWSSNSIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteAzureServiceBusIntegration 

func (*UnimplementedApplicationServiceServer) DeleteAzureServiceBusIntegration(ctx context.Context, req *DeleteAzureServiceBusIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteGCPPubSubIntegration 

func (*UnimplementedApplicationServiceServer) DeleteGCPPubSubIntegration(ctx context.Context, req *DeleteGCPPubSubIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteHTTPIntegration 

func (*UnimplementedApplicationServiceServer) DeleteHTTPIntegration(ctx context.Context, req *DeleteHTTPIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteInfluxDBIntegration 

func (*UnimplementedApplicationServiceServer) DeleteInfluxDBIntegration(ctx context.Context, req *DeleteInfluxDBIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteLoRaCloudIntegration 

func (*UnimplementedApplicationServiceServer) DeleteLoRaCloudIntegration(ctx context.Context, req *DeleteLoRaCloudIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteMyDevicesIntegration 

func (*UnimplementedApplicationServiceServer) DeleteMyDevicesIntegration(ctx context.Context, req *DeleteMyDevicesIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeletePilotThingsIntegration 

func (*UnimplementedApplicationServiceServer) DeletePilotThingsIntegration(ctx context.Context, req *DeletePilotThingsIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) DeleteThingsBoardIntegration 

func (*UnimplementedApplicationServiceServer) DeleteThingsBoardIntegration(ctx context.Context, req *DeleteThingsBoardIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) Get 

func (*UnimplementedApplicationServiceServer) Get(ctx context.Context, req *GetApplicationRequest) (*GetApplicationResponse, error)

func (*UnimplementedApplicationServiceServer) GetAWSSNSIntegration 

func (*UnimplementedApplicationServiceServer) GetAWSSNSIntegration(ctx context.Context, req *GetAWSSNSIntegrationRequest) (*GetAWSSNSIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetAzureServiceBusIntegration 

func (*UnimplementedApplicationServiceServer) GetAzureServiceBusIntegration(ctx context.Context, req *GetAzureServiceBusIntegrationRequest) (*GetAzureServiceBusIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetGCPPubSubIntegration 

func (*UnimplementedApplicationServiceServer) GetGCPPubSubIntegration(ctx context.Context, req *GetGCPPubSubIntegrationRequest) (*GetGCPPubSubIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetHTTPIntegration 

func (*UnimplementedApplicationServiceServer) GetHTTPIntegration(ctx context.Context, req *GetHTTPIntegrationRequest) (*GetHTTPIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetInfluxDBIntegration 

func (*UnimplementedApplicationServiceServer) GetInfluxDBIntegration(ctx context.Context, req *GetInfluxDBIntegrationRequest) (*GetInfluxDBIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetLoRaCloudIntegration 

func (*UnimplementedApplicationServiceServer) GetLoRaCloudIntegration(ctx context.Context, req *GetLoRaCloudIntegrationRequest) (*GetLoRaCloudIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetMyDevicesIntegration 

func (*UnimplementedApplicationServiceServer) GetMyDevicesIntegration(ctx context.Context, req *GetMyDevicesIntegrationRequest) (*GetMyDevicesIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetPilotThingsIntegration 

func (*UnimplementedApplicationServiceServer) GetPilotThingsIntegration(ctx context.Context, req *GetPilotThingsIntegrationRequest) (*GetPilotThingsIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) GetThingsBoardIntegration 

func (*UnimplementedApplicationServiceServer) GetThingsBoardIntegration(ctx context.Context, req *GetThingsBoardIntegrationRequest) (*GetThingsBoardIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) List 

func (*UnimplementedApplicationServiceServer) List(ctx context.Context, req *ListApplicationRequest) (*ListApplicationResponse, error)

func (*UnimplementedApplicationServiceServer) ListIntegrations 

func (*UnimplementedApplicationServiceServer) ListIntegrations(ctx context.Context, req *ListIntegrationRequest) (*ListIntegrationResponse, error)

func (*UnimplementedApplicationServiceServer) Update 

func (*UnimplementedApplicationServiceServer) Update(ctx context.Context, req *UpdateApplicationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateAWSSNSIntegration 

func (*UnimplementedApplicationServiceServer) UpdateAWSSNSIntegration(ctx context.Context, req *UpdateAWSSNSIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateAzureServiceBusIntegration 

func (*UnimplementedApplicationServiceServer) UpdateAzureServiceBusIntegration(ctx context.Context, req *UpdateAzureServiceBusIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateGCPPubSubIntegration 

func (*UnimplementedApplicationServiceServer) UpdateGCPPubSubIntegration(ctx context.Context, req *UpdateGCPPubSubIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateHTTPIntegration 

func (*UnimplementedApplicationServiceServer) UpdateHTTPIntegration(ctx context.Context, req *UpdateHTTPIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateInfluxDBIntegration 

func (*UnimplementedApplicationServiceServer) UpdateInfluxDBIntegration(ctx context.Context, req *UpdateInfluxDBIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateLoRaCloudIntegration 

func (*UnimplementedApplicationServiceServer) UpdateLoRaCloudIntegration(ctx context.Context, req *UpdateLoRaCloudIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateMyDevicesIntegration 

func (*UnimplementedApplicationServiceServer) UpdateMyDevicesIntegration(ctx context.Context, req *UpdateMyDevicesIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdatePilotThingsIntegration 

func (*UnimplementedApplicationServiceServer) UpdatePilotThingsIntegration(ctx context.Context, req *UpdatePilotThingsIntegrationRequest) (*emptypb.Empty, error)

func (*UnimplementedApplicationServiceServer) UpdateThingsBoardIntegration 

func (*UnimplementedApplicationServiceServer) UpdateThingsBoardIntegration(ctx context.Context, req *UpdateThingsBoardIntegrationRequest) (*emptypb.Empty, error)

type UnimplementedDebugServiceServer 

type UnimplementedDebugServiceServer struct {
}

UnimplementedDebugServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedDebugServiceServer) GetLorawanRx 

func (*UnimplementedDebugServiceServer) GetLorawanRx(ctx context.Context, req *emptypb.Empty) (*GetLorawanRxResponse, error)

func (*UnimplementedDebugServiceServer) GetLorawanTx 

func (*UnimplementedDebugServiceServer) GetLorawanTx(ctx context.Context, req *emptypb.Empty) (*GetLorawanTxResponse, error)

func (*UnimplementedDebugServiceServer) GetVPN 

func (*UnimplementedDebugServiceServer) GetVPN(ctx context.Context, req *emptypb.Empty) (*GetVPNResponse, error)

func (*UnimplementedDebugServiceServer) SetLogs 

func (*UnimplementedDebugServiceServer) SetLogs(ctx context.Context, req *SetLogsRequest) (*emptypb.Empty, error)

func (*UnimplementedDebugServiceServer) SetLorawanTx 

func (*UnimplementedDebugServiceServer) SetLorawanTx(ctx context.Context, req *SetLorawanTxRequest) (*emptypb.Empty, error)

func (*UnimplementedDebugServiceServer) SetVPN 

func (*UnimplementedDebugServiceServer) SetVPN(ctx context.Context, req *SetVPNRequest) (*emptypb.Empty, error)

func (*UnimplementedDebugServiceServer) StreamLogs 

func (*UnimplementedDebugServiceServer) StreamLogs(req *emptypb.Empty, srv DebugService_StreamLogsServer) error

func (*UnimplementedDebugServiceServer) StreamLorawanRx 

func (*UnimplementedDebugServiceServer) StreamLorawanRx(req *StreamLorawanRxRequest, srv DebugService_StreamLorawanRxServer) error

func (*UnimplementedDebugServiceServer) StreamLorawanTx 

func (*UnimplementedDebugServiceServer) StreamLorawanTx(req *emptypb.Empty, srv DebugService_StreamLorawanTxServer) error

type UnimplementedDeviceProfileServiceServer 

type UnimplementedDeviceProfileServiceServer struct {
}

UnimplementedDeviceProfileServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedDeviceProfileServiceServer) Create 

func (*UnimplementedDeviceProfileServiceServer) Create(ctx context.Context, req *CreateDeviceProfileRequest) (*CreateDeviceProfileResponse, error)

func (*UnimplementedDeviceProfileServiceServer) Delete 

func (*UnimplementedDeviceProfileServiceServer) Delete(ctx context.Context, req *DeleteDeviceProfileRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceProfileServiceServer) Get 

func (*UnimplementedDeviceProfileServiceServer) Get(ctx context.Context, req *GetDeviceProfileRequest) (*GetDeviceProfileResponse, error)

func (*UnimplementedDeviceProfileServiceServer) List 

func (*UnimplementedDeviceProfileServiceServer) List(ctx context.Context, req *ListDeviceProfileRequest) (*ListDeviceProfileResponse, error)

func (*UnimplementedDeviceProfileServiceServer) Update 

func (*UnimplementedDeviceProfileServiceServer) Update(ctx context.Context, req *UpdateDeviceProfileRequest) (*emptypb.Empty, error)

type UnimplementedDeviceQueueServiceServer 

type UnimplementedDeviceQueueServiceServer struct {
}

UnimplementedDeviceQueueServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedDeviceQueueServiceServer) Enqueue 

func (*UnimplementedDeviceQueueServiceServer) Enqueue(ctx context.Context, req *EnqueueDeviceQueueItemRequest) (*EnqueueDeviceQueueItemResponse, error)

func (*UnimplementedDeviceQueueServiceServer) Flush 

func (*UnimplementedDeviceQueueServiceServer) Flush(ctx context.Context, req *FlushDeviceQueueRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceQueueServiceServer) FlushAll 

func (*UnimplementedDeviceQueueServiceServer) FlushAll(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error)

func (*UnimplementedDeviceQueueServiceServer) List 

func (*UnimplementedDeviceQueueServiceServer) List(ctx context.Context, req *ListDeviceQueueItemsRequest) (*ListDeviceQueueItemsResponse, error)

func (*UnimplementedDeviceQueueServiceServer) ListALL 

func (*UnimplementedDeviceQueueServiceServer) ListALL(ctx context.Context, req *emptypb.Empty) (*ListDeviceQueueItemsResponse, error)

type UnimplementedDeviceServiceServer 

type UnimplementedDeviceServiceServer struct {
}

UnimplementedDeviceServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedDeviceServiceServer) Activate 

func (*UnimplementedDeviceServiceServer) Activate(ctx context.Context, req *ActivateDeviceRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceServiceServer) Create 

func (*UnimplementedDeviceServiceServer) Create(ctx context.Context, req *CreateDeviceRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceServiceServer) CreateAndActivateABPEnableDevice 

func (*UnimplementedDeviceServiceServer) CreateAndActivateABPEnableDevice(ctx context.Context, req *CreateAndActivateABPEnableDeviceRequest) (*CreateAndActivateABPEnableDeviceResponse, error)

func (*UnimplementedDeviceServiceServer) CreateKeys 

func (*UnimplementedDeviceServiceServer) CreateKeys(ctx context.Context, req *CreateDeviceKeysRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceServiceServer) CreateOTAAEnableDeviceAndKey 

func (*UnimplementedDeviceServiceServer) CreateOTAAEnableDeviceAndKey(ctx context.Context, req *CreateOTAAEnableDeviceAndKeyRequest) (*CreateOTAAEnableDeviceAndKeyResponse, error)

func (*UnimplementedDeviceServiceServer) Deactivate 

func (*UnimplementedDeviceServiceServer) Deactivate(ctx context.Context, req *DeactivateDeviceRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceServiceServer) Delete 

func (*UnimplementedDeviceServiceServer) Delete(ctx context.Context, req *DeleteDeviceRequest) (*DeleteDeviceResponse, error)

func (*UnimplementedDeviceServiceServer) DeleteKeys 

func (*UnimplementedDeviceServiceServer) DeleteKeys(ctx context.Context, req *DeleteDeviceKeysRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceServiceServer) Get 

func (*UnimplementedDeviceServiceServer) Get(ctx context.Context, req *GetDeviceRequest) (*GetDeviceResponse, error)

func (*UnimplementedDeviceServiceServer) GetActivation 

func (*UnimplementedDeviceServiceServer) GetActivation(ctx context.Context, req *GetDeviceActivationRequest) (*GetDeviceActivationResponse, error)

func (*UnimplementedDeviceServiceServer) GetDeviceDetails 

func (*UnimplementedDeviceServiceServer) GetDeviceDetails(ctx context.Context, req *GetDeviceDetailsRequest) (*GetDeviceDetailsResponse, error)

func (*UnimplementedDeviceServiceServer) GetKeys 

func (*UnimplementedDeviceServiceServer) GetKeys(ctx context.Context, req *GetDeviceKeysRequest) (*GetDeviceKeysResponse, error)

func (*UnimplementedDeviceServiceServer) GetRandomDevAddr 

func (*UnimplementedDeviceServiceServer) GetRandomDevAddr(ctx context.Context, req *GetRandomDevAddrRequest) (*GetRandomDevAddrResponse, error)

func (*UnimplementedDeviceServiceServer) List 

func (*UnimplementedDeviceServiceServer) List(ctx context.Context, req *ListDeviceRequest) (*ListDeviceResponse, error)

func (*UnimplementedDeviceServiceServer) QtcodeScanCreate 

func (*UnimplementedDeviceServiceServer) QtcodeScanCreate(ctx context.Context, req *QtcodeCreateDeviceRequest) (*QtcodeCreateDeviceResponse, error)

func (*UnimplementedDeviceServiceServer) StreamDeviceScanning 

func (*UnimplementedDeviceServiceServer) StreamDeviceScanning(req *StreamDeviceScanningRequest, srv DeviceService_StreamDeviceScanningServer) error

func (*UnimplementedDeviceServiceServer) StreamEventLogs 

func (*UnimplementedDeviceServiceServer) StreamEventLogs(req *StreamDeviceEventLogsRequest, srv DeviceService_StreamEventLogsServer) error

func (*UnimplementedDeviceServiceServer) StreamFrameLogs 

func (*UnimplementedDeviceServiceServer) StreamFrameLogs(req *StreamDeviceFrameLogsRequest, srv DeviceService_StreamFrameLogsServer) error

func (*UnimplementedDeviceServiceServer) StreamNFC 

func (*UnimplementedDeviceServiceServer) StreamNFC(srv DeviceService_StreamNFCServer) error

func (*UnimplementedDeviceServiceServer) Update 

func (*UnimplementedDeviceServiceServer) Update(ctx context.Context, req *UpdateDeviceRequest) (*emptypb.Empty, error)

func (*UnimplementedDeviceServiceServer) UpdateKeys 

func (*UnimplementedDeviceServiceServer) UpdateKeys(ctx context.Context, req *UpdateDeviceKeysRequest) (*emptypb.Empty, error)

type UnimplementedFUOTADeploymentServiceServer 

type UnimplementedFUOTADeploymentServiceServer struct {
}

UnimplementedFUOTADeploymentServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedFUOTADeploymentServiceServer) CreateForDevice 

func (*UnimplementedFUOTADeploymentServiceServer) CreateForDevice(ctx context.Context, req *CreateFUOTADeploymentForDeviceRequest) (*CreateFUOTADeploymentForDeviceResponse, error)

func (*UnimplementedFUOTADeploymentServiceServer) Get 

func (*UnimplementedFUOTADeploymentServiceServer) Get(ctx context.Context, req *GetFUOTADeploymentRequest) (*GetFUOTADeploymentResponse, error)

func (*UnimplementedFUOTADeploymentServiceServer) GetDeploymentDevice 

func (*UnimplementedFUOTADeploymentServiceServer) GetDeploymentDevice(ctx context.Context, req *GetFUOTADeploymentDeviceRequest) (*GetFUOTADeploymentDeviceResponse, error)

func (*UnimplementedFUOTADeploymentServiceServer) List 

func (*UnimplementedFUOTADeploymentServiceServer) List(ctx context.Context, req *ListFUOTADeploymentRequest) (*ListFUOTADeploymentResponse, error)

func (*UnimplementedFUOTADeploymentServiceServer) ListDeploymentDevices 

func (*UnimplementedFUOTADeploymentServiceServer) ListDeploymentDevices(ctx context.Context, req *ListFUOTADeploymentDevicesRequest) (*ListFUOTADeploymentDevicesResponse, error)

type UnimplementedGatewayProfileServiceServer 

type UnimplementedGatewayProfileServiceServer struct {
}

UnimplementedGatewayProfileServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedGatewayProfileServiceServer) Create 

func (*UnimplementedGatewayProfileServiceServer) Create(ctx context.Context, req *CreateGatewayProfileRequest) (*CreateGatewayProfileResponse, error)

func (*UnimplementedGatewayProfileServiceServer) Delete 

func (*UnimplementedGatewayProfileServiceServer) Delete(ctx context.Context, req *DeleteGatewayProfileRequest) (*emptypb.Empty, error)

func (*UnimplementedGatewayProfileServiceServer) Get 

func (*UnimplementedGatewayProfileServiceServer) Get(ctx context.Context, req *GetGatewayProfileRequest) (*GetGatewayProfileResponse, error)

func (*UnimplementedGatewayProfileServiceServer) List 

func (*UnimplementedGatewayProfileServiceServer) List(ctx context.Context, req *ListGatewayProfilesRequest) (*ListGatewayProfilesResponse, error)

func (*UnimplementedGatewayProfileServiceServer) Update 

func (*UnimplementedGatewayProfileServiceServer) Update(ctx context.Context, req *UpdateGatewayProfileRequest) (*emptypb.Empty, error)

type UnimplementedGatewayServiceServer 

type UnimplementedGatewayServiceServer struct {
}

UnimplementedGatewayServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedGatewayServiceServer) Create 

func (*UnimplementedGatewayServiceServer) Create(ctx context.Context, req *CreateGatewayRequest) (*emptypb.Empty, error)

func (*UnimplementedGatewayServiceServer) Delete 

func (*UnimplementedGatewayServiceServer) Delete(ctx context.Context, req *DeleteGatewayRequest) (*emptypb.Empty, error)

func (*UnimplementedGatewayServiceServer) GenerateGatewayClientCertificate 

func (*UnimplementedGatewayServiceServer) GenerateGatewayClientCertificate(ctx context.Context, req *GenerateGatewayClientCertificateRequest) (*GenerateGatewayClientCertificateResponse, error)

func (*UnimplementedGatewayServiceServer) Get 

func (*UnimplementedGatewayServiceServer) Get(ctx context.Context, req *GetGatewayRequest) (*GetGatewayResponse, error)

func (*UnimplementedGatewayServiceServer) GetLastPing 

func (*UnimplementedGatewayServiceServer) GetLastPing(ctx context.Context, req *GetLastPingRequest) (*GetLastPingResponse, error)

func (*UnimplementedGatewayServiceServer) GetStats 

func (*UnimplementedGatewayServiceServer) GetStats(ctx context.Context, req *GetGatewayStatsRequest) (*GetGatewayStatsResponse, error)

func (*UnimplementedGatewayServiceServer) List 

func (*UnimplementedGatewayServiceServer) List(ctx context.Context, req *ListGatewayRequest) (*ListGatewayResponse, error)

func (*UnimplementedGatewayServiceServer) StreamFrameLogs 

func (*UnimplementedGatewayServiceServer) StreamFrameLogs(req *StreamGatewayFrameLogsRequest, srv GatewayService_StreamFrameLogsServer) error

func (*UnimplementedGatewayServiceServer) Update 

func (*UnimplementedGatewayServiceServer) Update(ctx context.Context, req *UpdateGatewayRequest) (*emptypb.Empty, error)

type UnimplementedInternalServiceServer 

type UnimplementedInternalServiceServer struct {
}

UnimplementedInternalServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedInternalServiceServer) CreateAPIKey 

func (*UnimplementedInternalServiceServer) CreateAPIKey(ctx context.Context, req *CreateAPIKeyRequest) (*CreateAPIKeyResponse, error)

func (*UnimplementedInternalServiceServer) DeleteAPIKey 

func (*UnimplementedInternalServiceServer) DeleteAPIKey(ctx context.Context, req *DeleteAPIKeyRequest) (*emptypb.Empty, error)

func (*UnimplementedInternalServiceServer) GetDevicesSummary 

func (*UnimplementedInternalServiceServer) GetDevicesSummary(ctx context.Context, req *GetDevicesSummaryRequest) (*GetDevicesSummaryResponse, error)

func (*UnimplementedInternalServiceServer) GetGatewaysSummary 

func (*UnimplementedInternalServiceServer) GetGatewaysSummary(ctx context.Context, req *GetGatewaysSummaryRequest) (*GetGatewaysSummaryResponse, error)

func (*UnimplementedInternalServiceServer) GlobalSearch 

func (*UnimplementedInternalServiceServer) GlobalSearch(ctx context.Context, req *GlobalSearchRequest) (*GlobalSearchResponse, error)

func (*UnimplementedInternalServiceServer) ListAPIKeys 

func (*UnimplementedInternalServiceServer) ListAPIKeys(ctx context.Context, req *ListAPIKeysRequest) (*ListAPIKeysResponse, error)

func (*UnimplementedInternalServiceServer) Login 

func (*UnimplementedInternalServiceServer) Login(ctx context.Context, req *LoginRequest) (*LoginResponse, error)

func (*UnimplementedInternalServiceServer) OpenIDConnectLogin 

func (*UnimplementedInternalServiceServer) OpenIDConnectLogin(ctx context.Context, req *OpenIDConnectLoginRequest) (*OpenIDConnectLoginResponse, error)

func (*UnimplementedInternalServiceServer) Profile 

func (*UnimplementedInternalServiceServer) Profile(ctx context.Context, req *emptypb.Empty) (*ProfileResponse, error)

func (*UnimplementedInternalServiceServer) Quit 

func (*UnimplementedInternalServiceServer) Quit(ctx context.Context, req *QuitRequest) (*emptypb.Empty, error)

func (*UnimplementedInternalServiceServer) Settings 

func (*UnimplementedInternalServiceServer) Settings(ctx context.Context, req *emptypb.Empty) (*SettingsResponse, error)

func (*UnimplementedInternalServiceServer) ShellCommand 

func (*UnimplementedInternalServiceServer) ShellCommand(ctx context.Context, req *ShellCommandRequest) (*ShellCommandResponse, error)

type UnimplementedLoraWANServiceServer 

type UnimplementedLoraWANServiceServer struct {
}

UnimplementedLoraWANServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedLoraWANServiceServer) ConfigGateWayModeRegion 

func (*UnimplementedLoraWANServiceServer) ConfigGateWayModeRegion(ctx context.Context, req *ConfigGateWayModeRegionRequest) (*emptypb.Empty, error)

func (*UnimplementedLoraWANServiceServer) Get 

func (*UnimplementedLoraWANServiceServer) Get(ctx context.Context, req *emptypb.Empty) (*GetGateWayModeRegionResponse, error)

func (*UnimplementedLoraWANServiceServer) GetLoRaWANFilter 

func (*UnimplementedLoraWANServiceServer) GetLoRaWANFilter(ctx context.Context, req *emptypb.Empty) (*LoRaWANFilterResponse, error)

func (*UnimplementedLoraWANServiceServer) GetLoRaWANMode 

func (*UnimplementedLoraWANServiceServer) GetLoRaWANMode(ctx context.Context, req *emptypb.Empty) (*LoRaWANModeResponse, error)

func (*UnimplementedLoraWANServiceServer) GetLoRaWANRegion 

func (*UnimplementedLoraWANServiceServer) GetLoRaWANRegion(ctx context.Context, req *emptypb.Empty) (*LoRaWANRegionResponse, error)

func (*UnimplementedLoraWANServiceServer) SetLoRaWANFilter 

func (*UnimplementedLoraWANServiceServer) SetLoRaWANFilter(ctx context.Context, req *LoRaWANFilterRequest) (*emptypb.Empty, error)

func (*UnimplementedLoraWANServiceServer) SetLoRaWANMode 

func (*UnimplementedLoraWANServiceServer) SetLoRaWANMode(ctx context.Context, req *LoRaWANModeRequest) (*emptypb.Empty, error)

func (*UnimplementedLoraWANServiceServer) SetLoRaWANRegion 

func (*UnimplementedLoraWANServiceServer) SetLoRaWANRegion(ctx context.Context, req *LoRaWANRegionRequest) (*emptypb.Empty, error)

type UnimplementedMulticastGroupServiceServer 

type UnimplementedMulticastGroupServiceServer struct {
}

UnimplementedMulticastGroupServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedMulticastGroupServiceServer) AddDevice 

func (*UnimplementedMulticastGroupServiceServer) AddDevice(ctx context.Context, req *AddDeviceToMulticastGroupRequest) (*emptypb.Empty, error)

func (*UnimplementedMulticastGroupServiceServer) Create 

func (*UnimplementedMulticastGroupServiceServer) Create(ctx context.Context, req *CreateMulticastGroupRequest) (*CreateMulticastGroupResponse, error)

func (*UnimplementedMulticastGroupServiceServer) Delete 

func (*UnimplementedMulticastGroupServiceServer) Delete(ctx context.Context, req *DeleteMulticastGroupRequest) (*emptypb.Empty, error)

func (*UnimplementedMulticastGroupServiceServer) Enqueue 

func (*UnimplementedMulticastGroupServiceServer) Enqueue(ctx context.Context, req *EnqueueMulticastQueueItemRequest) (*EnqueueMulticastQueueItemResponse, error)

func (*UnimplementedMulticastGroupServiceServer) FlushQueue 

func (*UnimplementedMulticastGroupServiceServer) FlushQueue(ctx context.Context, req *FlushMulticastGroupQueueItemsRequest) (*emptypb.Empty, error)

func (*UnimplementedMulticastGroupServiceServer) Get 

func (*UnimplementedMulticastGroupServiceServer) Get(ctx context.Context, req *GetMulticastGroupRequest) (*GetMulticastGroupResponse, error)

func (*UnimplementedMulticastGroupServiceServer) List 

func (*UnimplementedMulticastGroupServiceServer) List(ctx context.Context, req *ListMulticastGroupRequest) (*ListMulticastGroupResponse, error)

func (*UnimplementedMulticastGroupServiceServer) ListQueue 

func (*UnimplementedMulticastGroupServiceServer) ListQueue(ctx context.Context, req *ListMulticastGroupQueueItemsRequest) (*ListMulticastGroupQueueItemsResponse, error)

func (*UnimplementedMulticastGroupServiceServer) RemoveDevice 

func (*UnimplementedMulticastGroupServiceServer) RemoveDevice(ctx context.Context, req *RemoveDeviceFromMulticastGroupRequest) (*emptypb.Empty, error)

func (*UnimplementedMulticastGroupServiceServer) Update 

func (*UnimplementedMulticastGroupServiceServer) Update(ctx context.Context, req *UpdateMulticastGroupRequest) (*emptypb.Empty, error)

type UnimplementedNetworkServerServiceServer 

type UnimplementedNetworkServerServiceServer struct {
}

UnimplementedNetworkServerServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedNetworkServerServiceServer) Create 

func (*UnimplementedNetworkServerServiceServer) Create(ctx context.Context, req *CreateNetworkServerRequest) (*CreateNetworkServerResponse, error)

func (*UnimplementedNetworkServerServiceServer) Delete 

func (*UnimplementedNetworkServerServiceServer) Delete(ctx context.Context, req *DeleteNetworkServerRequest) (*emptypb.Empty, error)

func (*UnimplementedNetworkServerServiceServer) Get 

func (*UnimplementedNetworkServerServiceServer) Get(ctx context.Context, req *GetNetworkServerRequest) (*GetNetworkServerResponse, error)

func (*UnimplementedNetworkServerServiceServer) List 

func (*UnimplementedNetworkServerServiceServer) List(ctx context.Context, req *ListNetworkServerRequest) (*ListNetworkServerResponse, error)

func (*UnimplementedNetworkServerServiceServer) Update 

func (*UnimplementedNetworkServerServiceServer) Update(ctx context.Context, req *UpdateNetworkServerRequest) (*emptypb.Empty, error)

type UnimplementedNetworkServiceServer 

type UnimplementedNetworkServiceServer struct {
}

UnimplementedNetworkServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedNetworkServiceServer) GetCat1 

func (*UnimplementedNetworkServiceServer) GetCat1(ctx context.Context, req *emptypb.Empty) (*Cat1Response, error)

func (*UnimplementedNetworkServiceServer) GetClient 

func (*UnimplementedNetworkServiceServer) GetClient(ctx context.Context, req *emptypb.Empty) (*GetClientResponse, error)

func (*UnimplementedNetworkServiceServer) GetEncryptList 

func (*UnimplementedNetworkServiceServer) GetEncryptList(ctx context.Context, req *emptypb.Empty) (*EncryptListResponse, error)

func (*UnimplementedNetworkServiceServer) GetEthernet 

func (*UnimplementedNetworkServiceServer) GetEthernet(ctx context.Context, req *emptypb.Empty) (*EthernetResponse, error)

func (*UnimplementedNetworkServiceServer) GetWiFi 

func (*UnimplementedNetworkServiceServer) GetWiFi(ctx context.Context, req *emptypb.Empty) (*WiFiResponse, error)

func (*UnimplementedNetworkServiceServer) GetWiFiConfiguration 

func (*UnimplementedNetworkServiceServer) GetWiFiConfiguration(ctx context.Context, req *GetWiFiConfigurationRequest) (*GetWiFiConfigurationResponse, error)

func (*UnimplementedNetworkServiceServer) GetWiFiList 

func (*UnimplementedNetworkServiceServer) GetWiFiList(ctx context.Context, req *emptypb.Empty) (*WiFiListResponse, error)

func (*UnimplementedNetworkServiceServer) SetCat1 

func (*UnimplementedNetworkServiceServer) SetCat1(ctx context.Context, req *Cat1Request) (*emptypb.Empty, error)

func (*UnimplementedNetworkServiceServer) SetClient 

func (*UnimplementedNetworkServiceServer) SetClient(ctx context.Context, req *SetClientRequest) (*emptypb.Empty, error)

func (*UnimplementedNetworkServiceServer) SetEthernet 

func (*UnimplementedNetworkServiceServer) SetEthernet(ctx context.Context, req *EthernetRequest) (*emptypb.Empty, error)

func (*UnimplementedNetworkServiceServer) SetWiFi 

func (*UnimplementedNetworkServiceServer) SetWiFi(ctx context.Context, req *WiFiRequest) (*emptypb.Empty, error)

type UnimplementedOTPServiceServer 

type UnimplementedOTPServiceServer struct {
}

UnimplementedOTPServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedOTPServiceServer) EncryptSN 

func (*UnimplementedOTPServiceServer) EncryptSN(ctx context.Context, req *EncryptSNRequest) (*emptypb.Empty, error)

func (*UnimplementedOTPServiceServer) GET_SECURE_OTP_BLOCK0 

func (*UnimplementedOTPServiceServer) GET_SECURE_OTP_BLOCK0(ctx context.Context, req *emptypb.Empty) (*BLOCK0Response, error)

func (*UnimplementedOTPServiceServer) Get 

func (*UnimplementedOTPServiceServer) Get(ctx context.Context, req *GetOTPRequest) (*GetOTPResponse, error)

func (*UnimplementedOTPServiceServer) GetEncryptSN 

func (*UnimplementedOTPServiceServer) GetEncryptSN(ctx context.Context, req *emptypb.Empty) (*EncryptSNResponse, error)

func (*UnimplementedOTPServiceServer) List 

func (*UnimplementedOTPServiceServer) List(ctx context.Context, req *emptypb.Empty) (*ListOTPResponse, error)

func (*UnimplementedOTPServiceServer) SET_SECURE_OTP_BLOCK0 

func (*UnimplementedOTPServiceServer) SET_SECURE_OTP_BLOCK0(ctx context.Context, req *BLOCK0Request) (*emptypb.Empty, error)

func (*UnimplementedOTPServiceServer) Set 

func (*UnimplementedOTPServiceServer) Set(ctx context.Context, req *SetOTPRequest) (*emptypb.Empty, error)

type UnimplementedOrganizationServiceServer 

type UnimplementedOrganizationServiceServer struct {
}

UnimplementedOrganizationServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedOrganizationServiceServer) AddUser 

func (*UnimplementedOrganizationServiceServer) AddUser(ctx context.Context, req *AddOrganizationUserRequest) (*emptypb.Empty, error)

func (*UnimplementedOrganizationServiceServer) Create 

func (*UnimplementedOrganizationServiceServer) Create(ctx context.Context, req *CreateOrganizationRequest) (*CreateOrganizationResponse, error)

func (*UnimplementedOrganizationServiceServer) Delete 

func (*UnimplementedOrganizationServiceServer) Delete(ctx context.Context, req *DeleteOrganizationRequest) (*emptypb.Empty, error)

func (*UnimplementedOrganizationServiceServer) DeleteUser 

func (*UnimplementedOrganizationServiceServer) DeleteUser(ctx context.Context, req *DeleteOrganizationUserRequest) (*emptypb.Empty, error)

func (*UnimplementedOrganizationServiceServer) Get 

func (*UnimplementedOrganizationServiceServer) Get(ctx context.Context, req *GetOrganizationRequest) (*GetOrganizationResponse, error)

func (*UnimplementedOrganizationServiceServer) GetUser 

func (*UnimplementedOrganizationServiceServer) GetUser(ctx context.Context, req *GetOrganizationUserRequest) (*GetOrganizationUserResponse, error)

func (*UnimplementedOrganizationServiceServer) List 

func (*UnimplementedOrganizationServiceServer) List(ctx context.Context, req *ListOrganizationRequest) (*ListOrganizationResponse, error)

func (*UnimplementedOrganizationServiceServer) ListUsers 

func (*UnimplementedOrganizationServiceServer) ListUsers(ctx context.Context, req *ListOrganizationUsersRequest) (*ListOrganizationUsersResponse, error)

func (*UnimplementedOrganizationServiceServer) Update 

func (*UnimplementedOrganizationServiceServer) Update(ctx context.Context, req *UpdateOrganizationRequest) (*emptypb.Empty, error)

func (*UnimplementedOrganizationServiceServer) UpdateUser 

func (*UnimplementedOrganizationServiceServer) UpdateUser(ctx context.Context, req *UpdateOrganizationUserRequest) (*emptypb.Empty, error)

type UnimplementedServiceProfileServiceServer 

type UnimplementedServiceProfileServiceServer struct {
}

UnimplementedServiceProfileServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedServiceProfileServiceServer) Create 

func (*UnimplementedServiceProfileServiceServer) Create(ctx context.Context, req *CreateServiceProfileRequest) (*CreateServiceProfileResponse, error)

func (*UnimplementedServiceProfileServiceServer) Delete 

func (*UnimplementedServiceProfileServiceServer) Delete(ctx context.Context, req *DeleteServiceProfileRequest) (*emptypb.Empty, error)

func (*UnimplementedServiceProfileServiceServer) Get 

func (*UnimplementedServiceProfileServiceServer) Get(ctx context.Context, req *GetServiceProfileRequest) (*GetServiceProfileResponse, error)

func (*UnimplementedServiceProfileServiceServer) List 

func (*UnimplementedServiceProfileServiceServer) List(ctx context.Context, req *ListServiceProfileRequest) (*ListServiceProfileResponse, error)

func (*UnimplementedServiceProfileServiceServer) Update 

func (*UnimplementedServiceProfileServiceServer) Update(ctx context.Context, req *UpdateServiceProfileRequest) (*emptypb.Empty, error)

type UnimplementedStatisticsServiceServer 

type UnimplementedStatisticsServiceServer struct {
}

UnimplementedStatisticsServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedStatisticsServiceServer) DeviceStats 

func (*UnimplementedStatisticsServiceServer) DeviceStats(ctx context.Context, req *DeviceStatsRequest) (*DeviceStatsResponse, error)

func (*UnimplementedStatisticsServiceServer) GatewayStats 

func (*UnimplementedStatisticsServiceServer) GatewayStats(ctx context.Context, req *GatewayStatsRequest) (*GatewayStatsResponse, error)

func (*UnimplementedStatisticsServiceServer) StreamDeviceStats 

func (*UnimplementedStatisticsServiceServer) StreamDeviceStats(req *DeviceStatsRequest, srv StatisticsService_StreamDeviceStatsServer) error

func (*UnimplementedStatisticsServiceServer) StreamGatewayStats 

func (*UnimplementedStatisticsServiceServer) StreamGatewayStats(req *GatewayStatsRequest, srv StatisticsService_StreamGatewayStatsServer) error

type UnimplementedSystemServiceServer 

type UnimplementedSystemServiceServer struct {
}

UnimplementedSystemServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedSystemServiceServer) Backup 

func (*UnimplementedSystemServiceServer) Backup(ctx context.Context, req *BackupRequest) (*emptypb.Empty, error)

func (*UnimplementedSystemServiceServer) BackupList 

func (*UnimplementedSystemServiceServer) BackupList(ctx context.Context, req *emptypb.Empty) (*BackupListResponse, error)

func (*UnimplementedSystemServiceServer) FactoryRestore 

func (*UnimplementedSystemServiceServer) FactoryRestore(ctx context.Context, req *FactoryRestoreResquest) (*emptypb.Empty, error)

func (*UnimplementedSystemServiceServer) GetSystemTime 

func (*UnimplementedSystemServiceServer) GetSystemTime(ctx context.Context, req *emptypb.Empty) (*GetSystemTimeResponse, error)

func (*UnimplementedSystemServiceServer) GetTimezone 

func (*UnimplementedSystemServiceServer) GetTimezone(ctx context.Context, req *emptypb.Empty) (*GetTimezoneResponse, error)

func (*UnimplementedSystemServiceServer) Query 

func (*UnimplementedSystemServiceServer) Query(ctx context.Context, req *emptypb.Empty) (*QueryResponse, error)

func (*UnimplementedSystemServiceServer) Restore 

func (*UnimplementedSystemServiceServer) Restore(ctx context.Context, req *RestoreRequest) (*emptypb.Empty, error)

func (*UnimplementedSystemServiceServer) SetSystemTime 

func (*UnimplementedSystemServiceServer) SetSystemTime(ctx context.Context, req *SetSystemTimeRequest) (*emptypb.Empty, error)

func (*UnimplementedSystemServiceServer) SetTimezone 

func (*UnimplementedSystemServiceServer) SetTimezone(ctx context.Context, req *SetTimezoneResquest) (*emptypb.Empty, error)

func (*UnimplementedSystemServiceServer) StreamUpgradeLog 

func (*UnimplementedSystemServiceServer) StreamUpgradeLog(req *emptypb.Empty, srv SystemService_StreamUpgradeLogServer) error

func (*UnimplementedSystemServiceServer) Upgrade 

func (*UnimplementedSystemServiceServer) Upgrade(ctx context.Context, req *UpgradeRequest) (*emptypb.Empty, error)

func (*UnimplementedSystemServiceServer) Upload 

func (*UnimplementedSystemServiceServer) Upload(ctx context.Context, req *UploadFWRequest) (*UploadFWResponse, error)

func (*UnimplementedSystemServiceServer) Usage 

func (*UnimplementedSystemServiceServer) Usage(ctx context.Context, req *emptypb.Empty) (*UsageResponse, error)

func (*UnimplementedSystemServiceServer) VaildToken 

func (*UnimplementedSystemServiceServer) VaildToken(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error)

type UnimplementedToolsServiceServer 

type UnimplementedToolsServiceServer struct {
}

UnimplementedToolsServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedToolsServiceServer) GetNTP 

func (*UnimplementedToolsServiceServer) GetNTP(ctx context.Context, req *emptypb.Empty) (*GetNTPResponse, error)

func (*UnimplementedToolsServiceServer) GetNodered 

func (*UnimplementedToolsServiceServer) GetNodered(ctx context.Context, req *emptypb.Empty) (*GetNoderedResponse, error)

func (*UnimplementedToolsServiceServer) Install 

func (*UnimplementedToolsServiceServer) Install(ctx context.Context, req *InstallRequest) (*emptypb.Empty, error)

func (*UnimplementedToolsServiceServer) InstallList 

func (*UnimplementedToolsServiceServer) InstallList(ctx context.Context, req *InstallListRequest) (*InstallListResponse, error)

func (*UnimplementedToolsServiceServer) Ping 

func (*UnimplementedToolsServiceServer) Ping(ctx context.Context, req *PingRequest) (*emptypb.Empty, error)

func (*UnimplementedToolsServiceServer) Reboot 

func (*UnimplementedToolsServiceServer) Reboot(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error)

func (*UnimplementedToolsServiceServer) SetNTP 

func (*UnimplementedToolsServiceServer) SetNTP(ctx context.Context, req *SetNTPRequest) (*emptypb.Empty, error)

func (*UnimplementedToolsServiceServer) SetNodeRed 

func (*UnimplementedToolsServiceServer) SetNodeRed(ctx context.Context, req *SetNoderedRequest) (*emptypb.Empty, error)

func (*UnimplementedToolsServiceServer) StreamImportDeviceList 

func (*UnimplementedToolsServiceServer) StreamImportDeviceList(req *emptypb.Empty, srv ToolsService_StreamImportDeviceListServer) error

func (*UnimplementedToolsServiceServer) StreamInstall 

func (*UnimplementedToolsServiceServer) StreamInstall(req *emptypb.Empty, srv ToolsService_StreamInstallServer) error

func (*UnimplementedToolsServiceServer) StreamNTP 

func (*UnimplementedToolsServiceServer) StreamNTP(req *emptypb.Empty, srv ToolsService_StreamNTPServer) error

func (*UnimplementedToolsServiceServer) StreamPing 

func (*UnimplementedToolsServiceServer) StreamPing(req *emptypb.Empty, srv ToolsService_StreamPingServer) error

func (*UnimplementedToolsServiceServer) Uninstall 

func (*UnimplementedToolsServiceServer) Uninstall(ctx context.Context, req *UninstallRequest) (*emptypb.Empty, error)

func (*UnimplementedToolsServiceServer) Upload 

func (*UnimplementedToolsServiceServer) Upload(ctx context.Context, req *UploadRequest) (*UploadResponse, error)

type UnimplementedUserServiceServer 

type UnimplementedUserServiceServer struct {
}

UnimplementedUserServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedUserServiceServer) Create 

func (*UnimplementedUserServiceServer) Create(ctx context.Context, req *CreateUserRequest) (*CreateUserResponse, error)

func (*UnimplementedUserServiceServer) Delete 

func (*UnimplementedUserServiceServer) Delete(ctx context.Context, req *DeleteUserRequest) (*emptypb.Empty, error)

func (*UnimplementedUserServiceServer) Get 

func (*UnimplementedUserServiceServer) Get(ctx context.Context, req *GetUserRequest) (*GetUserResponse, error)

func (*UnimplementedUserServiceServer) List 

func (*UnimplementedUserServiceServer) List(ctx context.Context, req *ListUserRequest) (*ListUserResponse, error)

func (*UnimplementedUserServiceServer) Update 

func (*UnimplementedUserServiceServer) Update(ctx context.Context, req *UpdateUserRequest) (*emptypb.Empty, error)

func (*UnimplementedUserServiceServer) UpdatePassword 

func (*UnimplementedUserServiceServer) UpdatePassword(ctx context.Context, req *UpdateUserPasswordRequest) (*emptypb.Empty, error)

type UninstallRequest 

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 (*UninstallRequest) Descriptor 

func (*UninstallRequest) Descriptor() ([]byte, []int)

func (*UninstallRequest) GetSoftware 

func (m *UninstallRequest) GetSoftware() *SoftwareInformation

func (*UninstallRequest) ProtoMessage 

func (*UninstallRequest) ProtoMessage()

func (*UninstallRequest) Reset 

func (m *UninstallRequest) Reset()

func (*UninstallRequest) String 

func (m *UninstallRequest) String() string

func (*UninstallRequest) XXX_DiscardUnknown 

func (m *UninstallRequest) XXX_DiscardUnknown()

func (*UninstallRequest) XXX_Marshal 

func (m *UninstallRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UninstallRequest) XXX_Merge 

func (m *UninstallRequest) XXX_Merge(src proto.Message)

func (*UninstallRequest) XXX_Size 

func (m *UninstallRequest) XXX_Size() int

func (*UninstallRequest) XXX_Unmarshal 

func (m *UninstallRequest) XXX_Unmarshal(b []byte) error

type UpdateAWSSNSIntegrationRequest 

type UpdateAWSSNSIntegrationRequest struct {
	// Integration object to update.
	Integration          *AWSSNSIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*UpdateAWSSNSIntegrationRequest) Descriptor 

func (*UpdateAWSSNSIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateAWSSNSIntegrationRequest) GetIntegration 

func (m *UpdateAWSSNSIntegrationRequest) GetIntegration() *AWSSNSIntegration

func (*UpdateAWSSNSIntegrationRequest) ProtoMessage 

func (*UpdateAWSSNSIntegrationRequest) ProtoMessage()

func (*UpdateAWSSNSIntegrationRequest) Reset 

func (m *UpdateAWSSNSIntegrationRequest) Reset()

func (*UpdateAWSSNSIntegrationRequest) String 

func (m *UpdateAWSSNSIntegrationRequest) String() string

func (*UpdateAWSSNSIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateAWSSNSIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateAWSSNSIntegrationRequest) XXX_Marshal 

func (m *UpdateAWSSNSIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateAWSSNSIntegrationRequest) XXX_Merge 

func (m *UpdateAWSSNSIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateAWSSNSIntegrationRequest) XXX_Size 

func (m *UpdateAWSSNSIntegrationRequest) XXX_Size() int

func (*UpdateAWSSNSIntegrationRequest) XXX_Unmarshal 

func (m *UpdateAWSSNSIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateApplicationRequest 

type UpdateApplicationRequest struct {
	// Application object to update.
	Application          *Application `protobuf:"bytes,1,opt,name=application,proto3" json:"application,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (*UpdateApplicationRequest) Descriptor 

func (*UpdateApplicationRequest) Descriptor() ([]byte, []int)

func (*UpdateApplicationRequest) GetApplication 

func (m *UpdateApplicationRequest) GetApplication() *Application

func (*UpdateApplicationRequest) ProtoMessage 

func (*UpdateApplicationRequest) ProtoMessage()

func (*UpdateApplicationRequest) Reset 

func (m *UpdateApplicationRequest) Reset()

func (*UpdateApplicationRequest) String 

func (m *UpdateApplicationRequest) String() string

func (*UpdateApplicationRequest) XXX_DiscardUnknown 

func (m *UpdateApplicationRequest) XXX_DiscardUnknown()

func (*UpdateApplicationRequest) XXX_Marshal 

func (m *UpdateApplicationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateApplicationRequest) XXX_Merge 

func (m *UpdateApplicationRequest) XXX_Merge(src proto.Message)

func (*UpdateApplicationRequest) XXX_Size 

func (m *UpdateApplicationRequest) XXX_Size() int

func (*UpdateApplicationRequest) XXX_Unmarshal 

func (m *UpdateApplicationRequest) XXX_Unmarshal(b []byte) error

type UpdateAzureServiceBusIntegrationRequest 

type UpdateAzureServiceBusIntegrationRequest struct {
	// Integration object to update.
	Integration          *AzureServiceBusIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (*UpdateAzureServiceBusIntegrationRequest) Descriptor 

func (*UpdateAzureServiceBusIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateAzureServiceBusIntegrationRequest) GetIntegration 

func (m *UpdateAzureServiceBusIntegrationRequest) GetIntegration() *AzureServiceBusIntegration

func (*UpdateAzureServiceBusIntegrationRequest) ProtoMessage 

func (*UpdateAzureServiceBusIntegrationRequest) ProtoMessage()

func (*UpdateAzureServiceBusIntegrationRequest) Reset 

func (m *UpdateAzureServiceBusIntegrationRequest) Reset()

func (*UpdateAzureServiceBusIntegrationRequest) String 

func (m *UpdateAzureServiceBusIntegrationRequest) String() string

func (*UpdateAzureServiceBusIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateAzureServiceBusIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateAzureServiceBusIntegrationRequest) XXX_Marshal 

func (m *UpdateAzureServiceBusIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateAzureServiceBusIntegrationRequest) XXX_Merge 

func (m *UpdateAzureServiceBusIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateAzureServiceBusIntegrationRequest) XXX_Size 

func (m *UpdateAzureServiceBusIntegrationRequest) XXX_Size() int

func (*UpdateAzureServiceBusIntegrationRequest) XXX_Unmarshal 

func (m *UpdateAzureServiceBusIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateDeviceKeysRequest 

type UpdateDeviceKeysRequest struct {
	// Device-keys object to update.
	DeviceKeys           *DeviceKeys `protobuf:"bytes,1,opt,name=device_keys,json=deviceKeys,proto3" json:"device_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*UpdateDeviceKeysRequest) Descriptor 

func (*UpdateDeviceKeysRequest) Descriptor() ([]byte, []int)

func (*UpdateDeviceKeysRequest) GetDeviceKeys 

func (m *UpdateDeviceKeysRequest) GetDeviceKeys() *DeviceKeys

func (*UpdateDeviceKeysRequest) ProtoMessage 

func (*UpdateDeviceKeysRequest) ProtoMessage()

func (*UpdateDeviceKeysRequest) Reset 

func (m *UpdateDeviceKeysRequest) Reset()

func (*UpdateDeviceKeysRequest) String 

func (m *UpdateDeviceKeysRequest) String() string

func (*UpdateDeviceKeysRequest) XXX_DiscardUnknown 

func (m *UpdateDeviceKeysRequest) XXX_DiscardUnknown()

func (*UpdateDeviceKeysRequest) XXX_Marshal 

func (m *UpdateDeviceKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateDeviceKeysRequest) XXX_Merge 

func (m *UpdateDeviceKeysRequest) XXX_Merge(src proto.Message)

func (*UpdateDeviceKeysRequest) XXX_Size 

func (m *UpdateDeviceKeysRequest) XXX_Size() int

func (*UpdateDeviceKeysRequest) XXX_Unmarshal 

func (m *UpdateDeviceKeysRequest) XXX_Unmarshal(b []byte) error

type UpdateDeviceProfileRequest 

type UpdateDeviceProfileRequest struct {
	// Device-profile object to update.
	DeviceProfile        *DeviceProfile `protobuf:"bytes,1,opt,name=device_profile,json=deviceProfile,proto3" json:"device_profile,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*UpdateDeviceProfileRequest) Descriptor 

func (*UpdateDeviceProfileRequest) Descriptor() ([]byte, []int)

func (*UpdateDeviceProfileRequest) GetDeviceProfile 

func (m *UpdateDeviceProfileRequest) GetDeviceProfile() *DeviceProfile

func (*UpdateDeviceProfileRequest) ProtoMessage 

func (*UpdateDeviceProfileRequest) ProtoMessage()

func (*UpdateDeviceProfileRequest) Reset 

func (m *UpdateDeviceProfileRequest) Reset()

func (*UpdateDeviceProfileRequest) String 

func (m *UpdateDeviceProfileRequest) String() string

func (*UpdateDeviceProfileRequest) XXX_DiscardUnknown 

func (m *UpdateDeviceProfileRequest) XXX_DiscardUnknown()

func (*UpdateDeviceProfileRequest) XXX_Marshal 

func (m *UpdateDeviceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateDeviceProfileRequest) XXX_Merge 

func (m *UpdateDeviceProfileRequest) XXX_Merge(src proto.Message)

func (*UpdateDeviceProfileRequest) XXX_Size 

func (m *UpdateDeviceProfileRequest) XXX_Size() int

func (*UpdateDeviceProfileRequest) XXX_Unmarshal 

func (m *UpdateDeviceProfileRequest) XXX_Unmarshal(b []byte) error

type UpdateDeviceRequest 

type UpdateDeviceRequest struct {
	// Device object to update.
	Device               *Device  `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*UpdateDeviceRequest) Descriptor 

func (*UpdateDeviceRequest) Descriptor() ([]byte, []int)

func (*UpdateDeviceRequest) GetDevice 

func (m *UpdateDeviceRequest) GetDevice() *Device

func (*UpdateDeviceRequest) ProtoMessage 

func (*UpdateDeviceRequest) ProtoMessage()

func (*UpdateDeviceRequest) Reset 

func (m *UpdateDeviceRequest) Reset()

func (*UpdateDeviceRequest) String 

func (m *UpdateDeviceRequest) String() string

func (*UpdateDeviceRequest) XXX_DiscardUnknown 

func (m *UpdateDeviceRequest) XXX_DiscardUnknown()

func (*UpdateDeviceRequest) XXX_Marshal 

func (m *UpdateDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateDeviceRequest) XXX_Merge 

func (m *UpdateDeviceRequest) XXX_Merge(src proto.Message)

func (*UpdateDeviceRequest) XXX_Size 

func (m *UpdateDeviceRequest) XXX_Size() int

func (*UpdateDeviceRequest) XXX_Unmarshal 

func (m *UpdateDeviceRequest) XXX_Unmarshal(b []byte) error

type UpdateGCPPubSubIntegrationRequest 

type UpdateGCPPubSubIntegrationRequest struct {
	// Integration object to update.
	Integration          *GCPPubSubIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*UpdateGCPPubSubIntegrationRequest) Descriptor 

func (*UpdateGCPPubSubIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateGCPPubSubIntegrationRequest) GetIntegration 

func (m *UpdateGCPPubSubIntegrationRequest) GetIntegration() *GCPPubSubIntegration

func (*UpdateGCPPubSubIntegrationRequest) ProtoMessage 

func (*UpdateGCPPubSubIntegrationRequest) ProtoMessage()

func (*UpdateGCPPubSubIntegrationRequest) Reset 

func (m *UpdateGCPPubSubIntegrationRequest) Reset()

func (*UpdateGCPPubSubIntegrationRequest) String 

func (m *UpdateGCPPubSubIntegrationRequest) String() string

func (*UpdateGCPPubSubIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateGCPPubSubIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateGCPPubSubIntegrationRequest) XXX_Marshal 

func (m *UpdateGCPPubSubIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateGCPPubSubIntegrationRequest) XXX_Merge 

func (m *UpdateGCPPubSubIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateGCPPubSubIntegrationRequest) XXX_Size 

func (m *UpdateGCPPubSubIntegrationRequest) XXX_Size() int

func (*UpdateGCPPubSubIntegrationRequest) XXX_Unmarshal 

func (m *UpdateGCPPubSubIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateGatewayProfileRequest 

type UpdateGatewayProfileRequest struct {
	// Gateway-profile object to update.
	GatewayProfile       *GatewayProfile `protobuf:"bytes,1,opt,name=gateway_profile,json=gatewayProfile,proto3" json:"gateway_profile,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*UpdateGatewayProfileRequest) Descriptor 

func (*UpdateGatewayProfileRequest) Descriptor() ([]byte, []int)

func (*UpdateGatewayProfileRequest) GetGatewayProfile 

func (m *UpdateGatewayProfileRequest) GetGatewayProfile() *GatewayProfile

func (*UpdateGatewayProfileRequest) ProtoMessage 

func (*UpdateGatewayProfileRequest) ProtoMessage()

func (*UpdateGatewayProfileRequest) Reset 

func (m *UpdateGatewayProfileRequest) Reset()

func (*UpdateGatewayProfileRequest) String 

func (m *UpdateGatewayProfileRequest) String() string

func (*UpdateGatewayProfileRequest) XXX_DiscardUnknown 

func (m *UpdateGatewayProfileRequest) XXX_DiscardUnknown()

func (*UpdateGatewayProfileRequest) XXX_Marshal 

func (m *UpdateGatewayProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateGatewayProfileRequest) XXX_Merge 

func (m *UpdateGatewayProfileRequest) XXX_Merge(src proto.Message)

func (*UpdateGatewayProfileRequest) XXX_Size 

func (m *UpdateGatewayProfileRequest) XXX_Size() int

func (*UpdateGatewayProfileRequest) XXX_Unmarshal 

func (m *UpdateGatewayProfileRequest) XXX_Unmarshal(b []byte) error

type UpdateGatewayRequest 

type UpdateGatewayRequest struct {
	// Gateway object to update.
	Gateway              *Gateway `protobuf:"bytes,1,opt,name=gateway,proto3" json:"gateway,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*UpdateGatewayRequest) Descriptor 

func (*UpdateGatewayRequest) Descriptor() ([]byte, []int)

func (*UpdateGatewayRequest) GetGateway 

func (m *UpdateGatewayRequest) GetGateway() *Gateway

func (*UpdateGatewayRequest) ProtoMessage 

func (*UpdateGatewayRequest) ProtoMessage()

func (*UpdateGatewayRequest) Reset 

func (m *UpdateGatewayRequest) Reset()

func (*UpdateGatewayRequest) String 

func (m *UpdateGatewayRequest) String() string

func (*UpdateGatewayRequest) XXX_DiscardUnknown 

func (m *UpdateGatewayRequest) XXX_DiscardUnknown()

func (*UpdateGatewayRequest) XXX_Marshal 

func (m *UpdateGatewayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateGatewayRequest) XXX_Merge 

func (m *UpdateGatewayRequest) XXX_Merge(src proto.Message)

func (*UpdateGatewayRequest) XXX_Size 

func (m *UpdateGatewayRequest) XXX_Size() int

func (*UpdateGatewayRequest) XXX_Unmarshal 

func (m *UpdateGatewayRequest) XXX_Unmarshal(b []byte) error

type UpdateHTTPIntegrationRequest 

type UpdateHTTPIntegrationRequest struct {
	// Integration object to update.
	Integration          *HTTPIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (*UpdateHTTPIntegrationRequest) Descriptor 

func (*UpdateHTTPIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateHTTPIntegrationRequest) GetIntegration 

func (m *UpdateHTTPIntegrationRequest) GetIntegration() *HTTPIntegration

func (*UpdateHTTPIntegrationRequest) ProtoMessage 

func (*UpdateHTTPIntegrationRequest) ProtoMessage()

func (*UpdateHTTPIntegrationRequest) Reset 

func (m *UpdateHTTPIntegrationRequest) Reset()

func (*UpdateHTTPIntegrationRequest) String 

func (m *UpdateHTTPIntegrationRequest) String() string

func (*UpdateHTTPIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateHTTPIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateHTTPIntegrationRequest) XXX_Marshal 

func (m *UpdateHTTPIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateHTTPIntegrationRequest) XXX_Merge 

func (m *UpdateHTTPIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateHTTPIntegrationRequest) XXX_Size 

func (m *UpdateHTTPIntegrationRequest) XXX_Size() int

func (*UpdateHTTPIntegrationRequest) XXX_Unmarshal 

func (m *UpdateHTTPIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateInfluxDBIntegrationRequest 

type UpdateInfluxDBIntegrationRequest struct {
	// Integration object.
	Integration          *InfluxDBIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (*UpdateInfluxDBIntegrationRequest) Descriptor 

func (*UpdateInfluxDBIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateInfluxDBIntegrationRequest) GetIntegration 

func (m *UpdateInfluxDBIntegrationRequest) GetIntegration() *InfluxDBIntegration

func (*UpdateInfluxDBIntegrationRequest) ProtoMessage 

func (*UpdateInfluxDBIntegrationRequest) ProtoMessage()

func (*UpdateInfluxDBIntegrationRequest) Reset 

func (m *UpdateInfluxDBIntegrationRequest) Reset()

func (*UpdateInfluxDBIntegrationRequest) String 

func (m *UpdateInfluxDBIntegrationRequest) String() string

func (*UpdateInfluxDBIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateInfluxDBIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateInfluxDBIntegrationRequest) XXX_Marshal 

func (m *UpdateInfluxDBIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateInfluxDBIntegrationRequest) XXX_Merge 

func (m *UpdateInfluxDBIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateInfluxDBIntegrationRequest) XXX_Size 

func (m *UpdateInfluxDBIntegrationRequest) XXX_Size() int

func (*UpdateInfluxDBIntegrationRequest) XXX_Unmarshal 

func (m *UpdateInfluxDBIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateLoRaCloudIntegrationRequest 

type UpdateLoRaCloudIntegrationRequest struct {
	// Integration object.
	Integration          *LoRaCloudIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*UpdateLoRaCloudIntegrationRequest) Descriptor 

func (*UpdateLoRaCloudIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateLoRaCloudIntegrationRequest) GetIntegration 

func (m *UpdateLoRaCloudIntegrationRequest) GetIntegration() *LoRaCloudIntegration

func (*UpdateLoRaCloudIntegrationRequest) ProtoMessage 

func (*UpdateLoRaCloudIntegrationRequest) ProtoMessage()

func (*UpdateLoRaCloudIntegrationRequest) Reset 

func (m *UpdateLoRaCloudIntegrationRequest) Reset()

func (*UpdateLoRaCloudIntegrationRequest) String 

func (m *UpdateLoRaCloudIntegrationRequest) String() string

func (*UpdateLoRaCloudIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateLoRaCloudIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateLoRaCloudIntegrationRequest) XXX_Marshal 

func (m *UpdateLoRaCloudIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateLoRaCloudIntegrationRequest) XXX_Merge 

func (m *UpdateLoRaCloudIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateLoRaCloudIntegrationRequest) XXX_Size 

func (m *UpdateLoRaCloudIntegrationRequest) XXX_Size() int

func (*UpdateLoRaCloudIntegrationRequest) XXX_Unmarshal 

func (m *UpdateLoRaCloudIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateMulticastGroupRequest 

type UpdateMulticastGroupRequest struct {
	// Multicast-group object to update.
	MulticastGroup       *MulticastGroup `protobuf:"bytes,1,opt,name=multicast_group,json=multicastGroup,proto3" json:"multicast_group,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*UpdateMulticastGroupRequest) Descriptor 

func (*UpdateMulticastGroupRequest) Descriptor() ([]byte, []int)

func (*UpdateMulticastGroupRequest) GetMulticastGroup 

func (m *UpdateMulticastGroupRequest) GetMulticastGroup() *MulticastGroup

func (*UpdateMulticastGroupRequest) ProtoMessage 

func (*UpdateMulticastGroupRequest) ProtoMessage()

func (*UpdateMulticastGroupRequest) Reset 

func (m *UpdateMulticastGroupRequest) Reset()

func (*UpdateMulticastGroupRequest) String 

func (m *UpdateMulticastGroupRequest) String() string

func (*UpdateMulticastGroupRequest) XXX_DiscardUnknown 

func (m *UpdateMulticastGroupRequest) XXX_DiscardUnknown()

func (*UpdateMulticastGroupRequest) XXX_Marshal 

func (m *UpdateMulticastGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateMulticastGroupRequest) XXX_Merge 

func (m *UpdateMulticastGroupRequest) XXX_Merge(src proto.Message)

func (*UpdateMulticastGroupRequest) XXX_Size 

func (m *UpdateMulticastGroupRequest) XXX_Size() int

func (*UpdateMulticastGroupRequest) XXX_Unmarshal 

func (m *UpdateMulticastGroupRequest) XXX_Unmarshal(b []byte) error

type UpdateMyDevicesIntegrationRequest 

type UpdateMyDevicesIntegrationRequest struct {
	// Integration object.
	Integration          *MyDevicesIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (*UpdateMyDevicesIntegrationRequest) Descriptor 

func (*UpdateMyDevicesIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateMyDevicesIntegrationRequest) GetIntegration 

func (m *UpdateMyDevicesIntegrationRequest) GetIntegration() *MyDevicesIntegration

func (*UpdateMyDevicesIntegrationRequest) ProtoMessage 

func (*UpdateMyDevicesIntegrationRequest) ProtoMessage()

func (*UpdateMyDevicesIntegrationRequest) Reset 

func (m *UpdateMyDevicesIntegrationRequest) Reset()

func (*UpdateMyDevicesIntegrationRequest) String 

func (m *UpdateMyDevicesIntegrationRequest) String() string

func (*UpdateMyDevicesIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateMyDevicesIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateMyDevicesIntegrationRequest) XXX_Marshal 

func (m *UpdateMyDevicesIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateMyDevicesIntegrationRequest) XXX_Merge 

func (m *UpdateMyDevicesIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateMyDevicesIntegrationRequest) XXX_Size 

func (m *UpdateMyDevicesIntegrationRequest) XXX_Size() int

func (*UpdateMyDevicesIntegrationRequest) XXX_Unmarshal 

func (m *UpdateMyDevicesIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateNetworkServerRequest 

type UpdateNetworkServerRequest struct {
	// Network-server object to update.
	NetworkServer        *NetworkServer `protobuf:"bytes,1,opt,name=network_server,json=networkServer,proto3" json:"network_server,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*UpdateNetworkServerRequest) Descriptor 

func (*UpdateNetworkServerRequest) Descriptor() ([]byte, []int)

func (*UpdateNetworkServerRequest) GetNetworkServer 

func (m *UpdateNetworkServerRequest) GetNetworkServer() *NetworkServer

func (*UpdateNetworkServerRequest) ProtoMessage 

func (*UpdateNetworkServerRequest) ProtoMessage()

func (*UpdateNetworkServerRequest) Reset 

func (m *UpdateNetworkServerRequest) Reset()

func (*UpdateNetworkServerRequest) String 

func (m *UpdateNetworkServerRequest) String() string

func (*UpdateNetworkServerRequest) XXX_DiscardUnknown 

func (m *UpdateNetworkServerRequest) XXX_DiscardUnknown()

func (*UpdateNetworkServerRequest) XXX_Marshal 

func (m *UpdateNetworkServerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateNetworkServerRequest) XXX_Merge 

func (m *UpdateNetworkServerRequest) XXX_Merge(src proto.Message)

func (*UpdateNetworkServerRequest) XXX_Size 

func (m *UpdateNetworkServerRequest) XXX_Size() int

func (*UpdateNetworkServerRequest) XXX_Unmarshal 

func (m *UpdateNetworkServerRequest) XXX_Unmarshal(b []byte) error

type UpdateOrganizationRequest 

type UpdateOrganizationRequest struct {
	// Organization object to update.
	Organization         *Organization `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (*UpdateOrganizationRequest) Descriptor 

func (*UpdateOrganizationRequest) Descriptor() ([]byte, []int)

func (*UpdateOrganizationRequest) GetOrganization 

func (m *UpdateOrganizationRequest) GetOrganization() *Organization

func (*UpdateOrganizationRequest) ProtoMessage 

func (*UpdateOrganizationRequest) ProtoMessage()

func (*UpdateOrganizationRequest) Reset 

func (m *UpdateOrganizationRequest) Reset()

func (*UpdateOrganizationRequest) String 

func (m *UpdateOrganizationRequest) String() string

func (*UpdateOrganizationRequest) XXX_DiscardUnknown 

func (m *UpdateOrganizationRequest) XXX_DiscardUnknown()

func (*UpdateOrganizationRequest) XXX_Marshal 

func (m *UpdateOrganizationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateOrganizationRequest) XXX_Merge 

func (m *UpdateOrganizationRequest) XXX_Merge(src proto.Message)

func (*UpdateOrganizationRequest) XXX_Size 

func (m *UpdateOrganizationRequest) XXX_Size() int

func (*UpdateOrganizationRequest) XXX_Unmarshal 

func (m *UpdateOrganizationRequest) XXX_Unmarshal(b []byte) error

type UpdateOrganizationUserRequest 

type UpdateOrganizationUserRequest struct {
	// Organization-user object to update.
	OrganizationUser     *OrganizationUser `protobuf:"bytes,1,opt,name=organization_user,json=organizationUser,proto3" json:"organization_user,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*UpdateOrganizationUserRequest) Descriptor 

func (*UpdateOrganizationUserRequest) Descriptor() ([]byte, []int)

func (*UpdateOrganizationUserRequest) GetOrganizationUser 

func (m *UpdateOrganizationUserRequest) GetOrganizationUser() *OrganizationUser

func (*UpdateOrganizationUserRequest) ProtoMessage 

func (*UpdateOrganizationUserRequest) ProtoMessage()

func (*UpdateOrganizationUserRequest) Reset 

func (m *UpdateOrganizationUserRequest) Reset()

func (*UpdateOrganizationUserRequest) String 

func (m *UpdateOrganizationUserRequest) String() string

func (*UpdateOrganizationUserRequest) XXX_DiscardUnknown 

func (m *UpdateOrganizationUserRequest) XXX_DiscardUnknown()

func (*UpdateOrganizationUserRequest) XXX_Marshal 

func (m *UpdateOrganizationUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateOrganizationUserRequest) XXX_Merge 

func (m *UpdateOrganizationUserRequest) XXX_Merge(src proto.Message)

func (*UpdateOrganizationUserRequest) XXX_Size 

func (m *UpdateOrganizationUserRequest) XXX_Size() int

func (*UpdateOrganizationUserRequest) XXX_Unmarshal 

func (m *UpdateOrganizationUserRequest) XXX_Unmarshal(b []byte) error

type UpdatePilotThingsIntegrationRequest 

type UpdatePilotThingsIntegrationRequest struct {
	// Integration object to update.
	Integration          *PilotThingsIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*UpdatePilotThingsIntegrationRequest) Descriptor 

func (*UpdatePilotThingsIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdatePilotThingsIntegrationRequest) GetIntegration 

func (m *UpdatePilotThingsIntegrationRequest) GetIntegration() *PilotThingsIntegration

func (*UpdatePilotThingsIntegrationRequest) ProtoMessage 

func (*UpdatePilotThingsIntegrationRequest) ProtoMessage()

func (*UpdatePilotThingsIntegrationRequest) Reset 

func (m *UpdatePilotThingsIntegrationRequest) Reset()

func (*UpdatePilotThingsIntegrationRequest) String 

func (m *UpdatePilotThingsIntegrationRequest) String() string

func (*UpdatePilotThingsIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdatePilotThingsIntegrationRequest) XXX_DiscardUnknown()

func (*UpdatePilotThingsIntegrationRequest) XXX_Marshal 

func (m *UpdatePilotThingsIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdatePilotThingsIntegrationRequest) XXX_Merge 

func (m *UpdatePilotThingsIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdatePilotThingsIntegrationRequest) XXX_Size 

func (m *UpdatePilotThingsIntegrationRequest) XXX_Size() int

func (*UpdatePilotThingsIntegrationRequest) XXX_Unmarshal 

func (m *UpdatePilotThingsIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateServiceProfileRequest 

type UpdateServiceProfileRequest struct {
	// Service-profile object to update.
	ServiceProfile       *ServiceProfile `protobuf:"bytes,1,opt,name=service_profile,json=serviceProfile,proto3" json:"service_profile,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*UpdateServiceProfileRequest) Descriptor 

func (*UpdateServiceProfileRequest) Descriptor() ([]byte, []int)

func (*UpdateServiceProfileRequest) GetServiceProfile 

func (m *UpdateServiceProfileRequest) GetServiceProfile() *ServiceProfile

func (*UpdateServiceProfileRequest) ProtoMessage 

func (*UpdateServiceProfileRequest) ProtoMessage()

func (*UpdateServiceProfileRequest) Reset 

func (m *UpdateServiceProfileRequest) Reset()

func (*UpdateServiceProfileRequest) String 

func (m *UpdateServiceProfileRequest) String() string

func (*UpdateServiceProfileRequest) XXX_DiscardUnknown 

func (m *UpdateServiceProfileRequest) XXX_DiscardUnknown()

func (*UpdateServiceProfileRequest) XXX_Marshal 

func (m *UpdateServiceProfileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateServiceProfileRequest) XXX_Merge 

func (m *UpdateServiceProfileRequest) XXX_Merge(src proto.Message)

func (*UpdateServiceProfileRequest) XXX_Size 

func (m *UpdateServiceProfileRequest) XXX_Size() int

func (*UpdateServiceProfileRequest) XXX_Unmarshal 

func (m *UpdateServiceProfileRequest) XXX_Unmarshal(b []byte) error

type UpdateThingsBoardIntegrationRequest 

type UpdateThingsBoardIntegrationRequest struct {
	// Integration object.
	Integration          *ThingsBoardIntegration `protobuf:"bytes,1,opt,name=integration,proto3" json:"integration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*UpdateThingsBoardIntegrationRequest) Descriptor 

func (*UpdateThingsBoardIntegrationRequest) Descriptor() ([]byte, []int)

func (*UpdateThingsBoardIntegrationRequest) GetIntegration 

func (m *UpdateThingsBoardIntegrationRequest) GetIntegration() *ThingsBoardIntegration

func (*UpdateThingsBoardIntegrationRequest) ProtoMessage 

func (*UpdateThingsBoardIntegrationRequest) ProtoMessage()

func (*UpdateThingsBoardIntegrationRequest) Reset 

func (m *UpdateThingsBoardIntegrationRequest) Reset()

func (*UpdateThingsBoardIntegrationRequest) String 

func (m *UpdateThingsBoardIntegrationRequest) String() string

func (*UpdateThingsBoardIntegrationRequest) XXX_DiscardUnknown 

func (m *UpdateThingsBoardIntegrationRequest) XXX_DiscardUnknown()

func (*UpdateThingsBoardIntegrationRequest) XXX_Marshal 

func (m *UpdateThingsBoardIntegrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateThingsBoardIntegrationRequest) XXX_Merge 

func (m *UpdateThingsBoardIntegrationRequest) XXX_Merge(src proto.Message)

func (*UpdateThingsBoardIntegrationRequest) XXX_Size 

func (m *UpdateThingsBoardIntegrationRequest) XXX_Size() int

func (*UpdateThingsBoardIntegrationRequest) XXX_Unmarshal 

func (m *UpdateThingsBoardIntegrationRequest) XXX_Unmarshal(b []byte) error

type UpdateUserPasswordRequest 

type UpdateUserPasswordRequest struct {
	// User ID.
	UserId int64  `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Old    string `protobuf:"bytes,3,opt,name=old,proto3" json:"old,omitempty"`
	// New pasword.
	Password             string   `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*UpdateUserPasswordRequest) Descriptor 

func (*UpdateUserPasswordRequest) Descriptor() ([]byte, []int)

func (*UpdateUserPasswordRequest) GetOld 

func (m *UpdateUserPasswordRequest) GetOld() string

func (*UpdateUserPasswordRequest) GetPassword 

func (m *UpdateUserPasswordRequest) GetPassword() string

func (*UpdateUserPasswordRequest) GetUserId 

func (m *UpdateUserPasswordRequest) GetUserId() int64

func (*UpdateUserPasswordRequest) ProtoMessage 

func (*UpdateUserPasswordRequest) ProtoMessage()

func (*UpdateUserPasswordRequest) Reset 

func (m *UpdateUserPasswordRequest) Reset()

func (*UpdateUserPasswordRequest) String 

func (m *UpdateUserPasswordRequest) String() string

func (*UpdateUserPasswordRequest) XXX_DiscardUnknown 

func (m *UpdateUserPasswordRequest) XXX_DiscardUnknown()

func (*UpdateUserPasswordRequest) XXX_Marshal 

func (m *UpdateUserPasswordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateUserPasswordRequest) XXX_Merge 

func (m *UpdateUserPasswordRequest) XXX_Merge(src proto.Message)

func (*UpdateUserPasswordRequest) XXX_Size 

func (m *UpdateUserPasswordRequest) XXX_Size() int

func (*UpdateUserPasswordRequest) XXX_Unmarshal 

func (m *UpdateUserPasswordRequest) XXX_Unmarshal(b []byte) error

type UpdateUserRequest 

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

func (*UpdateUserRequest) Descriptor 

func (*UpdateUserRequest) Descriptor() ([]byte, []int)

func (*UpdateUserRequest) GetUser 

func (m *UpdateUserRequest) GetUser() *User

func (*UpdateUserRequest) ProtoMessage 

func (*UpdateUserRequest) ProtoMessage()

func (*UpdateUserRequest) Reset 

func (m *UpdateUserRequest) Reset()

func (*UpdateUserRequest) String 

func (m *UpdateUserRequest) String() string

func (*UpdateUserRequest) XXX_DiscardUnknown 

func (m *UpdateUserRequest) XXX_DiscardUnknown()

func (*UpdateUserRequest) XXX_Marshal 

func (m *UpdateUserRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpdateUserRequest) XXX_Merge 

func (m *UpdateUserRequest) XXX_Merge(src proto.Message)

func (*UpdateUserRequest) XXX_Size 

func (m *UpdateUserRequest) XXX_Size() int

func (*UpdateUserRequest) XXX_Unmarshal 

func (m *UpdateUserRequest) XXX_Unmarshal(b []byte) error

type UpgradeRequest 

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 (*UpgradeRequest) Descriptor 

func (*UpgradeRequest) Descriptor() ([]byte, []int)

func (*UpgradeRequest) GetPath 

func (m *UpgradeRequest) GetPath() string

func (*UpgradeRequest) ProtoMessage 

func (*UpgradeRequest) ProtoMessage()

func (*UpgradeRequest) Reset 

func (m *UpgradeRequest) Reset()

func (*UpgradeRequest) String 

func (m *UpgradeRequest) String() string

func (*UpgradeRequest) XXX_DiscardUnknown 

func (m *UpgradeRequest) XXX_DiscardUnknown()

func (*UpgradeRequest) XXX_Marshal 

func (m *UpgradeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UpgradeRequest) XXX_Merge 

func (m *UpgradeRequest) XXX_Merge(src proto.Message)

func (*UpgradeRequest) XXX_Size 

func (m *UpgradeRequest) XXX_Size() int

func (*UpgradeRequest) XXX_Unmarshal 

func (m *UpgradeRequest) XXX_Unmarshal(b []byte) error

type UplinkFrameLog 

type UplinkFrameLog struct {
	GatewayEUI string `protobuf:"bytes,10,opt,name=gatewayEUI,proto3" json:"gatewayEUI,omitempty"`
	DevEUI     string `protobuf:"bytes,11,opt,name=devEUI,proto3" json:"devEUI,omitempty"`
	JoinEUI    string `protobuf:"bytes,12,opt,name=joinEUI,proto3" json:"joinEUI,omitempty"`
	DevAddr    string `protobuf:"bytes,13,opt,name=devAddr,proto3" json:"devAddr,omitempty"`
	Name       string `protobuf:"bytes,14,opt,name=name,proto3" json:"name,omitempty"`
	// TX information of the uplink.
	TxInfo *gw.UplinkTXInfo `protobuf:"bytes,1,opt,name=tx_info,json=txInfo,proto3" json:"tx_info,omitempty"`
	// RX information of the uplink.
	RxInfo []*gw.UplinkRXInfo `protobuf:"bytes,2,rep,name=rx_info,json=rxInfo,proto3" json:"rx_info,omitempty"`
	// LoRaWAN PHYPayload.
	PhyPayloadJson       string   `protobuf:"bytes,3,opt,name=phy_payload_json,json=phyPayloadJSON,proto3" json:"phy_payload_json,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*UplinkFrameLog) Descriptor 

func (*UplinkFrameLog) Descriptor() ([]byte, []int)

func (*UplinkFrameLog) GetDevAddr 

func (m *UplinkFrameLog) GetDevAddr() string

func (*UplinkFrameLog) GetDevEUI 

func (m *UplinkFrameLog) GetDevEUI() string

func (*UplinkFrameLog) GetGatewayEUI 

func (m *UplinkFrameLog) GetGatewayEUI() string

func (*UplinkFrameLog) GetJoinEUI 

func (m *UplinkFrameLog) GetJoinEUI() string

func (*UplinkFrameLog) GetName 

func (m *UplinkFrameLog) GetName() string

func (*UplinkFrameLog) GetPhyPayloadJson 

func (m *UplinkFrameLog) GetPhyPayloadJson() string

func (*UplinkFrameLog) GetRxInfo 

func (m *UplinkFrameLog) GetRxInfo() []*gw.UplinkRXInfo

func (*UplinkFrameLog) GetTxInfo 

func (m *UplinkFrameLog) GetTxInfo() *gw.UplinkTXInfo

func (*UplinkFrameLog) ProtoMessage 

func (*UplinkFrameLog) ProtoMessage()

func (*UplinkFrameLog) Reset 

func (m *UplinkFrameLog) Reset()

func (*UplinkFrameLog) String 

func (m *UplinkFrameLog) String() string

func (*UplinkFrameLog) XXX_DiscardUnknown 

func (m *UplinkFrameLog) XXX_DiscardUnknown()

func (*UplinkFrameLog) XXX_Marshal 

func (m *UplinkFrameLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UplinkFrameLog) XXX_Merge 

func (m *UplinkFrameLog) XXX_Merge(src proto.Message)

func (*UplinkFrameLog) XXX_Size 

func (m *UplinkFrameLog) XXX_Size() int

func (*UplinkFrameLog) XXX_Unmarshal 

func (m *UplinkFrameLog) XXX_Unmarshal(b []byte) error

type UplinkFrameLogForDevice 

type UplinkFrameLogForDevice struct {
	// TX information of the uplink.
	TxInfo *gw.UplinkTXInfo `protobuf:"bytes,1,opt,name=tx_info,json=txInfo,proto3" json:"tx_info,omitempty"`
	// RX information of the uplink.
	RxInfo []*gw.UplinkRXInfo `protobuf:"bytes,2,rep,name=rx_info,json=rxInfo,proto3" json:"rx_info,omitempty"`
	// LoRaWAN PHYPayload.
	PhyPayloadJson       string   `protobuf:"bytes,3,opt,name=phy_payload_json,json=phyPayloadJSON,proto3" json:"phy_payload_json,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*UplinkFrameLogForDevice) Descriptor 

func (*UplinkFrameLogForDevice) Descriptor() ([]byte, []int)

func (*UplinkFrameLogForDevice) GetPhyPayloadJson 

func (m *UplinkFrameLogForDevice) GetPhyPayloadJson() string

func (*UplinkFrameLogForDevice) GetRxInfo 

func (m *UplinkFrameLogForDevice) GetRxInfo() []*gw.UplinkRXInfo

func (*UplinkFrameLogForDevice) GetTxInfo 

func (m *UplinkFrameLogForDevice) GetTxInfo() *gw.UplinkTXInfo

func (*UplinkFrameLogForDevice) ProtoMessage 

func (*UplinkFrameLogForDevice) ProtoMessage()

func (*UplinkFrameLogForDevice) Reset 

func (m *UplinkFrameLogForDevice) Reset()

func (*UplinkFrameLogForDevice) String 

func (m *UplinkFrameLogForDevice) String() string

func (*UplinkFrameLogForDevice) XXX_DiscardUnknown 

func (m *UplinkFrameLogForDevice) XXX_DiscardUnknown()

func (*UplinkFrameLogForDevice) XXX_Marshal 

func (m *UplinkFrameLogForDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UplinkFrameLogForDevice) XXX_Merge 

func (m *UplinkFrameLogForDevice) XXX_Merge(src proto.Message)

func (*UplinkFrameLogForDevice) XXX_Size 

func (m *UplinkFrameLogForDevice) XXX_Size() int

func (*UplinkFrameLogForDevice) XXX_Unmarshal 

func (m *UplinkFrameLogForDevice) XXX_Unmarshal(b []byte) error

type UploadFWRequest 

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 (*UploadFWRequest) Descriptor 

func (*UploadFWRequest) Descriptor() ([]byte, []int)

func (*UploadFWRequest) GetFirmware 

func (m *UploadFWRequest) GetFirmware() *FileUpload

func (*UploadFWRequest) ProtoMessage 

func (*UploadFWRequest) ProtoMessage()

func (*UploadFWRequest) Reset 

func (m *UploadFWRequest) Reset()

func (*UploadFWRequest) String 

func (m *UploadFWRequest) String() string

func (*UploadFWRequest) XXX_DiscardUnknown 

func (m *UploadFWRequest) XXX_DiscardUnknown()

func (*UploadFWRequest) XXX_Marshal 

func (m *UploadFWRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UploadFWRequest) XXX_Merge 

func (m *UploadFWRequest) XXX_Merge(src proto.Message)

func (*UploadFWRequest) XXX_Size 

func (m *UploadFWRequest) XXX_Size() int

func (*UploadFWRequest) XXX_Unmarshal 

func (m *UploadFWRequest) XXX_Unmarshal(b []byte) error

type UploadFWResponse 

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 (*UploadFWResponse) Descriptor 

func (*UploadFWResponse) Descriptor() ([]byte, []int)

func (*UploadFWResponse) GetEmpty 

func (m *UploadFWResponse) GetEmpty() *emptypb.Empty

func (*UploadFWResponse) GetPath 

func (m *UploadFWResponse) GetPath() string

func (*UploadFWResponse) GetType 

func (m *UploadFWResponse) GetType() isUploadFWResponse_Type

func (*UploadFWResponse) ProtoMessage 

func (*UploadFWResponse) ProtoMessage()

func (*UploadFWResponse) Reset 

func (m *UploadFWResponse) Reset()

func (*UploadFWResponse) String 

func (m *UploadFWResponse) String() string

func (*UploadFWResponse) XXX_DiscardUnknown 

func (m *UploadFWResponse) XXX_DiscardUnknown()

func (*UploadFWResponse) XXX_Marshal 

func (m *UploadFWResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UploadFWResponse) XXX_Merge 

func (m *UploadFWResponse) XXX_Merge(src proto.Message)

func (*UploadFWResponse) XXX_OneofWrappers 

func (*UploadFWResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*UploadFWResponse) XXX_Size 

func (m *UploadFWResponse) XXX_Size() int

func (*UploadFWResponse) XXX_Unmarshal 

func (m *UploadFWResponse) XXX_Unmarshal(b []byte) error

type UploadFWResponse_Empty 

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

type UploadFWResponse_Path 

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

type UploadRequest 

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 (*UploadRequest) Descriptor 

func (*UploadRequest) Descriptor() ([]byte, []int)

func (*UploadRequest) GetSoftware 

func (m *UploadRequest) GetSoftware() *FileUpload

func (*UploadRequest) ProtoMessage 

func (*UploadRequest) ProtoMessage()

func (*UploadRequest) Reset 

func (m *UploadRequest) Reset()

func (*UploadRequest) String 

func (m *UploadRequest) String() string

func (*UploadRequest) XXX_DiscardUnknown 

func (m *UploadRequest) XXX_DiscardUnknown()

func (*UploadRequest) XXX_Marshal 

func (m *UploadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UploadRequest) XXX_Merge 

func (m *UploadRequest) XXX_Merge(src proto.Message)

func (*UploadRequest) XXX_Size 

func (m *UploadRequest) XXX_Size() int

func (*UploadRequest) XXX_Unmarshal 

func (m *UploadRequest) XXX_Unmarshal(b []byte) error

type UploadResponse 

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 (*UploadResponse) Descriptor 

func (*UploadResponse) Descriptor() ([]byte, []int)

func (*UploadResponse) GetEmpty 

func (m *UploadResponse) GetEmpty() *emptypb.Empty

func (*UploadResponse) GetPath 

func (m *UploadResponse) GetPath() string

func (*UploadResponse) GetType 

func (m *UploadResponse) GetType() isUploadResponse_Type

func (*UploadResponse) ProtoMessage 

func (*UploadResponse) ProtoMessage()

func (*UploadResponse) Reset 

func (m *UploadResponse) Reset()

func (*UploadResponse) String 

func (m *UploadResponse) String() string

func (*UploadResponse) XXX_DiscardUnknown 

func (m *UploadResponse) XXX_DiscardUnknown()

func (*UploadResponse) XXX_Marshal 

func (m *UploadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UploadResponse) XXX_Merge 

func (m *UploadResponse) XXX_Merge(src proto.Message)

func (*UploadResponse) XXX_OneofWrappers 

func (*UploadResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*UploadResponse) XXX_Size 

func (m *UploadResponse) XXX_Size() int

func (*UploadResponse) XXX_Unmarshal 

func (m *UploadResponse) XXX_Unmarshal(b []byte) error

type UploadResponse_Empty 

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

type UploadResponse_Path 

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

type UsageResponse 

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 (*UsageResponse) Descriptor 

func (*UsageResponse) Descriptor() ([]byte, []int)

func (*UsageResponse) GetCpuUsg 

func (m *UsageResponse) GetCpuUsg() float32

func (*UsageResponse) GetMemUsg 

func (m *UsageResponse) GetMemUsg() *MemoryUsage

func (*UsageResponse) ProtoMessage 

func (*UsageResponse) ProtoMessage()

func (*UsageResponse) Reset 

func (m *UsageResponse) Reset()

func (*UsageResponse) String 

func (m *UsageResponse) String() string

func (*UsageResponse) XXX_DiscardUnknown 

func (m *UsageResponse) XXX_DiscardUnknown()

func (*UsageResponse) XXX_Marshal 

func (m *UsageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UsageResponse) XXX_Merge 

func (m *UsageResponse) XXX_Merge(src proto.Message)

func (*UsageResponse) XXX_Size 

func (m *UsageResponse) XXX_Size() int

func (*UsageResponse) XXX_Unmarshal 

func (m *UsageResponse) XXX_Unmarshal(b []byte) error

type User 

type User struct {
	// User ID.
	// Will be set automatically on create.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// The session timeout, in minutes.
	SessionTtl int32 `protobuf:"varint,3,opt,name=session_ttl,json=sessionTTL,proto3" json:"session_ttl,omitempty"`
	// Set to true to make the user a global administrator.
	IsAdmin bool `protobuf:"varint,4,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// Set to false to disable the user.
	IsActive bool `protobuf:"varint,5,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"`
	// E-mail of the user.
	Email string `protobuf:"bytes,6,opt,name=email,proto3" json:"email,omitempty"`
	// Optional note to store with the user.
	Note                 string   `protobuf:"bytes,7,opt,name=note,proto3" json:"note,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*User) Descriptor 

func (*User) Descriptor() ([]byte, []int)

func (*User) GetEmail 

func (m *User) GetEmail() string

func (*User) GetId 

func (m *User) GetId() int64

func (*User) GetIsActive 

func (m *User) GetIsActive() bool

func (*User) GetIsAdmin 

func (m *User) GetIsAdmin() bool

func (*User) GetNote 

func (m *User) GetNote() string

func (*User) GetSessionTtl 

func (m *User) GetSessionTtl() int32

func (*User) ProtoMessage 

func (*User) ProtoMessage()

func (*User) Reset 

func (m *User) Reset()

func (*User) String 

func (m *User) String() string

func (*User) XXX_DiscardUnknown 

func (m *User) XXX_DiscardUnknown()

func (*User) XXX_Marshal 

func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*User) XXX_Merge 

func (m *User) XXX_Merge(src proto.Message)

func (*User) XXX_Size 

func (m *User) XXX_Size() int

func (*User) XXX_Unmarshal 

func (m *User) XXX_Unmarshal(b []byte) error

type UserListItem 

type UserListItem struct {
	// User ID.
	// Will be set automatically on create.
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Email of the user.
	Email string `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
	// The session timeout, in minutes.
	SessionTtl int32 `protobuf:"varint,3,opt,name=session_ttl,json=sessionTTL,proto3" json:"session_ttl,omitempty"`
	// Set to true to make the user a global administrator.
	IsAdmin bool `protobuf:"varint,4,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// Set to false to disable the user.
	IsActive bool `protobuf:"varint,5,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"`
	// Created at timestamp.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp.
	UpdatedAt            *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (*UserListItem) Descriptor 

func (*UserListItem) Descriptor() ([]byte, []int)

func (*UserListItem) GetCreatedAt 

func (m *UserListItem) GetCreatedAt() *timestamppb.Timestamp

func (*UserListItem) GetEmail 

func (m *UserListItem) GetEmail() string

func (*UserListItem) GetId 

func (m *UserListItem) GetId() int64

func (*UserListItem) GetIsActive 

func (m *UserListItem) GetIsActive() bool

func (*UserListItem) GetIsAdmin 

func (m *UserListItem) GetIsAdmin() bool

func (*UserListItem) GetSessionTtl 

func (m *UserListItem) GetSessionTtl() int32

func (*UserListItem) GetUpdatedAt 

func (m *UserListItem) GetUpdatedAt() *timestamppb.Timestamp

func (*UserListItem) ProtoMessage 

func (*UserListItem) ProtoMessage()

func (*UserListItem) Reset 

func (m *UserListItem) Reset()

func (*UserListItem) String 

func (m *UserListItem) String() string

func (*UserListItem) XXX_DiscardUnknown 

func (m *UserListItem) XXX_DiscardUnknown()

func (*UserListItem) XXX_Marshal 

func (m *UserListItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UserListItem) XXX_Merge 

func (m *UserListItem) XXX_Merge(src proto.Message)

func (*UserListItem) XXX_Size 

func (m *UserListItem) XXX_Size() int

func (*UserListItem) XXX_Unmarshal 

func (m *UserListItem) XXX_Unmarshal(b []byte) error

type UserOrganization 

type UserOrganization struct {
	// Organization ID.
	OrganizationId int64 `protobuf:"varint,1,opt,name=organization_id,json=organizationID,proto3" json:"organization_id,omitempty"`
	// User is admin within the context of the organization.
	// There is no need to set the is_device_admin and is_gateway_admin flags.
	IsAdmin bool `protobuf:"varint,2,opt,name=is_admin,json=isAdmin,proto3" json:"is_admin,omitempty"`
	// User is able to modify device related resources (applications,
	// device-profiles, devices, multicast-groups).
	IsDeviceAdmin bool `protobuf:"varint,3,opt,name=is_device_admin,json=isDeviceAdmin,proto3" json:"is_device_admin,omitempty"`
	// User is able to modify gateways.
	IsGatewayAdmin       bool     `protobuf:"varint,4,opt,name=is_gateway_admin,json=isGatewayAdmin,proto3" json:"is_gateway_admin,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*UserOrganization) Descriptor 

func (*UserOrganization) Descriptor() ([]byte, []int)

func (*UserOrganization) GetIsAdmin 

func (m *UserOrganization) GetIsAdmin() bool

func (*UserOrganization) GetIsDeviceAdmin 

func (m *UserOrganization) GetIsDeviceAdmin() bool

func (*UserOrganization) GetIsGatewayAdmin 

func (m *UserOrganization) GetIsGatewayAdmin() bool

func (*UserOrganization) GetOrganizationId 

func (m *UserOrganization) GetOrganizationId() int64

func (*UserOrganization) ProtoMessage 

func (*UserOrganization) ProtoMessage()

func (*UserOrganization) Reset 

func (m *UserOrganization) Reset()

func (*UserOrganization) String 

func (m *UserOrganization) String() string

func (*UserOrganization) XXX_DiscardUnknown 

func (m *UserOrganization) XXX_DiscardUnknown()

func (*UserOrganization) XXX_Marshal 

func (m *UserOrganization) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UserOrganization) XXX_Merge 

func (m *UserOrganization) XXX_Merge(src proto.Message)

func (*UserOrganization) XXX_Size 

func (m *UserOrganization) XXX_Size() int

func (*UserOrganization) XXX_Unmarshal 

func (m *UserOrganization) XXX_Unmarshal(b []byte) error

type UserServiceClient 

type UserServiceClient interface {
	// Get user list.
	List(ctx context.Context, in *ListUserRequest, opts ...grpc.CallOption) (*ListUserResponse, error)
	// Get data for a particular user.
	Get(ctx context.Context, in *GetUserRequest, opts ...grpc.CallOption) (*GetUserResponse, error)
	// Create a new user.
	Create(ctx context.Context, in *CreateUserRequest, opts ...grpc.CallOption) (*CreateUserResponse, error)
	// Update an existing user.
	Update(ctx context.Context, in *UpdateUserRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Delete a user.
	Delete(ctx context.Context, in *DeleteUserRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// UpdatePassword updates a password.
	UpdatePassword(ctx context.Context, in *UpdateUserPasswordRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

UserServiceClient is the client API for UserService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewUserServiceClient 

func NewUserServiceClient(cc grpc.ClientConnInterface) UserServiceClient

type UserServiceServer 

type UserServiceServer interface {
	// Get user list.
	List(context.Context, *ListUserRequest) (*ListUserResponse, error)
	// Get data for a particular user.
	Get(context.Context, *GetUserRequest) (*GetUserResponse, error)
	// Create a new user.
	Create(context.Context, *CreateUserRequest) (*CreateUserResponse, error)
	// Update an existing user.
	Update(context.Context, *UpdateUserRequest) (*emptypb.Empty, error)
	// Delete a user.
	Delete(context.Context, *DeleteUserRequest) (*emptypb.Empty, error)
	// UpdatePassword updates a password.
	UpdatePassword(context.Context, *UpdateUserPasswordRequest) (*emptypb.Empty, error)
}

UserServiceServer is the server API for UserService service.

type VPN_IPSec 

type VPN_IPSec struct {
	PeerAddress          string   `protobuf:"bytes,2,opt,name=peerAddress,proto3" json:"peerAddress,omitempty"`
	LocalSubnet          string   `protobuf:"bytes,3,opt,name=localSubnet,proto3" json:"localSubnet,omitempty"`
	RemoteSubnet         string   `protobuf:"bytes,4,opt,name=remoteSubnet,proto3" json:"remoteSubnet,omitempty"`
	Psk                  string   `protobuf:"bytes,5,opt,name=psk,proto3" json:"psk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*VPN_IPSec) Descriptor 

func (*VPN_IPSec) Descriptor() ([]byte, []int)

func (*VPN_IPSec) GetLocalSubnet 

func (m *VPN_IPSec) GetLocalSubnet() string

func (*VPN_IPSec) GetPeerAddress 

func (m *VPN_IPSec) GetPeerAddress() string

func (*VPN_IPSec) GetPsk 

func (m *VPN_IPSec) GetPsk() string

func (*VPN_IPSec) GetRemoteSubnet 

func (m *VPN_IPSec) GetRemoteSubnet() string

func (*VPN_IPSec) ProtoMessage 

func (*VPN_IPSec) ProtoMessage()

func (*VPN_IPSec) Reset 

func (m *VPN_IPSec) Reset()

func (*VPN_IPSec) String 

func (m *VPN_IPSec) String() string

func (*VPN_IPSec) XXX_DiscardUnknown 

func (m *VPN_IPSec) XXX_DiscardUnknown()

func (*VPN_IPSec) XXX_Marshal 

func (m *VPN_IPSec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*VPN_IPSec) XXX_Merge 

func (m *VPN_IPSec) XXX_Merge(src proto.Message)

func (*VPN_IPSec) XXX_Size 

func (m *VPN_IPSec) XXX_Size() int

func (*VPN_IPSec) XXX_Unmarshal 

func (m *VPN_IPSec) XXX_Unmarshal(b []byte) error

type VPN_L2TP 

type VPN_L2TP struct {
	Server               string   `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"`
	User                 string   `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	Passwd               string   `protobuf:"bytes,4,opt,name=passwd,proto3" json:"passwd,omitempty"`
	Psk                  string   `protobuf:"bytes,5,opt,name=psk,proto3" json:"psk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*VPN_L2TP) Descriptor 

func (*VPN_L2TP) Descriptor() ([]byte, []int)

func (*VPN_L2TP) GetPasswd 

func (m *VPN_L2TP) GetPasswd() string

func (*VPN_L2TP) GetPsk 

func (m *VPN_L2TP) GetPsk() string

func (*VPN_L2TP) GetServer 

func (m *VPN_L2TP) GetServer() string

func (*VPN_L2TP) GetUser 

func (m *VPN_L2TP) GetUser() string

func (*VPN_L2TP) ProtoMessage 

func (*VPN_L2TP) ProtoMessage()

func (*VPN_L2TP) Reset 

func (m *VPN_L2TP) Reset()

func (*VPN_L2TP) String 

func (m *VPN_L2TP) String() string

func (*VPN_L2TP) XXX_DiscardUnknown 

func (m *VPN_L2TP) XXX_DiscardUnknown()

func (*VPN_L2TP) XXX_Marshal 

func (m *VPN_L2TP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*VPN_L2TP) XXX_Merge 

func (m *VPN_L2TP) XXX_Merge(src proto.Message)

func (*VPN_L2TP) XXX_Size 

func (m *VPN_L2TP) XXX_Size() int

func (*VPN_L2TP) XXX_Unmarshal 

func (m *VPN_L2TP) XXX_Unmarshal(b []byte) error

type VPN_PPTP 

type VPN_PPTP struct {
	Server               string   `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"`
	User                 string   `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	Passwd               string   `protobuf:"bytes,4,opt,name=passwd,proto3" json:"passwd,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*VPN_PPTP) Descriptor 

func (*VPN_PPTP) Descriptor() ([]byte, []int)

func (*VPN_PPTP) GetPasswd 

func (m *VPN_PPTP) GetPasswd() string

func (*VPN_PPTP) GetServer 

func (m *VPN_PPTP) GetServer() string

func (*VPN_PPTP) GetUser 

func (m *VPN_PPTP) GetUser() string

func (*VPN_PPTP) ProtoMessage 

func (*VPN_PPTP) ProtoMessage()

func (*VPN_PPTP) Reset 

func (m *VPN_PPTP) Reset()

func (*VPN_PPTP) String 

func (m *VPN_PPTP) String() string

func (*VPN_PPTP) XXX_DiscardUnknown 

func (m *VPN_PPTP) XXX_DiscardUnknown()

func (*VPN_PPTP) XXX_Marshal 

func (m *VPN_PPTP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*VPN_PPTP) XXX_Merge 

func (m *VPN_PPTP) XXX_Merge(src proto.Message)

func (*VPN_PPTP) XXX_Size 

func (m *VPN_PPTP) XXX_Size() int

func (*VPN_PPTP) XXX_Unmarshal 

func (m *VPN_PPTP) XXX_Unmarshal(b []byte) error

type WhiteList 

type WhiteList struct {
	Enable  bool     `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	OuiList []string `protobuf:"bytes,2,rep,name=ouiList,proto3" json:"ouiList,omitempty"`
	// range 1~127
	JoinList             []*JoinEUIs `protobuf:"bytes,3,rep,name=joinList,proto3" json:"joinList,omitempty"`
	NetList              []string    `protobuf:"bytes,4,rep,name=netList,proto3" json:"netList,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*WhiteList) Descriptor 

func (*WhiteList) Descriptor() ([]byte, []int)

func (*WhiteList) GetEnable 

func (m *WhiteList) GetEnable() bool

func (*WhiteList) GetJoinList 

func (m *WhiteList) GetJoinList() []*JoinEUIs

func (*WhiteList) GetNetList 

func (m *WhiteList) GetNetList() []string

func (*WhiteList) GetOuiList 

func (m *WhiteList) GetOuiList() []string

func (*WhiteList) ProtoMessage 

func (*WhiteList) ProtoMessage()

func (*WhiteList) Reset 

func (m *WhiteList) Reset()

func (*WhiteList) String 

func (m *WhiteList) String() string

func (*WhiteList) XXX_DiscardUnknown 

func (m *WhiteList) XXX_DiscardUnknown()

func (*WhiteList) XXX_Marshal 

func (m *WhiteList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WhiteList) XXX_Merge 

func (m *WhiteList) XXX_Merge(src proto.Message)

func (*WhiteList) XXX_Size 

func (m *WhiteList) XXX_Size() int

func (*WhiteList) XXX_Unmarshal 

func (m *WhiteList) XXX_Unmarshal(b []byte) error

type WiFiAP 

type WiFiAP struct {
	Ssid                 string   `protobuf:"bytes,2,opt,name=ssid,proto3" json:"ssid,omitempty"`
	Passwd               string   `protobuf:"bytes,3,opt,name=passwd,proto3" json:"passwd,omitempty"`
	Ip                   string   `protobuf:"bytes,4,opt,name=ip,proto3" json:"ip,omitempty"`
	Netmask              string   `protobuf:"bytes,5,opt,name=netmask,proto3" json:"netmask,omitempty"`
	Gateway              string   `protobuf:"bytes,6,opt,name=gateway,proto3" json:"gateway,omitempty"`
	NumOfConns           int32    `protobuf:"varint,7,opt,name=numOfConns,proto3" json:"numOfConns,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*WiFiAP) Descriptor 

func (*WiFiAP) Descriptor() ([]byte, []int)

func (*WiFiAP) GetGateway 

func (m *WiFiAP) GetGateway() string

func (*WiFiAP) GetIp 

func (m *WiFiAP) GetIp() string

func (*WiFiAP) GetNetmask 

func (m *WiFiAP) GetNetmask() string

func (*WiFiAP) GetNumOfConns 

func (m *WiFiAP) GetNumOfConns() int32

func (*WiFiAP) GetPasswd 

func (m *WiFiAP) GetPasswd() string

func (*WiFiAP) GetSsid 

func (m *WiFiAP) GetSsid() string

func (*WiFiAP) ProtoMessage 

func (*WiFiAP) ProtoMessage()

func (*WiFiAP) Reset 

func (m *WiFiAP) Reset()

func (*WiFiAP) String 

func (m *WiFiAP) String() string

func (*WiFiAP) XXX_DiscardUnknown 

func (m *WiFiAP) XXX_DiscardUnknown()

func (*WiFiAP) XXX_Marshal 

func (m *WiFiAP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiAP) XXX_Merge 

func (m *WiFiAP) XXX_Merge(src proto.Message)

func (*WiFiAP) XXX_Size 

func (m *WiFiAP) XXX_Size() int

func (*WiFiAP) XXX_Unmarshal 

func (m *WiFiAP) XXX_Unmarshal(b []byte) error

type WiFiAPConfiguration 

type WiFiAPConfiguration struct {
	Ssid                 string   `protobuf:"bytes,1,opt,name=ssid,proto3" json:"ssid,omitempty"`
	Passwd               string   `protobuf:"bytes,2,opt,name=passwd,proto3" json:"passwd,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*WiFiAPConfiguration) Descriptor 

func (*WiFiAPConfiguration) Descriptor() ([]byte, []int)

func (*WiFiAPConfiguration) GetPasswd 

func (m *WiFiAPConfiguration) GetPasswd() string

func (*WiFiAPConfiguration) GetSsid 

func (m *WiFiAPConfiguration) GetSsid() string

func (*WiFiAPConfiguration) ProtoMessage 

func (*WiFiAPConfiguration) ProtoMessage()

func (*WiFiAPConfiguration) Reset 

func (m *WiFiAPConfiguration) Reset()

func (*WiFiAPConfiguration) String 

func (m *WiFiAPConfiguration) String() string

func (*WiFiAPConfiguration) XXX_DiscardUnknown 

func (m *WiFiAPConfiguration) XXX_DiscardUnknown()

func (*WiFiAPConfiguration) XXX_Marshal 

func (m *WiFiAPConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiAPConfiguration) XXX_Merge 

func (m *WiFiAPConfiguration) XXX_Merge(src proto.Message)

func (*WiFiAPConfiguration) XXX_Size 

func (m *WiFiAPConfiguration) XXX_Size() int

func (*WiFiAPConfiguration) XXX_Unmarshal 

func (m *WiFiAPConfiguration) XXX_Unmarshal(b []byte) error

type WiFiInfo 

type WiFiInfo struct {
	SSID                 string   `protobuf:"bytes,1,opt,name=SSID,proto3" json:"SSID,omitempty"`
	BSS                  string   `protobuf:"bytes,2,opt,name=BSS,proto3" json:"BSS,omitempty"`
	Encrypt              string   `protobuf:"bytes,3,opt,name=encrypt,proto3" json:"encrypt,omitempty"`
	Signal               float64  `protobuf:"fixed64,4,opt,name=signal,proto3" json:"signal,omitempty"`
	Connected            bool     `protobuf:"varint,5,opt,name=connected,proto3" json:"connected,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*WiFiInfo) Descriptor 

func (*WiFiInfo) Descriptor() ([]byte, []int)

func (*WiFiInfo) GetBSS 

func (m *WiFiInfo) GetBSS() string

func (*WiFiInfo) GetConnected 

func (m *WiFiInfo) GetConnected() bool

func (*WiFiInfo) GetEncrypt 

func (m *WiFiInfo) GetEncrypt() string

func (*WiFiInfo) GetSSID 

func (m *WiFiInfo) GetSSID() string

func (*WiFiInfo) GetSignal 

func (m *WiFiInfo) GetSignal() float64

func (*WiFiInfo) ProtoMessage 

func (*WiFiInfo) ProtoMessage()

func (*WiFiInfo) Reset 

func (m *WiFiInfo) Reset()

func (*WiFiInfo) String 

func (m *WiFiInfo) String() string

func (*WiFiInfo) XXX_DiscardUnknown 

func (m *WiFiInfo) XXX_DiscardUnknown()

func (*WiFiInfo) XXX_Marshal 

func (m *WiFiInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiInfo) XXX_Merge 

func (m *WiFiInfo) XXX_Merge(src proto.Message)

func (*WiFiInfo) XXX_Size 

func (m *WiFiInfo) XXX_Size() int

func (*WiFiInfo) XXX_Unmarshal 

func (m *WiFiInfo) XXX_Unmarshal(b []byte) error

type WiFiListResponse 

type WiFiListResponse struct {
	Total                int32       `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Result               []*WiFiInfo `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*WiFiListResponse) Descriptor 

func (*WiFiListResponse) Descriptor() ([]byte, []int)

func (*WiFiListResponse) GetResult 

func (m *WiFiListResponse) GetResult() []*WiFiInfo

func (*WiFiListResponse) GetTotal 

func (m *WiFiListResponse) GetTotal() int32

func (*WiFiListResponse) ProtoMessage 

func (*WiFiListResponse) ProtoMessage()

func (*WiFiListResponse) Reset 

func (m *WiFiListResponse) Reset()

func (*WiFiListResponse) String 

func (m *WiFiListResponse) String() string

func (*WiFiListResponse) XXX_DiscardUnknown 

func (m *WiFiListResponse) XXX_DiscardUnknown()

func (*WiFiListResponse) XXX_Marshal 

func (m *WiFiListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiListResponse) XXX_Merge 

func (m *WiFiListResponse) XXX_Merge(src proto.Message)

func (*WiFiListResponse) XXX_Size 

func (m *WiFiListResponse) XXX_Size() int

func (*WiFiListResponse) XXX_Unmarshal 

func (m *WiFiListResponse) XXX_Unmarshal(b []byte) error

type WiFiRequest 

type WiFiRequest struct {
	// Types that are valid to be assigned to Wifi:
	//
	//	*WiFiRequest_WifiAP
	//	*WiFiRequest_WifiSTA
	//	*WiFiRequest_Disable
	Wifi                 isWiFiRequest_Wifi `protobuf_oneof:"wifi"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*WiFiRequest) Descriptor 

func (*WiFiRequest) Descriptor() ([]byte, []int)

func (*WiFiRequest) GetDisable 

func (m *WiFiRequest) GetDisable() bool

func (*WiFiRequest) GetWifi 

func (m *WiFiRequest) GetWifi() isWiFiRequest_Wifi

func (*WiFiRequest) GetWifiAP 

func (m *WiFiRequest) GetWifiAP() *WiFiAP

func (*WiFiRequest) GetWifiSTA 

func (m *WiFiRequest) GetWifiSTA() *WiFiSTA

func (*WiFiRequest) ProtoMessage 

func (*WiFiRequest) ProtoMessage()

func (*WiFiRequest) Reset 

func (m *WiFiRequest) Reset()

func (*WiFiRequest) String 

func (m *WiFiRequest) String() string

func (*WiFiRequest) XXX_DiscardUnknown 

func (m *WiFiRequest) XXX_DiscardUnknown()

func (*WiFiRequest) XXX_Marshal 

func (m *WiFiRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiRequest) XXX_Merge 

func (m *WiFiRequest) XXX_Merge(src proto.Message)

func (*WiFiRequest) XXX_OneofWrappers 

func (*WiFiRequest) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*WiFiRequest) XXX_Size 

func (m *WiFiRequest) XXX_Size() int

func (*WiFiRequest) XXX_Unmarshal 

func (m *WiFiRequest) XXX_Unmarshal(b []byte) error

type WiFiRequest_Disable 

type WiFiRequest_Disable struct {
	Disable bool `protobuf:"varint,3,opt,name=disable,proto3,oneof"`
}

type WiFiRequest_WifiAP 

type WiFiRequest_WifiAP struct {
	WifiAP *WiFiAP `protobuf:"bytes,1,opt,name=wifiAP,proto3,oneof"`
}

type WiFiRequest_WifiSTA 

type WiFiRequest_WifiSTA struct {
	WifiSTA *WiFiSTA `protobuf:"bytes,2,opt,name=wifiSTA,proto3,oneof"`
}

type WiFiResponse 

type WiFiResponse struct {
	// Types that are valid to be assigned to Wifi:
	//
	//	*WiFiResponse_WifiAP
	//	*WiFiResponse_WifiSTA
	//	*WiFiResponse_Disable
	Wifi                 isWiFiResponse_Wifi `protobuf_oneof:"wifi"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (*WiFiResponse) Descriptor 

func (*WiFiResponse) Descriptor() ([]byte, []int)

func (*WiFiResponse) GetDisable 

func (m *WiFiResponse) GetDisable() bool

func (*WiFiResponse) GetWifi 

func (m *WiFiResponse) GetWifi() isWiFiResponse_Wifi

func (*WiFiResponse) GetWifiAP 

func (m *WiFiResponse) GetWifiAP() *WiFiAP

func (*WiFiResponse) GetWifiSTA 

func (m *WiFiResponse) GetWifiSTA() *WiFiSTA

func (*WiFiResponse) ProtoMessage 

func (*WiFiResponse) ProtoMessage()

func (*WiFiResponse) Reset 

func (m *WiFiResponse) Reset()

func (*WiFiResponse) String 

func (m *WiFiResponse) String() string

func (*WiFiResponse) XXX_DiscardUnknown 

func (m *WiFiResponse) XXX_DiscardUnknown()

func (*WiFiResponse) XXX_Marshal 

func (m *WiFiResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiResponse) XXX_Merge 

func (m *WiFiResponse) XXX_Merge(src proto.Message)

func (*WiFiResponse) XXX_OneofWrappers 

func (*WiFiResponse) XXX_OneofWrappers() []interface{}

XXX_OneofWrappers is for the internal use of the proto package.

func (*WiFiResponse) XXX_Size 

func (m *WiFiResponse) XXX_Size() int

func (*WiFiResponse) XXX_Unmarshal 

func (m *WiFiResponse) XXX_Unmarshal(b []byte) error

type WiFiResponse_Disable 

type WiFiResponse_Disable struct {
	Disable bool `protobuf:"varint,3,opt,name=disable,proto3,oneof"`
}

type WiFiResponse_WifiAP 

type WiFiResponse_WifiAP struct {
	WifiAP *WiFiAP `protobuf:"bytes,1,opt,name=wifiAP,proto3,oneof"`
}

type WiFiResponse_WifiSTA 

type WiFiResponse_WifiSTA struct {
	WifiSTA *WiFiSTA `protobuf:"bytes,2,opt,name=wifiSTA,proto3,oneof"`
}

type WiFiSTA 

type WiFiSTA struct {
	Ssid                 string   `protobuf:"bytes,2,opt,name=ssid,proto3" json:"ssid,omitempty"`
	Passwd               string   `protobuf:"bytes,3,opt,name=passwd,proto3" json:"passwd,omitempty"`
	Ip                   string   `protobuf:"bytes,4,opt,name=ip,proto3" json:"ip,omitempty"`
	Netmask              string   `protobuf:"bytes,5,opt,name=netmask,proto3" json:"netmask,omitempty"`
	Gateway              string   `protobuf:"bytes,6,opt,name=gateway,proto3" json:"gateway,omitempty"`
	Encrypt              string   `protobuf:"bytes,7,opt,name=encrypt,proto3" json:"encrypt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*WiFiSTA) Descriptor 

func (*WiFiSTA) Descriptor() ([]byte, []int)

func (*WiFiSTA) GetEncrypt 

func (m *WiFiSTA) GetEncrypt() string

func (*WiFiSTA) GetGateway 

func (m *WiFiSTA) GetGateway() string

func (*WiFiSTA) GetIp 

func (m *WiFiSTA) GetIp() string

func (*WiFiSTA) GetNetmask 

func (m *WiFiSTA) GetNetmask() string

func (*WiFiSTA) GetPasswd 

func (m *WiFiSTA) GetPasswd() string

func (*WiFiSTA) GetSsid 

func (m *WiFiSTA) GetSsid() string

func (*WiFiSTA) ProtoMessage 

func (*WiFiSTA) ProtoMessage()

func (*WiFiSTA) Reset 

func (m *WiFiSTA) Reset()

func (*WiFiSTA) String 

func (m *WiFiSTA) String() string

func (*WiFiSTA) XXX_DiscardUnknown 

func (m *WiFiSTA) XXX_DiscardUnknown()

func (*WiFiSTA) XXX_Marshal 

func (m *WiFiSTA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiSTA) XXX_Merge 

func (m *WiFiSTA) XXX_Merge(src proto.Message)

func (*WiFiSTA) XXX_Size 

func (m *WiFiSTA) XXX_Size() int

func (*WiFiSTA) XXX_Unmarshal 

func (m *WiFiSTA) XXX_Unmarshal(b []byte) error

type WiFiSTAConfiguration 

type WiFiSTAConfiguration struct {
	Ssid                 string   `protobuf:"bytes,1,opt,name=ssid,proto3" json:"ssid,omitempty"`
	Passwd               string   `protobuf:"bytes,2,opt,name=passwd,proto3" json:"passwd,omitempty"`
	Encrypt              string   `protobuf:"bytes,3,opt,name=encrypt,proto3" json:"encrypt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*WiFiSTAConfiguration) Descriptor 

func (*WiFiSTAConfiguration) Descriptor() ([]byte, []int)

func (*WiFiSTAConfiguration) GetEncrypt 

func (m *WiFiSTAConfiguration) GetEncrypt() string

func (*WiFiSTAConfiguration) GetPasswd 

func (m *WiFiSTAConfiguration) GetPasswd() string

func (*WiFiSTAConfiguration) GetSsid 

func (m *WiFiSTAConfiguration) GetSsid() string

func (*WiFiSTAConfiguration) ProtoMessage 

func (*WiFiSTAConfiguration) ProtoMessage()

func (*WiFiSTAConfiguration) Reset 

func (m *WiFiSTAConfiguration) Reset()

func (*WiFiSTAConfiguration) String 

func (m *WiFiSTAConfiguration) String() string

func (*WiFiSTAConfiguration) XXX_DiscardUnknown 

func (m *WiFiSTAConfiguration) XXX_DiscardUnknown()

func (*WiFiSTAConfiguration) XXX_Marshal 

func (m *WiFiSTAConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiSTAConfiguration) XXX_Merge 

func (m *WiFiSTAConfiguration) XXX_Merge(src proto.Message)

func (*WiFiSTAConfiguration) XXX_Size 

func (m *WiFiSTAConfiguration) XXX_Size() int

func (*WiFiSTAConfiguration) XXX_Unmarshal 

func (m *WiFiSTAConfiguration) XXX_Unmarshal(b []byte) error

type WiFiSTAConfigurationList 

type WiFiSTAConfigurationList struct {
	Item                 []*WiFiSTAConfiguration `protobuf:"bytes,1,rep,name=item,proto3" json:"item,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*WiFiSTAConfigurationList) Descriptor 

func (*WiFiSTAConfigurationList) Descriptor() ([]byte, []int)

func (*WiFiSTAConfigurationList) GetItem 

func (m *WiFiSTAConfigurationList) GetItem() []*WiFiSTAConfiguration

func (*WiFiSTAConfigurationList) ProtoMessage 

func (*WiFiSTAConfigurationList) ProtoMessage()

func (*WiFiSTAConfigurationList) Reset 

func (m *WiFiSTAConfigurationList) Reset()

func (*WiFiSTAConfigurationList) String 

func (m *WiFiSTAConfigurationList) String() string

func (*WiFiSTAConfigurationList) XXX_DiscardUnknown 

func (m *WiFiSTAConfigurationList) XXX_DiscardUnknown()

func (*WiFiSTAConfigurationList) XXX_Marshal 

func (m *WiFiSTAConfigurationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WiFiSTAConfigurationList) XXX_Merge 

func (m *WiFiSTAConfigurationList) XXX_Merge(src proto.Message)

func (*WiFiSTAConfigurationList) XXX_Size 

func (m *WiFiSTAConfigurationList) XXX_Size() int

func (*WiFiSTAConfigurationList) XXX_Unmarshal 

func (m *WiFiSTAConfigurationList) XXX_Unmarshal(b []byte) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.