device_service.pb.descriptors.go

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

package device_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/v1/device"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// 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{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized                    bool
	deviceServiceDescriptor                   *DeviceServiceDescriptor
	getDeviceDescriptor                       *GetDeviceDescriptor
	batchGetDevicesDescriptor                 *BatchGetDevicesDescriptor
	listDevicesDescriptor                     *ListDevicesDescriptor
	watchDeviceDescriptor                     *WatchDeviceDescriptor
	watchDevicesDescriptor                    *WatchDevicesDescriptor
	createDeviceDescriptor                    *CreateDeviceDescriptor
	updateDeviceDescriptor                    *UpdateDeviceDescriptor
	deleteDeviceDescriptor                    *DeleteDeviceDescriptor
	provisionServiceAccountToDeviceDescriptor *ProvisionServiceAccountToDeviceDescriptor
	removeServiceAccountFromDeviceDescriptor  *RemoveServiceAccountFromDeviceDescriptor
	heartbeatDescriptor                       *HeartbeatDescriptor
)

type GetDeviceDescriptor struct{}

type GetDeviceDescriptorClientMsgHandle struct{}

type GetDeviceDescriptorServerMsgHandle struct{}

func (d *GetDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetDeviceRequest{}
}

func (d *GetDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &device.Device{}
}

func (d *GetDeviceDescriptor) IsUnary() bool {
	return true
}

func (d *GetDeviceDescriptor) IsClientStream() bool {
	return false
}

func (d *GetDeviceDescriptor) IsServerStream() bool {
	return false
}

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

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

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

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

func (d *GetDeviceDescriptor) GetVerb() string {
	return "get"
}

func (d *GetDeviceDescriptor) GetMethodName() string {
	return "GetDevice"
}

func (d *GetDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/GetDevice"
}

func (d *GetDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *GetDeviceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *GetDeviceDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *GetDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *GetDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetDeviceDescriptorClientMsgHandle{}
}

func (d *GetDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetDeviceDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

func (h *GetDeviceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*device.Device)
}

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

func GetGetDeviceDescriptor() *GetDeviceDescriptor {
	return getDeviceDescriptor
}

type BatchGetDevicesDescriptor struct{}

type BatchGetDevicesDescriptorClientMsgHandle struct{}

type BatchGetDevicesDescriptorServerMsgHandle struct{}

func (d *BatchGetDevicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetDevicesRequest{}
}

func (d *BatchGetDevicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetDevicesResponse{}
}

func (d *BatchGetDevicesDescriptor) IsUnary() bool {
	return true
}

func (d *BatchGetDevicesDescriptor) IsClientStream() bool {
	return false
}

func (d *BatchGetDevicesDescriptor) IsServerStream() bool {
	return false
}

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

func (d *BatchGetDevicesDescriptor) IsPlural() bool {
	return true
}

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

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

func (d *BatchGetDevicesDescriptor) GetVerb() string {
	return "batchGet"
}

func (d *BatchGetDevicesDescriptor) GetMethodName() string {
	return "BatchGetDevices"
}

func (d *BatchGetDevicesDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/BatchGetDevices"
}

func (d *BatchGetDevicesDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *BatchGetDevicesDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *BatchGetDevicesDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *BatchGetDevicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *BatchGetDevicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetDevicesDescriptorClientMsgHandle{}
}

func (d *BatchGetDevicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetDevicesDescriptorServerMsgHandle{}
}

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

func (h *BatchGetDevicesDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BatchGetDevicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BatchGetDevicesRequest) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if names := typedMsg.GetNames(); len(names) > 0 {
			return device.DeviceNameList(names)
		}
	}
	return (device.DeviceNameList)(nil)
}

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

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

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

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

func (h *BatchGetDevicesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*BatchGetDevicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*BatchGetDevicesResponse) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resources := typedMsg.GetDevices(); len(resources) > 0 {
			list := make(device.DeviceNameList, 0, len(resources))
			for _, res := range resources {
				list = append(list, res.GetName())
			}
			return list
		}
	}
	return (device.DeviceNameList)(nil)
}

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

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

func (h *BatchGetDevicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetDevicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetDevicesResponse) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetDevices(); len(resources) > 0 {
			return device.DeviceList(resources)
		}
	}
	return (device.DeviceList)(nil)
}

func GetBatchGetDevicesDescriptor() *BatchGetDevicesDescriptor {
	return batchGetDevicesDescriptor
}

type ListDevicesDescriptor struct{}

type ListDevicesDescriptorClientMsgHandle struct{}

