github.com/cloudwan/edgelq-sdk@v1.15.4/devices/client/v1alpha2/broker/broker_service.pb.descriptors.go

// Code generated by protoc-gen-goten-client
// API: BrokerService
// DO NOT EDIT!!!

package broker_client

import (
	"google.golang.org/protobuf/proto"

	gotenclient "github.com/cloudwan/goten-sdk/runtime/client"
	gotenresource "github.com/cloudwan/goten-sdk/runtime/resource"
)

// proto imports
import (
	device "github.com/cloudwan/edgelq-sdk/devices/resources/v1alpha2/device"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = new(proto.Message)
	_ = new(gotenclient.MethodDescriptor)
	_ = gotenresource.WildcardId
)

// make sure we're using proto imports
var (
	_ = &device.Device{}
)

var (
	descriptorsInitialized                bool
	brokerServiceDescriptor               *BrokerServiceDescriptor
	listenForConnectionsDescriptor        *ListenForConnectionsDescriptor
	openConnectionChannelSocketDescriptor *OpenConnectionChannelSocketDescriptor
	connectToDeviceDescriptor             *ConnectToDeviceDescriptor
)

type ListenForConnectionsDescriptor struct{}

type ListenForConnectionsDescriptorClientMsgHandle struct{}

type ListenForConnectionsDescriptorServerMsgHandle struct{}

func (d *ListenForConnectionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListenForConnectionsRequest{}
}

func (d *ListenForConnectionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListenForConnectionsResponse{}
}

func (d *ListenForConnectionsDescriptor) IsUnary() bool {
	return false
}

func (d *ListenForConnectionsDescriptor) IsClientStream() bool {
	return true
}

func (d *ListenForConnectionsDescriptor) IsServerStream() bool {
	return true
}

func (d *ListenForConnectionsDescriptor) IsCollection() bool {
	return false
}

func (d *ListenForConnectionsDescriptor) IsPlural() bool {
	return false
}

func (d *ListenForConnectionsDescriptor) HasResource() bool {
	return true
}

func (d *ListenForConnectionsDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *ListenForConnectionsDescriptor) GetVerb() string {
	return "listenForConnections"
}

func (d *ListenForConnectionsDescriptor) GetMethodName() string {
	return "ListenForConnections"
}

func (d *ListenForConnectionsDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1alpha2.BrokerService/ListenForConnections"
}

func (d *ListenForConnectionsDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1alpha2"
}

func (d *ListenForConnectionsDescriptor) GetApiName() string {
	return "BrokerService"
}

func (d *ListenForConnectionsDescriptor) GetServiceDomain() string {
	return "devices.edgelq.com"
}

func (d *ListenForConnectionsDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *ListenForConnectionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return brokerServiceDescriptor
}

func (d *ListenForConnectionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return device.GetDescriptor()
}

func (d *ListenForConnectionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListenForConnectionsDescriptorClientMsgHandle{}
}

func (d *ListenForConnectionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListenForConnectionsDescriptorServerMsgHandle{}
}

func (h *ListenForConnectionsDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListenForConnectionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ListenForConnectionsRequest) *device.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetRegisterListener().GetDevice(); name != nil {
			return name
		}
	}
	return (*device.Name)(nil)
}

func (h *ListenForConnectionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListenForConnectionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListenForConnectionsRequest) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListenForConnectionsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListenForConnectionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ListenForConnectionsRequest) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *ListenForConnectionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListenForConnectionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListenForConnectionsRequest) *device.Device
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListenForConnectionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListenForConnectionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListenForConnectionsRequest) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *ListenForConnectionsDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListenForConnectionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ListenForConnectionsResponse) *device.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *ListenForConnectionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListenForConnectionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListenForConnectionsResponse) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListenForConnectionsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListenForConnectionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ListenForConnectionsResponse) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *ListenForConnectionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListenForConnectionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListenForConnectionsResponse) *device.Device
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListenForConnectionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListenForConnectionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListenForConnectionsResponse) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetListenForConnectionsDescriptor() *ListenForConnectionsDescriptor {
	return listenForConnectionsDescriptor
}

