api

package
v0.0.0-...-d91e8b8 Latest Latest
Warning

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

 Go to latest Published: Nov 14, 2024 License: MIT Imports: 21 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 APRequest 

type APRequest struct {
	// Types that are valid to be assigned to Ap:
	//
	//	*APRequest_WifiAP
	//	*APRequest_Disable
	Ap                   isAPRequest_Ap `protobuf_oneof:"ap"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (*APRequest) Descriptor 

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

func (*APRequest) GetAp 

func (m *APRequest) GetAp() isAPRequest_Ap

func (*APRequest) GetDisable 

func (m *APRequest) GetDisable() bool

func (*APRequest) GetWifiAP 

func (m *APRequest) GetWifiAP() *WiFiAP

func (*APRequest) ProtoMessage 

func (*APRequest) ProtoMessage()

func (*APRequest) Reset 

func (m *APRequest) Reset()

func (*APRequest) String 

func (m *APRequest) String() string

func (*APRequest) XXX_DiscardUnknown 

func (m *APRequest) XXX_DiscardUnknown()

func (*APRequest) XXX_Marshal 

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

func (*APRequest) XXX_Merge 

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

func (*APRequest) XXX_OneofWrappers 

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

XXX_OneofWrappers is for the internal use of the proto package.

func (*APRequest) XXX_Size 

func (m *APRequest) XXX_Size() int

func (*APRequest) XXX_Unmarshal 

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

type APRequest_Disable 

type APRequest_Disable struct {
	Disable bool `protobuf:"varint,2,opt,name=disable,proto3,oneof"`
}

type APRequest_WifiAP 

type APRequest_WifiAP struct {
	WifiAP *WiFiAP `protobuf:"bytes,1,opt,name=wifiAP,proto3,oneof"`
}

type APResponse 

type APResponse struct {
	// Types that are valid to be assigned to Ap:
	//
	//	*APResponse_WifiAP
	//	*APResponse_Disable
	Ap                   isAPResponse_Ap `protobuf_oneof:"ap"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (*APResponse) Descriptor 

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

func (*APResponse) GetAp 

func (m *APResponse) GetAp() isAPResponse_Ap

func (*APResponse) GetDisable 

func (m *APResponse) GetDisable() bool

func (*APResponse) GetWifiAP 

func (m *APResponse) GetWifiAP() *WiFiAP

func (*APResponse) ProtoMessage 

func (*APResponse) ProtoMessage()

func (*APResponse) Reset 

func (m *APResponse) Reset()

func (*APResponse) String 

func (m *APResponse) String() string

func (*APResponse) XXX_DiscardUnknown 

func (m *APResponse) XXX_DiscardUnknown()

func (*APResponse) XXX_Marshal 

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

func (*APResponse) XXX_Merge 

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

func (*APResponse) XXX_OneofWrappers 

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

XXX_OneofWrappers is for the internal use of the proto package.

func (*APResponse) XXX_Size 

func (m *APResponse) XXX_Size() int

func (*APResponse) XXX_Unmarshal 

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

type APResponse_Disable 

type APResponse_Disable struct {
	Disable bool `protobuf:"varint,2,opt,name=disable,proto3,oneof"`
}

type APResponse_WifiAP 

type APResponse_WifiAP struct {
	WifiAP *WiFiAP `protobuf:"bytes,1,opt,name=wifiAP,proto3,oneof"`
}

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"`
	DevNum               int64              `protobuf:"varint,12,opt,name=devNum,proto3" json:"devNum,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) GetDevNum 

func (m *ApplicationListItem) GetDevNum() int64

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 BandCountriesMap 

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

func (*BandCountriesMap) Descriptor 

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

func (*BandCountriesMap) GetArea 

func (m *BandCountriesMap) GetArea() string

func (*BandCountriesMap) GetBand 

func (m *BandCountriesMap) GetBand() string

func (*BandCountriesMap) GetCity 

func (m *BandCountriesMap) GetCity() string

func (*BandCountriesMap) GetCountry 

func (m *BandCountriesMap) GetCountry() string

func (*BandCountriesMap) GetTAdditional 

func (m *BandCountriesMap) GetTAdditional() string

func (*BandCountriesMap) GetTimezone 

func (m *BandCountriesMap) GetTimezone() string

func (*BandCountriesMap) ProtoMessage 

func (*BandCountriesMap) ProtoMessage()

func (*BandCountriesMap) Reset 

func (m *BandCountriesMap) Reset()

func (*BandCountriesMap) String 

func (m *BandCountriesMap) String() string

func (*BandCountriesMap) XXX_DiscardUnknown 

func (m *BandCountriesMap) XXX_DiscardUnknown()

func (*BandCountriesMap) XXX_Marshal 

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

func (*BandCountriesMap) XXX_Merge 

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

func (*BandCountriesMap) XXX_Size 

func (m *BandCountriesMap) XXX_Size() int

func (*BandCountriesMap) XXX_Unmarshal 

func (m *BandCountriesMap) 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 CodecListResponse 

type CodecListResponse struct {
	List                 []*DeviceCodecRules `protobuf:"bytes,1,rep,name=list,proto3" json:"list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (*CodecListResponse) Descriptor 

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

func (*CodecListResponse) GetList 

func (m *CodecListResponse) GetList() []*DeviceCodecRules

func (*CodecListResponse) ProtoMessage 

func (*CodecListResponse) ProtoMessage()

func (*CodecListResponse) Reset 

func (m *CodecListResponse) Reset()

func (*CodecListResponse) String 

func (m *CodecListResponse) String() string

func (*CodecListResponse) XXX_DiscardUnknown 

func (m *CodecListResponse) XXX_DiscardUnknown()

func (*CodecListResponse) XXX_Marshal 

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

func (*CodecListResponse) XXX_Merge 

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

func (*CodecListResponse) XXX_Size 

func (m *CodecListResponse) XXX_Size() int

func (*CodecListResponse) XXX_Unmarshal 

func (m *CodecListResponse) 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 CountriesResponse 

type CountriesResponse struct {
	Table                []*BandCountriesMap `protobuf:"bytes,1,rep,name=table,proto3" json:"table,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (*CountriesResponse) Descriptor 

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

func (*CountriesResponse) GetTable 

func (m *CountriesResponse) GetTable() []*BandCountriesMap

func (*CountriesResponse) ProtoMessage 

func (*CountriesResponse) ProtoMessage()

func (*CountriesResponse) Reset 

func (m *CountriesResponse) Reset()

func (*CountriesResponse) String 

func (m *CountriesResponse) String() string

func (*CountriesResponse) XXX_DiscardUnknown 

func (m *CountriesResponse) XXX_DiscardUnknown()

func (*CountriesResponse) XXX_Marshal 

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

func (*CountriesResponse) XXX_Merge 

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

func (*CountriesResponse) XXX_Size 

func (m *CountriesResponse) XXX_Size() int

func (*CountriesResponse) XXX_Unmarshal 

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

type CountriesResquest 

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

func (*CountriesResquest) Descriptor 

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

func (*CountriesResquest) GetConfig 

func (m *CountriesResquest) GetConfig() *BandCountriesMap

func (*CountriesResquest) ProtoMessage 

func (*CountriesResquest) ProtoMessage()

func (*CountriesResquest) Reset 

func (m *CountriesResquest) Reset()

func (*CountriesResquest) String 

func (m *CountriesResquest) String() string

func (*CountriesResquest) XXX_DiscardUnknown 

func (m *CountriesResquest) XXX_DiscardUnknown()

func (*CountriesResquest) XXX_Marshal 

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

func (*CountriesResquest) XXX_Merge 

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

func (*CountriesResquest) XXX_Size 

func (m *CountriesResquest) XXX_Size() int

func (*CountriesResquest) XXX_Unmarshal 

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

type CountriesTimezoneMap 

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

func (*CountriesTimezoneMap) Descriptor 

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

func (*CountriesTimezoneMap) GetName 

func (m *CountriesTimezoneMap) GetName() string

func (*CountriesTimezoneMap) GetTimezone 

func (m *CountriesTimezoneMap) GetTimezone() []string

func (*CountriesTimezoneMap) ProtoMessage 

func (*CountriesTimezoneMap) ProtoMessage()

func (*CountriesTimezoneMap) Reset 

func (m *CountriesTimezoneMap) Reset()

func (*CountriesTimezoneMap) String 

func (m *CountriesTimezoneMap) String() string

func (*CountriesTimezoneMap) XXX_DiscardUnknown 

func (m *CountriesTimezoneMap) XXX_DiscardUnknown()

func (*CountriesTimezoneMap) XXX_Marshal 

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

func (*CountriesTimezoneMap) XXX_Merge 

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

func (*CountriesTimezoneMap) XXX_Size 

func (m *CountriesTimezoneMap) XXX_Size() int

func (*CountriesTimezoneMap) XXX_Unmarshal 

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

type CountryResponse 

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

func (*CountryResponse) Descriptor 

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

func (*CountryResponse) GetConfig 

func (m *CountryResponse) GetConfig() *BandCountriesMap

func (*CountryResponse) ProtoMessage 

func (*CountryResponse) ProtoMessage()

func (*CountryResponse) Reset 

func (m *CountryResponse) Reset()

func (*CountryResponse) String 

func (m *CountryResponse) String() string

func (*CountryResponse) XXX_DiscardUnknown 

func (m *CountryResponse) XXX_DiscardUnknown()

func (*CountryResponse) XXX_Marshal 

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

func (*CountryResponse) XXX_Merge 

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

func (*CountryResponse) XXX_Size 

func (m *CountryResponse) XXX_Size() int

func (*CountryResponse) XXX_Unmarshal 

func (m *CountryResponse) 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 CreateCodecRequest 

type CreateCodecRequest struct {
	// Device-keys object to create.
	DeviceCodec          *DeviceCodecRules `protobuf:"bytes,1,opt,name=device_codec,json=deviceCodec,proto3" json:"device_codec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*CreateCodecRequest) Descriptor 

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

func (*CreateCodecRequest) GetDeviceCodec 

func (m *CreateCodecRequest) GetDeviceCodec() *DeviceCodecRules

func (*CreateCodecRequest) ProtoMessage 

func (*CreateCodecRequest) ProtoMessage()

func (*CreateCodecRequest) Reset 

func (m *CreateCodecRequest) Reset()

func (*CreateCodecRequest) String 

func (m *CreateCodecRequest) String() string

func (*CreateCodecRequest) XXX_DiscardUnknown 

func (m *CreateCodecRequest) XXX_DiscardUnknown()

func (*CreateCodecRequest) XXX_Marshal 

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

func (*CreateCodecRequest) XXX_Merge 

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

func (*CreateCodecRequest) XXX_Size 

func (m *CreateCodecRequest) XXX_Size() int

func (*CreateCodecRequest) XXX_Unmarshal 

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

type CreateCodecResponse 

type CreateCodecResponse struct {
	// Device-keys object to 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 (*CreateCodecResponse) Descriptor 

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

func (*CreateCodecResponse) GetId 

func (m *CreateCodecResponse) GetId() string

func (*CreateCodecResponse) ProtoMessage 

func (*CreateCodecResponse) ProtoMessage()

func (*CreateCodecResponse) Reset 

func (m *CreateCodecResponse) Reset()

func (*CreateCodecResponse) String 

func (m *CreateCodecResponse) String() string

func (*CreateCodecResponse) XXX_DiscardUnknown 

func (m *CreateCodecResponse) XXX_DiscardUnknown()

func (*CreateCodecResponse) XXX_Marshal 

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

func (*CreateCodecResponse) XXX_Merge 

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

func (*CreateCodecResponse) XXX_Size 

func (m *CreateCodecResponse) XXX_Size() int

func (*CreateCodecResponse) XXX_Unmarshal 

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

type CreateDeviceCodecRequest 

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

func (*CreateDeviceCodecRequest) Descriptor 

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

func (*CreateDeviceCodecRequest) GetDeviceCodec 

func (m *CreateDeviceCodecRequest) GetDeviceCodec() *DeviceCodec

func (*CreateDeviceCodecRequest) ProtoMessage 

func (*CreateDeviceCodecRequest) ProtoMessage()

func (*CreateDeviceCodecRequest) Reset 

func (m *CreateDeviceCodecRequest) Reset()

func (*CreateDeviceCodecRequest) String 

func (m *CreateDeviceCodecRequest) String() string

func (*CreateDeviceCodecRequest) XXX_DiscardUnknown 

func (m *CreateDeviceCodecRequest) XXX_DiscardUnknown()

func (*CreateDeviceCodecRequest) XXX_Marshal 

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

func (*CreateDeviceCodecRequest) XXX_Merge 

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

func (*CreateDeviceCodecRequest) XXX_Size 

func (m *CreateDeviceCodecRequest) XXX_Size() int

func (*CreateDeviceCodecRequest) XXX_Unmarshal 

func (m *CreateDeviceCodecRequest) 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 DefPasswordResponse 

type DefPasswordResponse struct {
	// Types that are valid to be assigned to Status:
	//
	//	*DefPasswordResponse_Password
	//	*DefPasswordResponse_Default
	Status               isDefPasswordResponse_Status `protobuf_oneof:"status"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (*DefPasswordResponse) Descriptor 

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

func (*DefPasswordResponse) GetDefault 

func (m *DefPasswordResponse) GetDefault() bool

func (*DefPasswordResponse) GetPassword 

func (m *DefPasswordResponse) GetPassword() string

func (*DefPasswordResponse) GetStatus 

func (m *DefPasswordResponse) GetStatus() isDefPasswordResponse_Status

func (*DefPasswordResponse) ProtoMessage 

func (*DefPasswordResponse) ProtoMessage()

func (*DefPasswordResponse) Reset 

func (m *DefPasswordResponse) Reset()

func (*DefPasswordResponse) String 

func (m *DefPasswordResponse) String() string

func (*DefPasswordResponse) XXX_DiscardUnknown 

func (m *DefPasswordResponse) XXX_DiscardUnknown()

func (*DefPasswordResponse) XXX_Marshal 

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

func (*DefPasswordResponse) XXX_Merge 

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

func (*DefPasswordResponse) XXX_OneofWrappers 

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

XXX_OneofWrappers is for the internal use of the proto package.

func (*DefPasswordResponse) XXX_Size 

func (m *DefPasswordResponse) XXX_Size() int

func (*DefPasswordResponse) XXX_Unmarshal 

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

type DefPasswordResponse_Default 

type DefPasswordResponse_Default struct {
	Default bool `protobuf:"varint,2,opt,name=default,proto3,oneof"`
}

type DefPasswordResponse_Password 

type DefPasswordResponse_Password struct {
	Password string `protobuf:"bytes,1,opt,name=password,proto3,oneof"`
}

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 DeleteCodecRequest 

type DeleteCodecRequest struct {
	// Device EUI (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 (*DeleteCodecRequest) Descriptor 

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

func (*DeleteCodecRequest) GetId 

func (m *DeleteCodecRequest) GetId() string

func (*DeleteCodecRequest) ProtoMessage 

func (*DeleteCodecRequest) ProtoMessage()

func (*DeleteCodecRequest) Reset 

func (m *DeleteCodecRequest) Reset()

func (*DeleteCodecRequest) String 

func (m *DeleteCodecRequest) String() string

func (*DeleteCodecRequest) XXX_DiscardUnknown 

func (m *DeleteCodecRequest) XXX_DiscardUnknown()

func (*DeleteCodecRequest) XXX_Marshal 

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

func (*DeleteCodecRequest) XXX_Merge 

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

func (*DeleteCodecRequest) XXX_Size 

func (m *DeleteCodecRequest) XXX_Size() int

func (*DeleteCodecRequest) XXX_Unmarshal 

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

type DeleteDeviceCodecRequest 

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

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

func (*DeleteDeviceCodecRequest) GetDevEui 

func (m *DeleteDeviceCodecRequest) GetDevEui() string

func (*DeleteDeviceCodecRequest) ProtoMessage 

func (*DeleteDeviceCodecRequest) ProtoMessage()

func (*DeleteDeviceCodecRequest) Reset 

func (m *DeleteDeviceCodecRequest) Reset()

func (*DeleteDeviceCodecRequest) String 

func (m *DeleteDeviceCodecRequest) String() string

func (*DeleteDeviceCodecRequest) XXX_DiscardUnknown 

func (m *DeleteDeviceCodecRequest) XXX_DiscardUnknown()

func (*DeleteDeviceCodecRequest) XXX_Marshal 

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

func (*DeleteDeviceCodecRequest) XXX_Merge 

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

func (*DeleteDeviceCodecRequest) XXX_Size 

func (m *DeleteDeviceCodecRequest) XXX_Size() int

func (*DeleteDeviceCodecRequest) XXX_Unmarshal 

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

type DeleteDeviceKeysRequest 

type DeleteDeviceKeysRequest 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:"-"`
}

Device EUI (HEX encoded).

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"`
	// google.protobuf.Int32Value id   = 12;
	// StringValue  id   = 12;
	Id                   *wrapperspb.StringValue `protobuf:"bytes,12,opt,name=id,proto3" json:"id,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) GetId 

func (m *Device) GetId() *wrapperspb.StringValue

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 DeviceCodec 

type DeviceCodec struct {
	// Device EUI (HEX encoded).
	DevEui string `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,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,2,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,3,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,4,opt,name=payload_decoder_script,json=payloadDecoderScript,proto3" json:"payload_decoder_script,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceCodec) Descriptor 

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

func (*DeviceCodec) GetDevEui 

func (m *DeviceCodec) GetDevEui() string

func (*DeviceCodec) GetPayloadCodec 

func (m *DeviceCodec) GetPayloadCodec() string

func (*DeviceCodec) GetPayloadDecoderScript 

func (m *DeviceCodec) GetPayloadDecoderScript() string

func (*DeviceCodec) GetPayloadEncoderScript 

func (m *DeviceCodec) GetPayloadEncoderScript() string

func (*DeviceCodec) ProtoMessage 

func (*DeviceCodec) ProtoMessage()

func (*DeviceCodec) Reset 

func (m *DeviceCodec) Reset()

func (*DeviceCodec) String 

func (m *DeviceCodec) String() string

func (*DeviceCodec) XXX_DiscardUnknown 

func (m *DeviceCodec) XXX_DiscardUnknown()

func (*DeviceCodec) XXX_Marshal 

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

func (*DeviceCodec) XXX_Merge 

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

func (*DeviceCodec) XXX_Size 

func (m *DeviceCodec) XXX_Size() int

func (*DeviceCodec) XXX_Unmarshal 

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

type DeviceCodecRules 

type DeviceCodecRules struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Customized           bool     `protobuf:"varint,3,opt,name=customized,proto3" json:"customized,omitempty"`
	PayloadCodec         string   `protobuf:"bytes,4,opt,name=payload_codec,json=payloadCodec,proto3" json:"payload_codec,omitempty"`
	PayloadEncoderScript string   `protobuf:"bytes,5,opt,name=payload_encoder_script,json=payloadEncoderScript,proto3" json:"payload_encoder_script,omitempty"`
	PayloadDecoderScript string   `protobuf:"bytes,6,opt,name=payload_decoder_script,json=payloadDecoderScript,proto3" json:"payload_decoder_script,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*DeviceCodecRules) Descriptor 

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

func (*DeviceCodecRules) GetCustomized 

func (m *DeviceCodecRules) GetCustomized() bool

func (*DeviceCodecRules) GetId 

func (m *DeviceCodecRules) GetId() string

func (*DeviceCodecRules) GetName 

func (m *DeviceCodecRules) GetName() string

func (*DeviceCodecRules) GetPayloadCodec 

func (m *DeviceCodecRules) GetPayloadCodec() string

func (*DeviceCodecRules) GetPayloadDecoderScript 

func (m *DeviceCodecRules) GetPayloadDecoderScript() string

func (*DeviceCodecRules) GetPayloadEncoderScript 

func (m *DeviceCodecRules) GetPayloadEncoderScript() string

func (*DeviceCodecRules) ProtoMessage 

func (*DeviceCodecRules) ProtoMessage()

func (*DeviceCodecRules) Reset 

func (m *DeviceCodecRules) Reset()

func (*DeviceCodecRules) String 

func (m *DeviceCodecRules) String() string

func (*DeviceCodecRules) XXX_DiscardUnknown 

func (m *DeviceCodecRules) XXX_DiscardUnknown()

func (*DeviceCodecRules) XXX_Marshal 

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

func (*DeviceCodecRules) XXX_Merge 

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

func (*DeviceCodecRules) XXX_Size 

func (m *DeviceCodecRules) XXX_Size() int

func (*DeviceCodecRules) XXX_Unmarshal 

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

type DeviceKeyValue 

type DeviceKeyValue struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	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 (*DeviceKeyValue) Descriptor 

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

func (*DeviceKeyValue) GetKey 

func (m *DeviceKeyValue) GetKey() string

func (*DeviceKeyValue) GetValue 

func (m *DeviceKeyValue) GetValue() string

func (*DeviceKeyValue) ProtoMessage 

func (*DeviceKeyValue) ProtoMessage()

func (*DeviceKeyValue) Reset 

func (m *DeviceKeyValue) Reset()

func (*DeviceKeyValue) String 

func (m *DeviceKeyValue) String() string

func (*DeviceKeyValue) XXX_DiscardUnknown 

func (m *DeviceKeyValue) XXX_DiscardUnknown()

func (*DeviceKeyValue) XXX_Marshal 

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

func (*DeviceKeyValue) XXX_Merge 

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

func (*DeviceKeyValue) XXX_Size 

func (m *DeviceKeyValue) XXX_Size() int

func (*DeviceKeyValue) XXX_Unmarshal 

func (m *DeviceKeyValue) 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"`
	// google.protobuf.Int32Value id   = 16;
	// StringValue  id   = 16;
	Id                   *wrapperspb.StringValue `protobuf:"bytes,16,opt,name=id,proto3" json:"id,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) GetId 

func (m *DeviceListItem) GetId() *wrapperspb.StringValue

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 DeviceScreenItem 

type DeviceScreenItem struct {
	DevEui               string                  `protobuf:"bytes,1,opt,name=dev_eui,json=devEUI,proto3" json:"dev_eui,omitempty"`
	Name                 string                  `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	ApplicationId        int64                   `protobuf:"varint,3,opt,name=application_id,json=applicationID,proto3" json:"application_id,omitempty"`
	Description          string                  `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
	Rssi                 int32                   `protobuf:"varint,5,opt,name=rssi,proto3" json:"rssi,omitempty"`
	Snr                  float64                 `protobuf:"fixed64,6,opt,name=snr,proto3" json:"snr,omitempty"`
	Battery              uint32                  `protobuf:"varint,7,opt,name=battery,proto3" json:"battery,omitempty"`
	Id                   *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=id,proto3" json:"id,omitempty"`
	LastSeenAt           *timestamppb.Timestamp  `protobuf:"bytes,9,opt,name=last_seen_at,json=lastSeenAt,proto3" json:"last_seen_at,omitempty"`
	Keyvalue             []*DeviceKeyValue       `protobuf:"bytes,10,rep,name=keyvalue,proto3" json:"keyvalue,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (*DeviceScreenItem) Descriptor 

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

func (*DeviceScreenItem) GetApplicationId 

func (m *DeviceScreenItem) GetApplicationId() int64

func (*DeviceScreenItem) GetBattery 

func (m *DeviceScreenItem) GetBattery() uint32

func (*DeviceScreenItem) GetDescription 

func (m *DeviceScreenItem) GetDescription() string

func (*DeviceScreenItem) GetDevEui 

func (m *DeviceScreenItem) GetDevEui() string

func (*DeviceScreenItem) GetId 

func (m *DeviceScreenItem) GetId() *wrapperspb.StringValue

func (*DeviceScreenItem) GetKeyvalue 

func (m *DeviceScreenItem) GetKeyvalue() []*DeviceKeyValue

func (*DeviceScreenItem) GetLastSeenAt 

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

func (*DeviceScreenItem) GetName 

func (m *DeviceScreenItem) GetName() string

func (*DeviceScreenItem) GetRssi 

func (m *DeviceScreenItem) GetRssi() int32

func (*DeviceScreenItem) GetSnr 

func (m *DeviceScreenItem) GetSnr() float64

func (*DeviceScreenItem) ProtoMessage 

func (*DeviceScreenItem) ProtoMessage()

func (*DeviceScreenItem) Reset 

func (m *DeviceScreenItem) Reset()

func (*DeviceScreenItem) String 

func (m *DeviceScreenItem) String() string

func (*DeviceScreenItem) XXX_DiscardUnknown 

func (m *DeviceScreenItem) XXX_DiscardUnknown()

func (*DeviceScreenItem) XXX_Marshal 

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

func (*DeviceScreenItem) XXX_Merge 

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

func (*DeviceScreenItem) XXX_Size 

func (m *DeviceScreenItem) XXX_Size() int

func (*DeviceScreenItem) XXX_Unmarshal 

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

type DeviceServiceClient 

type DeviceServiceClient interface {
	// Create creates the given device.
	Create(ctx context.Context, in *CreateDeviceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetCsvFormatDeviceList(ctx context.Context, in *GetCsvFormatDeviceListRequest, opts ...grpc.CallOption) (*GetCsvFormatDeviceListResponse, 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, opts ...grpc.CallOption) (DeviceService_StreamDeviceScanningClient, error)
	CreateDeviceCodec(ctx context.Context, in *CreateDeviceCodecRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// GetKeys returns the device-keys for the given DevEUI.
	GetDeviceCodec(ctx context.Context, in *GetDeviceCodecRequest, opts ...grpc.CallOption) (*GetDeviceCodecResponse, error)
	// UpdateKeys updates the device-keys.
	UpdateDeviceCodec(ctx context.Context, in *UpdateDeviceCodecRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteKeys deletes the device-keys for the given DevEUI.
	DeleteDeviceCodec(ctx context.Context, in *DeleteDeviceCodecRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CodecList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CodecListResponse, error)
	CreateCodec(ctx context.Context, in *CreateCodecRequest, opts ...grpc.CallOption) (*CreateCodecResponse, error)
	VerifyCodec(ctx context.Context, in *VerifyCodecRequest, opts ...grpc.CallOption) (*VerifyCodecResponse, error)
	// GetKeys returns the device-keys for the given DevEUI.
	GetCodec(ctx context.Context, in *GetCodecRequest, opts ...grpc.CallOption) (*GetCodecResponse, error)
	// UpdateKeys updates the device-keys.
	UpdateCodec(ctx context.Context, in *UpdateCodecRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DeleteKeys deletes the device-keys for the given DevEUI.
	DeleteCodec(ctx context.Context, in *DeleteCodecRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetScriptList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetScriptListReponse, error)
	GetScriptVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetScriptVersionReponse, error)
	UpdateScript(ctx context.Context, in *UpdateScriptRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StreamUpgradeScriptLog(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (DeviceService_StreamUpgradeScriptLogClient, 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)
	GetCsvFormatDeviceList(context.Context, *GetCsvFormatDeviceListRequest) (*GetCsvFormatDeviceListResponse, 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(DeviceService_StreamDeviceScanningServer) error
	CreateDeviceCodec(context.Context, *CreateDeviceCodecRequest) (*emptypb.Empty, error)
	// GetKeys returns the device-keys for the given DevEUI.
	GetDeviceCodec(context.Context, *GetDeviceCodecRequest) (*GetDeviceCodecResponse, error)
	// UpdateKeys updates the device-keys.
	UpdateDeviceCodec(context.Context, *UpdateDeviceCodecRequest) (*emptypb.Empty, error)
	// DeleteKeys deletes the device-keys for the given DevEUI.
	DeleteDeviceCodec(context.Context, *DeleteDeviceCodecRequest) (*emptypb.Empty, error)
	CodecList(context.Context, *emptypb.Empty) (*CodecListResponse, error)
	CreateCodec(context.Context, *CreateCodecRequest) (*CreateCodecResponse, error)
	VerifyCodec(context.Context, *VerifyCodecRequest) (*VerifyCodecResponse, error)
	// GetKeys returns the device-keys for the given DevEUI.
	GetCodec(context.Context, *GetCodecRequest) (*GetCodecResponse, error)
	// UpdateKeys updates the device-keys.
	UpdateCodec(context.Context, *UpdateCodecRequest) (*emptypb.Empty, error)
	// DeleteKeys deletes the device-keys for the given DevEUI.
	DeleteCodec(context.Context, *DeleteCodecRequest) (*emptypb.Empty, error)
	GetScriptList(context.Context, *emptypb.Empty) (*GetScriptListReponse, error)
	GetScriptVersion(context.Context, *emptypb.Empty) (*GetScriptVersionReponse, error)
	UpdateScript(context.Context, *UpdateScriptRequest) (*emptypb.Empty, error)
	StreamUpgradeScriptLog(*emptypb.Empty, DeviceService_StreamUpgradeScriptLogServer) error
}

DeviceServiceServer is the server API for DeviceService service.

type DeviceService_StreamDeviceScanningClient 

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

type DeviceService_StreamDeviceScanningServer 

type DeviceService_StreamDeviceScanningServer interface {
	Send(*StreamDeviceScanningReponse) error
	Recv() (*StreamDeviceScanningRequest, 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 DeviceService_StreamUpgradeScriptLogClient 

type DeviceService_StreamUpgradeScriptLogClient interface {
	Recv() (*UpgradeScriptLogReponse, error)
	grpc.ClientStream
}

type DeviceService_StreamUpgradeScriptLogServer 

type DeviceService_StreamUpgradeScriptLogServer interface {
	Send(*UpgradeScriptLogReponse) 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)
	StreamDeviceScreen(ctx context.Context, opts ...grpc.CallOption) (GatewayService_StreamDeviceScreenClient, 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
	StreamDeviceScreen(GatewayService_StreamDeviceScreenServer) error
}

GatewayServiceServer is the server API for GatewayService service.

type GatewayService_StreamDeviceScreenClient 

type GatewayService_StreamDeviceScreenClient interface {
	Send(*StreamDeviceScreenRequest) error
	Recv() (*StreamDeviceScreenResponse, error)
	grpc.ClientStream
}

type GatewayService_StreamDeviceScreenServer 

type GatewayService_StreamDeviceScreenServer interface {
	Send(*StreamDeviceScreenResponse) error
	Recv() (*StreamDeviceScreenRequest, error)
	grpc.ServerStream
}

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 GetCodecRequest 

type GetCodecRequest struct {
	// Device EUI (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 (*GetCodecRequest) Descriptor 

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

func (*GetCodecRequest) GetId 

func (m *GetCodecRequest) GetId() string

func (*GetCodecRequest) ProtoMessage 

func (*GetCodecRequest) ProtoMessage()

func (*GetCodecRequest) Reset 

func (m *GetCodecRequest) Reset()

func (*GetCodecRequest) String 

func (m *GetCodecRequest) String() string

func (*GetCodecRequest) XXX_DiscardUnknown 

func (m *GetCodecRequest) XXX_DiscardUnknown()

func (*GetCodecRequest) XXX_Marshal 

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

func (*GetCodecRequest) XXX_Merge 

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

func (*GetCodecRequest) XXX_Size 

func (m *GetCodecRequest) XXX_Size() int

func (*GetCodecRequest) XXX_Unmarshal 

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

type GetCodecResponse 

type GetCodecResponse struct {
	// Device-key object.
	DeviceCodec          *DeviceCodecRules `protobuf:"bytes,1,opt,name=device_codec,json=deviceCodec,proto3" json:"device_codec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (*GetCodecResponse) Descriptor 

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

func (*GetCodecResponse) GetDeviceCodec 

func (m *GetCodecResponse) GetDeviceCodec() *DeviceCodecRules

func (*GetCodecResponse) ProtoMessage 

func (*GetCodecResponse) ProtoMessage()

func (*GetCodecResponse) Reset 

func (m *GetCodecResponse) Reset()

func (*GetCodecResponse) String 

func (m *GetCodecResponse) String() string

func (*GetCodecResponse) XXX_DiscardUnknown 

func (m *GetCodecResponse) XXX_DiscardUnknown()

func (*GetCodecResponse) XXX_Marshal 

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

func (*GetCodecResponse) XXX_Merge 

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

func (*GetCodecResponse) XXX_Size 

func (m *GetCodecResponse) XXX_Size() int

func (*GetCodecResponse) XXX_Unmarshal 

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

type GetCsvFormatDeviceListRequest 

type GetCsvFormatDeviceListRequest struct {
	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 (*GetCsvFormatDeviceListRequest) Descriptor 

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

func (*GetCsvFormatDeviceListRequest) GetApplicationId 

func (m *GetCsvFormatDeviceListRequest) GetApplicationId() int64

func (*GetCsvFormatDeviceListRequest) ProtoMessage 

func (*GetCsvFormatDeviceListRequest) ProtoMessage()

func (*GetCsvFormatDeviceListRequest) Reset 

func (m *GetCsvFormatDeviceListRequest) Reset()

func (*GetCsvFormatDeviceListRequest) String 

func (m *GetCsvFormatDeviceListRequest) String() string

func (*GetCsvFormatDeviceListRequest) XXX_DiscardUnknown 

func (m *GetCsvFormatDeviceListRequest) XXX_DiscardUnknown()

func (*GetCsvFormatDeviceListRequest) XXX_Marshal 

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

func (*GetCsvFormatDeviceListRequest) XXX_Merge 

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

func (*GetCsvFormatDeviceListRequest) XXX_Size 

func (m *GetCsvFormatDeviceListRequest) XXX_Size() int

func (*GetCsvFormatDeviceListRequest) XXX_Unmarshal 

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

type GetCsvFormatDeviceListResponse 

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

func (*GetCsvFormatDeviceListResponse) Descriptor 

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

func (*GetCsvFormatDeviceListResponse) GetCsv 

func (m *GetCsvFormatDeviceListResponse) GetCsv() *CSVAdd

func (*GetCsvFormatDeviceListResponse) ProtoMessage 

func (*GetCsvFormatDeviceListResponse) ProtoMessage()

func (*GetCsvFormatDeviceListResponse) Reset 

func (m *GetCsvFormatDeviceListResponse) Reset()

func (*GetCsvFormatDeviceListResponse) String 

func (m *GetCsvFormatDeviceListResponse) String() string

func (*GetCsvFormatDeviceListResponse) XXX_DiscardUnknown 

func (m *GetCsvFormatDeviceListResponse) XXX_DiscardUnknown()

func (*GetCsvFormatDeviceListResponse) XXX_Marshal 

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

func (*GetCsvFormatDeviceListResponse) XXX_Merge 

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

func (*GetCsvFormatDeviceListResponse) XXX_Size 

func (m *GetCsvFormatDeviceListResponse) XXX_Size() int

func (*GetCsvFormatDeviceListResponse) XXX_Unmarshal 

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

type GetDefaultLoRaWANModeRequest 

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

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

func (*GetDefaultLoRaWANModeRequest) GetMode 

func (m *GetDefaultLoRaWANModeRequest) GetMode() string

func (*GetDefaultLoRaWANModeRequest) ProtoMessage 

func (*GetDefaultLoRaWANModeRequest) ProtoMessage()

func (*GetDefaultLoRaWANModeRequest) Reset 

func (m *GetDefaultLoRaWANModeRequest) Reset()

func (*GetDefaultLoRaWANModeRequest) String 

func (m *GetDefaultLoRaWANModeRequest) String() string

func (*GetDefaultLoRaWANModeRequest) XXX_DiscardUnknown 

func (m *GetDefaultLoRaWANModeRequest) XXX_DiscardUnknown()

func (*GetDefaultLoRaWANModeRequest) XXX_Marshal 

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

func (*GetDefaultLoRaWANModeRequest) XXX_Merge 

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

func (*GetDefaultLoRaWANModeRequest) XXX_Size 

func (m *GetDefaultLoRaWANModeRequest) XXX_Size() int

func (*GetDefaultLoRaWANModeRequest) XXX_Unmarshal 

func (m *GetDefaultLoRaWANModeRequest) 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 GetDeviceCodecRequest 

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

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

func (*GetDeviceCodecRequest) GetDevEui 

func (m *GetDeviceCodecRequest) GetDevEui() string

func (*GetDeviceCodecRequest) ProtoMessage 

func (*GetDeviceCodecRequest) ProtoMessage()

func (*GetDeviceCodecRequest) Reset 

func (m *GetDeviceCodecRequest) Reset()

func (*GetDeviceCodecRequest) String 

func (m *GetDeviceCodecRequest) String() string

func (*GetDeviceCodecRequest) XXX_DiscardUnknown 

func (m *GetDeviceCodecRequest) XXX_DiscardUnknown()

func (*GetDeviceCodecRequest) XXX_Marshal 

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

func (*GetDeviceCodecRequest) XXX_Merge 

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

func (*GetDeviceCodecRequest) XXX_Size 

func (m *GetDeviceCodecRequest) XXX_Size() int

func (*GetDeviceCodecRequest) XXX_Unmarshal 

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

type GetDeviceCodecResponse 

type GetDeviceCodecResponse struct {
	// Device-key object.
	DeviceCodec          *DeviceCodec `protobuf:"bytes,1,opt,name=device_codec,json=deviceCodec,proto3" json:"device_codec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (*GetDeviceCodecResponse) Descriptor 

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

func (*GetDeviceCodecResponse) GetDeviceCodec 

func (m *GetDeviceCodecResponse) GetDeviceCodec() *DeviceCodec

func (*GetDeviceCodecResponse) ProtoMessage 

func (*GetDeviceCodecResponse) ProtoMessage()

func (*GetDeviceCodecResponse) Reset 

func (m *GetDeviceCodecResponse) Reset()

func (*GetDeviceCodecResponse) String 

func (m *GetDeviceCodecResponse) String() string

func (*GetDeviceCodecResponse) XXX_DiscardUnknown 

func (m *GetDeviceCodecResponse) XXX_DiscardUnknown()

func (*GetDeviceCodecResponse) XXX_Marshal 

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

func (*GetDeviceCodecResponse) XXX_Merge 

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

func (*GetDeviceCodecResponse) XXX_Size 

func (m *GetDeviceCodecResponse) XXX_Size() int

func (*GetDeviceCodecResponse) XXX_Unmarshal 

func (m *GetDeviceCodecResponse) 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