type ListDevicesDescriptorServerMsgHandle struct{}

func (d *ListDevicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListDevicesRequest{}
}

func (d *ListDevicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListDevicesResponse{}
}

func (d *ListDevicesDescriptor) IsUnary() bool {
	return true
}

func (d *ListDevicesDescriptor) IsClientStream() bool {
	return false
}

func (d *ListDevicesDescriptor) IsServerStream() bool {
	return false
}

func (d *ListDevicesDescriptor) IsCollection() bool {
	return true
}

func (d *ListDevicesDescriptor) IsPlural() bool {
	return true
}

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

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

func (d *ListDevicesDescriptor) GetVerb() string {
	return "list"
}

func (d *ListDevicesDescriptor) GetMethodName() string {
	return "ListDevices"
}

func (d *ListDevicesDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/ListDevices"
}

func (d *ListDevicesDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *ListDevicesDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *ListDevicesDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *ListDevicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *ListDevicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListDevicesDescriptorClientMsgHandle{}
}

func (d *ListDevicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListDevicesDescriptorServerMsgHandle{}
}

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

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

func (h *ListDevicesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*ListDevicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*ListDevicesRequest) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*device.ParentName)(nil)
}

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

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

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

func (h *ListDevicesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListDevicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListDevicesResponse) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resources := typedMsg.GetDevices(); len(resources) > 0 {
			list := make(device.DeviceNameList, 0, len(resources))
			for _, res := range resources {
				list = append(list, res.GetName())
			}
			return list
		}
	}
	return (device.DeviceNameList)(nil)
}

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

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

func (h *ListDevicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListDevicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListDevicesResponse) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetDevices(); len(resources) > 0 {
			return device.DeviceList(resources)
		}
	}
	return (device.DeviceList)(nil)
}

func GetListDevicesDescriptor() *ListDevicesDescriptor {
	return listDevicesDescriptor
}

type WatchDeviceDescriptor struct{}

type WatchDeviceDescriptorClientMsgHandle struct{}

type WatchDeviceDescriptorServerMsgHandle struct{}

func (d *WatchDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchDeviceRequest{}
}

func (d *WatchDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchDeviceResponse{}
}

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

func (d *WatchDeviceDescriptor) IsClientStream() bool {
	return false
}

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

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

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

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

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

func (d *WatchDeviceDescriptor) GetVerb() string {
	return "watch"
}

func (d *WatchDeviceDescriptor) GetMethodName() string {
	return "WatchDevice"
}

func (d *WatchDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/WatchDevice"
}

func (d *WatchDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *WatchDeviceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *WatchDeviceDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *WatchDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *WatchDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDeviceDescriptorClientMsgHandle{}
}

func (d *WatchDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDeviceDescriptorServerMsgHandle{}
}

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

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

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

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

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

func (h *WatchDeviceDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchDeviceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchDeviceResponse) *device.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *device.DeviceChange_Added_:
				return tResChange.Added.GetDevice().GetName()
			case *device.DeviceChange_Modified_:
				return tResChange.Modified.GetName()
			case *device.DeviceChange_Removed_:
				return tResChange.Removed.GetName()
			case *device.DeviceChange_Current_:
				return tResChange.Current.GetDevice().GetName()
			}
		}
	}
	return (*device.Name)(nil)
}

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

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

func (h *WatchDeviceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchDeviceResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchDeviceResponse) *device.Device
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *device.DeviceChange_Added_:
				return tResChange.Added.GetDevice()
			case *device.DeviceChange_Modified_:
				return tResChange.Modified.GetDevice()
			case *device.DeviceChange_Current_:
				return tResChange.Current.GetDevice()
			}
		}
	}
	return (*device.Device)(nil)
}

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

func GetWatchDeviceDescriptor() *WatchDeviceDescriptor {
	return watchDeviceDescriptor
}

type WatchDevicesDescriptor struct{}

type WatchDevicesDescriptorClientMsgHandle struct{}

type WatchDevicesDescriptorServerMsgHandle struct{}

func (d *WatchDevicesDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchDevicesRequest{}
}

func (d *WatchDevicesDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchDevicesResponse{}
}

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

func (d *WatchDevicesDescriptor) IsClientStream() bool {
	return false
}

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

func (d *WatchDevicesDescriptor) IsCollection() bool {
	return true
}

func (d *WatchDevicesDescriptor) IsPlural() bool {
	return true
}

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

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

func (d *WatchDevicesDescriptor) GetVerb() string {
	return "watch"
}