type OpenConnectionChannelSocketDescriptor struct{}

type OpenConnectionChannelSocketDescriptorClientMsgHandle struct{}

type OpenConnectionChannelSocketDescriptorServerMsgHandle struct{}

func (d *OpenConnectionChannelSocketDescriptor) NewEmptyClientMsg() proto.Message {
	return &OpenConnectionChannelSocketRequest{}
}

func (d *OpenConnectionChannelSocketDescriptor) NewEmptyServerMsg() proto.Message {
	return &OpenConnectionChannelSocketResponse{}
}

func (d *OpenConnectionChannelSocketDescriptor) IsUnary() bool {
	return false
}

func (d *OpenConnectionChannelSocketDescriptor) IsClientStream() bool {
	return true
}

func (d *OpenConnectionChannelSocketDescriptor) IsServerStream() bool {
	return true
}

func (d *OpenConnectionChannelSocketDescriptor) IsCollection() bool {
	return false
}

func (d *OpenConnectionChannelSocketDescriptor) IsPlural() bool {
	return false
}

func (d *OpenConnectionChannelSocketDescriptor) HasResource() bool {
	return true
}

func (d *OpenConnectionChannelSocketDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *OpenConnectionChannelSocketDescriptor) GetVerb() string {
	return "openConnectionChannelSocket"
}

func (d *OpenConnectionChannelSocketDescriptor) GetMethodName() string {
	return "OpenConnectionChannelSocket"
}

func (d *OpenConnectionChannelSocketDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1alpha2.BrokerService/OpenConnectionChannelSocket"
}

func (d *OpenConnectionChannelSocketDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1alpha2"
}

func (d *OpenConnectionChannelSocketDescriptor) GetApiName() string {
	return "BrokerService"
}

func (d *OpenConnectionChannelSocketDescriptor) GetServiceDomain() string {
	return "devices.edgelq.com"
}

func (d *OpenConnectionChannelSocketDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *OpenConnectionChannelSocketDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return brokerServiceDescriptor
}

func (d *OpenConnectionChannelSocketDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return device.GetDescriptor()
}

func (d *OpenConnectionChannelSocketDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &OpenConnectionChannelSocketDescriptorClientMsgHandle{}
}

func (d *OpenConnectionChannelSocketDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &OpenConnectionChannelSocketDescriptorServerMsgHandle{}
}

func (h *OpenConnectionChannelSocketDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*OpenConnectionChannelSocketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*OpenConnectionChannelSocketRequest) *device.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetRegisterSocket().GetDevice(); name != nil {
			return name
		}
	}
	return (*device.Name)(nil)
}

func (h *OpenConnectionChannelSocketDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*OpenConnectionChannelSocketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*OpenConnectionChannelSocketRequest) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*OpenConnectionChannelSocketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*OpenConnectionChannelSocketRequest) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*OpenConnectionChannelSocketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*OpenConnectionChannelSocketRequest) *device.Device
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*OpenConnectionChannelSocketRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*OpenConnectionChannelSocketRequest) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*OpenConnectionChannelSocketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*OpenConnectionChannelSocketResponse) *device.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*OpenConnectionChannelSocketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*OpenConnectionChannelSocketResponse) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*OpenConnectionChannelSocketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*OpenConnectionChannelSocketResponse) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*OpenConnectionChannelSocketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*OpenConnectionChannelSocketResponse) *device.Device
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *OpenConnectionChannelSocketDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*OpenConnectionChannelSocketResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*OpenConnectionChannelSocketResponse) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetOpenConnectionChannelSocketDescriptor() *OpenConnectionChannelSocketDescriptor {
	return openConnectionChannelSocketDescriptor
}

type ConnectToDeviceDescriptor struct{}

type ConnectToDeviceDescriptorClientMsgHandle struct{}

type ConnectToDeviceDescriptorServerMsgHandle struct{}

func (d *ConnectToDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &ConnectToDeviceRequest{}
}

func (d *ConnectToDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &ConnectToDeviceResponse{}
}

func (d *ConnectToDeviceDescriptor) IsUnary() bool {
	return false
}

func (d *ConnectToDeviceDescriptor) IsClientStream() bool {
	return true
}

func (d *ConnectToDeviceDescriptor) IsServerStream() bool {
	return true
}

func (d *ConnectToDeviceDescriptor) IsCollection() bool {
	return false
}

func (d *ConnectToDeviceDescriptor) IsPlural() bool {
	return false
}

func (d *ConnectToDeviceDescriptor) HasResource() bool {
	return true
}

func (d *ConnectToDeviceDescriptor) RequestHasResourceBody() bool {
	return false
}

func (d *ConnectToDeviceDescriptor) GetVerb() string {
	return "connectToDevice"
}

func (d *ConnectToDeviceDescriptor) GetMethodName() string {
	return "ConnectToDevice"
}

func (d *ConnectToDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1alpha2.BrokerService/ConnectToDevice"
}

func (d *ConnectToDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1alpha2"
}

func (d *ConnectToDeviceDescriptor) GetApiName() string {
	return "BrokerService"
}

func (d *ConnectToDeviceDescriptor) GetServiceDomain() string {
	return "devices.edgelq.com"
}

func (d *ConnectToDeviceDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func (d *ConnectToDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return brokerServiceDescriptor
}

func (d *ConnectToDeviceDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return device.GetDescriptor()
}

func (d *ConnectToDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ConnectToDeviceDescriptorClientMsgHandle{}
}

func (d *ConnectToDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ConnectToDeviceDescriptorServerMsgHandle{}
}

func (h *ConnectToDeviceDescriptorClientMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ConnectToDeviceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ConnectToDeviceRequest) *device.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if name := typedMsg.GetOpenRequest().GetDevice(); name != nil {
			return name
		}
	}
	return (*device.Name)(nil)
}

func (h *ConnectToDeviceDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ConnectToDeviceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ConnectToDeviceRequest) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ConnectToDeviceDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ConnectToDeviceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ConnectToDeviceRequest) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *ConnectToDeviceDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ConnectToDeviceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ConnectToDeviceRequest) *device.Device
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ConnectToDeviceDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ConnectToDeviceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ConnectToDeviceRequest) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *ConnectToDeviceDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ConnectToDeviceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*ConnectToDeviceResponse) *device.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	return nil
}

func (h *ConnectToDeviceDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ConnectToDeviceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ConnectToDeviceResponse) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ConnectToDeviceDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ConnectToDeviceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ConnectToDeviceResponse) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	return nil
}

func (h *ConnectToDeviceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ConnectToDeviceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ConnectToDeviceResponse) *device.Device
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ConnectToDeviceDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ConnectToDeviceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ConnectToDeviceResponse) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetConnectToDeviceDescriptor() *ConnectToDeviceDescriptor {
	return connectToDeviceDescriptor
}

type BrokerServiceDescriptor struct{}

func (d *BrokerServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		listenForConnectionsDescriptor,
		openConnectionChannelSocketDescriptor,
		connectToDeviceDescriptor,
	}
}

func (d *BrokerServiceDescriptor) GetFullAPIName() string {
	return "/ntt.devices.v1alpha2.BrokerService"
}

func (d *BrokerServiceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1alpha2"
}

func (d *BrokerServiceDescriptor) GetApiName() string {
	return "BrokerService"
}

func (d *BrokerServiceDescriptor) GetServiceDomain() string {
	return "devices.edgelq.com"
}

func (d *BrokerServiceDescriptor) GetServiceVersion() string {
	return "v1alpha2"
}

func GetBrokerServiceDescriptor() *BrokerServiceDescriptor {
	return brokerServiceDescriptor
}

func initDescriptors() {
	brokerServiceDescriptor = &BrokerServiceDescriptor{}
	listenForConnectionsDescriptor = &ListenForConnectionsDescriptor{}
	openConnectionChannelSocketDescriptor = &OpenConnectionChannelSocketDescriptor{}
	connectToDeviceDescriptor = &ConnectToDeviceDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(brokerServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listenForConnectionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(openConnectionChannelSocketDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(connectToDeviceDescriptor)
}

func init() {
	if !descriptorsInitialized {
		initDescriptors()
		descriptorsInitialized = true
	}
}