func (d *WatchDevicesDescriptor) GetMethodName() string {
	return "WatchDevices"
}

func (d *WatchDevicesDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/WatchDevices"
}

func (d *WatchDevicesDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *WatchDevicesDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *WatchDevicesDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *WatchDevicesDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *WatchDevicesDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDevicesDescriptorClientMsgHandle{}
}

func (d *WatchDevicesDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchDevicesDescriptorServerMsgHandle{}
}

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

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

func (h *WatchDevicesDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchDevicesRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*WatchDevicesRequest) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*device.ParentName)(nil)
}

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

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

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

func (h *WatchDevicesDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchDevicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchDevicesResponse) []*device.Name
	})
	if ok {
		return device.DeviceNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetDeviceChanges(); len(resChanges) > 0 {
			list := make(device.DeviceNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *device.DeviceChange_Added_:
					list = append(list, tResChange.Added.GetDevice().GetName())
				case *device.DeviceChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *device.DeviceChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *device.DeviceChange_Current_:
					list = append(list, tResChange.Current.GetDevice().GetName())
				}
			}
			return list
		}
	}
	return (device.DeviceNameList)(nil)
}

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

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

func (h *WatchDevicesDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchDevicesResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchDevicesResponse) []*device.Device
	})
	if ok {
		return device.DeviceList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetDeviceChanges(); len(resChanges) > 0 {
			list := make(device.DeviceList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *device.DeviceChange_Added_:
					list = append(list, tResChange.Added.GetDevice())
				case *device.DeviceChange_Modified_:
					list = append(list, tResChange.Modified.GetDevice())
				case *device.DeviceChange_Current_:
					list = append(list, tResChange.Current.GetDevice())
				}
			}
			return list
		}
	}
	return (device.DeviceList)(nil)
}

func GetWatchDevicesDescriptor() *WatchDevicesDescriptor {
	return watchDevicesDescriptor
}

type CreateDeviceDescriptor struct{}

type CreateDeviceDescriptorClientMsgHandle struct{}

type CreateDeviceDescriptorServerMsgHandle struct{}

func (d *CreateDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateDeviceRequest{}
}

func (d *CreateDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &device.Device{}
}

func (d *CreateDeviceDescriptor) IsUnary() bool {
	return true
}

func (d *CreateDeviceDescriptor) IsClientStream() bool {
	return false
}

func (d *CreateDeviceDescriptor) IsServerStream() bool {
	return false
}

func (d *CreateDeviceDescriptor) IsCollection() bool {
	return true
}

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

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

func (d *CreateDeviceDescriptor) RequestHasResourceBody() bool {
	return true
}

func (d *CreateDeviceDescriptor) GetVerb() string {
	return "create"
}

func (d *CreateDeviceDescriptor) GetMethodName() string {
	return "CreateDevice"
}

func (d *CreateDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/CreateDevice"
}

func (d *CreateDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *CreateDeviceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *CreateDeviceDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *CreateDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *CreateDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateDeviceDescriptorClientMsgHandle{}
}

func (d *CreateDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateDeviceDescriptorServerMsgHandle{}
}

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

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

func (h *CreateDeviceDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*CreateDeviceRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractCollectionName(*CreateDeviceRequest) *device.ParentName
	})
	if ok {
		return override.OverrideExtractCollectionName(typedMsg)
	}
	{
		if parentName := typedMsg.GetParent(); parentName != nil {
			return parentName
		}
	}
	return (*device.ParentName)(nil)
}

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

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

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

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

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

func (h *CreateDeviceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*device.Device)
}

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

func GetCreateDeviceDescriptor() *CreateDeviceDescriptor {
	return createDeviceDescriptor
}

type UpdateDeviceDescriptor struct{}

type UpdateDeviceDescriptorClientMsgHandle struct{}

type UpdateDeviceDescriptorServerMsgHandle struct{}

func (d *UpdateDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateDeviceRequest{}
}

func (d *UpdateDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &device.Device{}
}

func (d *UpdateDeviceDescriptor) IsUnary() bool {
	return true
}

func (d *UpdateDeviceDescriptor) IsClientStream() bool {
	return false
}

func (d *UpdateDeviceDescriptor) IsServerStream() bool {
	return false
}

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

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

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

func (d *UpdateDeviceDescriptor) RequestHasResourceBody() bool {
	return true
}

func (d *UpdateDeviceDescriptor) GetVerb() string {
	return "update"
}

func (d *UpdateDeviceDescriptor) GetMethodName() string {
	return "UpdateDevice"
}

func (d *UpdateDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/UpdateDevice"
}

func (d *UpdateDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *UpdateDeviceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *UpdateDeviceDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *UpdateDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *UpdateDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateDeviceDescriptorClientMsgHandle{}
}

func (d *UpdateDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateDeviceDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

func (h *UpdateDeviceDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*device.Device)
}

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

func GetUpdateDeviceDescriptor() *UpdateDeviceDescriptor {
	return updateDeviceDescriptor
}

type DeleteDeviceDescriptor struct{}

type DeleteDeviceDescriptorClientMsgHandle struct{}

type DeleteDeviceDescriptorServerMsgHandle struct{}

func (d *DeleteDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteDeviceRequest{}
}

func (d *DeleteDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &emptypb.Empty{}
}

func (d *DeleteDeviceDescriptor) IsUnary() bool {
	return true
}

func (d *DeleteDeviceDescriptor) IsClientStream() bool {
	return false
}

func (d *DeleteDeviceDescriptor) IsServerStream() bool {
	return false
}

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

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

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

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

func (d *DeleteDeviceDescriptor) GetVerb() string {
	return "delete"
}

func (d *DeleteDeviceDescriptor) GetMethodName() string {
	return "DeleteDevice"
}

func (d *DeleteDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/DeleteDevice"
}

func (d *DeleteDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *DeleteDeviceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *DeleteDeviceDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *DeleteDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *DeleteDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteDeviceDescriptorClientMsgHandle{}
}

func (d *DeleteDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteDeviceDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

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

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

func GetDeleteDeviceDescriptor() *DeleteDeviceDescriptor {
	return deleteDeviceDescriptor
}

type ProvisionServiceAccountToDeviceDescriptor struct{}

type ProvisionServiceAccountToDeviceDescriptorClientMsgHandle struct{}

type ProvisionServiceAccountToDeviceDescriptorServerMsgHandle struct{}

func (d *ProvisionServiceAccountToDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &ProvisionServiceAccountToDeviceRequest{}
}

func (d *ProvisionServiceAccountToDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &ProvisionServiceAccountToDeviceResponse{}
}

func (d *ProvisionServiceAccountToDeviceDescriptor) IsUnary() bool {
	return true
}

func (d *ProvisionServiceAccountToDeviceDescriptor) IsClientStream() bool {
	return false
}

func (d *ProvisionServiceAccountToDeviceDescriptor) IsServerStream() bool {
	return false
}

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

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

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

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

func (d *ProvisionServiceAccountToDeviceDescriptor) GetVerb() string {
	return "provisionServiceAccountToDevice"
}

func (d *ProvisionServiceAccountToDeviceDescriptor) GetMethodName() string {
	return "ProvisionServiceAccountToDevice"
}

func (d *ProvisionServiceAccountToDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/ProvisionServiceAccountToDevice"
}

func (d *ProvisionServiceAccountToDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *ProvisionServiceAccountToDeviceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *ProvisionServiceAccountToDeviceDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *ProvisionServiceAccountToDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *ProvisionServiceAccountToDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ProvisionServiceAccountToDeviceDescriptorClientMsgHandle{}
}

func (d *ProvisionServiceAccountToDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ProvisionServiceAccountToDeviceDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

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

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

func GetProvisionServiceAccountToDeviceDescriptor() *ProvisionServiceAccountToDeviceDescriptor {
	return provisionServiceAccountToDeviceDescriptor
}

type RemoveServiceAccountFromDeviceDescriptor struct{}

type RemoveServiceAccountFromDeviceDescriptorClientMsgHandle struct{}

type RemoveServiceAccountFromDeviceDescriptorServerMsgHandle struct{}

func (d *RemoveServiceAccountFromDeviceDescriptor) NewEmptyClientMsg() proto.Message {
	return &RemoveServiceAccountFromDeviceRequest{}
}

func (d *RemoveServiceAccountFromDeviceDescriptor) NewEmptyServerMsg() proto.Message {
	return &RemoveServiceAccountFromDeviceResponse{}
}

func (d *RemoveServiceAccountFromDeviceDescriptor) IsUnary() bool {
	return true
}

func (d *RemoveServiceAccountFromDeviceDescriptor) IsClientStream() bool {
	return false
}

func (d *RemoveServiceAccountFromDeviceDescriptor) IsServerStream() bool {
	return false
}

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

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

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

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

func (d *RemoveServiceAccountFromDeviceDescriptor) GetVerb() string {
	return "removeServiceAccountFromDevice"
}

func (d *RemoveServiceAccountFromDeviceDescriptor) GetMethodName() string {
	return "RemoveServiceAccountFromDevice"
}

func (d *RemoveServiceAccountFromDeviceDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/RemoveServiceAccountFromDevice"
}

func (d *RemoveServiceAccountFromDeviceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *RemoveServiceAccountFromDeviceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *RemoveServiceAccountFromDeviceDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *RemoveServiceAccountFromDeviceDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *RemoveServiceAccountFromDeviceDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &RemoveServiceAccountFromDeviceDescriptorClientMsgHandle{}
}

func (d *RemoveServiceAccountFromDeviceDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &RemoveServiceAccountFromDeviceDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

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

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

func GetRemoveServiceAccountFromDeviceDescriptor() *RemoveServiceAccountFromDeviceDescriptor {
	return removeServiceAccountFromDeviceDescriptor
}

type HeartbeatDescriptor struct{}

type HeartbeatDescriptorClientMsgHandle struct{}

type HeartbeatDescriptorServerMsgHandle struct{}

func (d *HeartbeatDescriptor) NewEmptyClientMsg() proto.Message {
	return &HeartbeatMsg{}
}

func (d *HeartbeatDescriptor) NewEmptyServerMsg() proto.Message {
	return &HeartbeatResponse{}
}

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

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

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

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

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

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

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

func (d *HeartbeatDescriptor) GetVerb() string {
	return "heartbeat"
}

func (d *HeartbeatDescriptor) GetMethodName() string {
	return "Heartbeat"
}

func (d *HeartbeatDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.DeviceService/Heartbeat"
}

func (d *HeartbeatDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *HeartbeatDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *HeartbeatDescriptor) GetServiceVersion() string {
	return "v1"
}

func (d *HeartbeatDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return deviceServiceDescriptor
}

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

func (d *HeartbeatDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &HeartbeatDescriptorClientMsgHandle{}
}

func (d *HeartbeatDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &HeartbeatDescriptorServerMsgHandle{}
}

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

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

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

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

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

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

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

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

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

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

func GetHeartbeatDescriptor() *HeartbeatDescriptor {
	return heartbeatDescriptor
}

type DeviceServiceDescriptor struct{}

func (d *DeviceServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getDeviceDescriptor,
		batchGetDevicesDescriptor,
		listDevicesDescriptor,
		watchDeviceDescriptor,
		watchDevicesDescriptor,
		createDeviceDescriptor,
		updateDeviceDescriptor,
		deleteDeviceDescriptor,
		provisionServiceAccountToDeviceDescriptor,
		removeServiceAccountFromDeviceDescriptor,
		heartbeatDescriptor,
	}
}

func (d *DeviceServiceDescriptor) GetFullAPIName() string {
	return "/ntt.devices.v1.DeviceService"
}

func (d *DeviceServiceDescriptor) GetProtoPkgName() string {
	return "ntt.devices.v1"
}

func (d *DeviceServiceDescriptor) GetApiName() string {
	return "DeviceService"
}

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

func (d *DeviceServiceDescriptor) GetServiceVersion() string {
	return "v1"
}

func GetDeviceServiceDescriptor() *DeviceServiceDescriptor {
	return deviceServiceDescriptor
}

func initDescriptors() {
	deviceServiceDescriptor = &DeviceServiceDescriptor{}
	getDeviceDescriptor = &GetDeviceDescriptor{}
	batchGetDevicesDescriptor = &BatchGetDevicesDescriptor{}
	listDevicesDescriptor = &ListDevicesDescriptor{}
	watchDeviceDescriptor = &WatchDeviceDescriptor{}
	watchDevicesDescriptor = &WatchDevicesDescriptor{}
	createDeviceDescriptor = &CreateDeviceDescriptor{}
	updateDeviceDescriptor = &UpdateDeviceDescriptor{}
	deleteDeviceDescriptor = &DeleteDeviceDescriptor{}
	provisionServiceAccountToDeviceDescriptor = &ProvisionServiceAccountToDeviceDescriptor{}
	removeServiceAccountFromDeviceDescriptor = &RemoveServiceAccountFromDeviceDescriptor{}
	heartbeatDescriptor = &HeartbeatDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(deviceServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getDeviceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetDevicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listDevicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchDeviceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchDevicesDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createDeviceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateDeviceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteDeviceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(provisionServiceAccountToDeviceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(removeServiceAccountFromDeviceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(heartbeatDescriptor)
}

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