github.com/cloudwan/edgelq-sdk@v1.15.4/devices/client/v1/os_version/os_version_service.pb.descriptors.go

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

package os_version_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 (
	os_version "github.com/cloudwan/edgelq-sdk/devices/resources/v1/os_version"
	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 (
	_ = &os_version.OsVersion{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized       bool
	osVersionServiceDescriptor   *OsVersionServiceDescriptor
	getOsVersionDescriptor       *GetOsVersionDescriptor
	batchGetOsVersionsDescriptor *BatchGetOsVersionsDescriptor
	listOsVersionsDescriptor     *ListOsVersionsDescriptor
	watchOsVersionDescriptor     *WatchOsVersionDescriptor
	watchOsVersionsDescriptor    *WatchOsVersionsDescriptor
	createOsVersionDescriptor    *CreateOsVersionDescriptor
	updateOsVersionDescriptor    *UpdateOsVersionDescriptor
	deleteOsVersionDescriptor    *DeleteOsVersionDescriptor
)

type GetOsVersionDescriptor struct{}

type GetOsVersionDescriptorClientMsgHandle struct{}

type GetOsVersionDescriptorServerMsgHandle struct{}

func (d *GetOsVersionDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetOsVersionRequest{}
}

func (d *GetOsVersionDescriptor) NewEmptyServerMsg() proto.Message {
	return &os_version.OsVersion{}
}

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

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

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

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

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

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

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

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

func (d *GetOsVersionDescriptor) GetMethodName() string {
	return "GetOsVersion"
}

func (d *GetOsVersionDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/GetOsVersion"
}

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

func (d *GetOsVersionDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *GetOsVersionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *GetOsVersionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *GetOsVersionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetOsVersionDescriptorClientMsgHandle{}
}

func (d *GetOsVersionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetOsVersionDescriptorServerMsgHandle{}
}

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

func (h *GetOsVersionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetOsVersionRequest) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetOsVersionDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *GetOsVersionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetOsVersionRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetOsVersionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetOsVersionRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetOsVersionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*os_version.OsVersion)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*os_version.OsVersion) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *GetOsVersionDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *GetOsVersionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*os_version.OsVersion)
}

func (h *GetOsVersionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*os_version.OsVersion)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*os_version.OsVersion) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetOsVersionDescriptor() *GetOsVersionDescriptor {
	return getOsVersionDescriptor
}

type BatchGetOsVersionsDescriptor struct{}

type BatchGetOsVersionsDescriptorClientMsgHandle struct{}

type BatchGetOsVersionsDescriptorServerMsgHandle struct{}

func (d *BatchGetOsVersionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetOsVersionsRequest{}
}

func (d *BatchGetOsVersionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetOsVersionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetOsVersionsDescriptor) GetMethodName() string {
	return "BatchGetOsVersions"
}

func (d *BatchGetOsVersionsDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/BatchGetOsVersions"
}

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

func (d *BatchGetOsVersionsDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *BatchGetOsVersionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *BatchGetOsVersionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *BatchGetOsVersionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetOsVersionsDescriptorClientMsgHandle{}
}

func (d *BatchGetOsVersionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetOsVersionsDescriptorServerMsgHandle{}
}

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

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

func (h *BatchGetOsVersionsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *BatchGetOsVersionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetOsVersionsRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetOsVersionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetOsVersionsRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *BatchGetOsVersionsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *BatchGetOsVersionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetOsVersionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetOsVersionsResponse) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetOsVersionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetOsVersionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetOsVersionsResponse) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetOsVersions(); len(resources) > 0 {
			return os_version.OsVersionList(resources)
		}
	}
	return (os_version.OsVersionList)(nil)
}

func GetBatchGetOsVersionsDescriptor() *BatchGetOsVersionsDescriptor {
	return batchGetOsVersionsDescriptor
}

type ListOsVersionsDescriptor struct{}

type ListOsVersionsDescriptorClientMsgHandle struct{}

type ListOsVersionsDescriptorServerMsgHandle struct{}

func (d *ListOsVersionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListOsVersionsRequest{}
}

func (d *ListOsVersionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListOsVersionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListOsVersionsDescriptor) GetMethodName() string {
	return "ListOsVersions"
}

func (d *ListOsVersionsDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/ListOsVersions"
}

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

func (d *ListOsVersionsDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *ListOsVersionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *ListOsVersionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *ListOsVersionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListOsVersionsDescriptorClientMsgHandle{}
}

func (d *ListOsVersionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListOsVersionsDescriptorServerMsgHandle{}
}

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

func (h *ListOsVersionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListOsVersionsRequest) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *ListOsVersionsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListOsVersionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListOsVersionsRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListOsVersionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListOsVersionsRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *ListOsVersionsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *ListOsVersionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListOsVersionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListOsVersionsResponse) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListOsVersionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListOsVersionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListOsVersionsResponse) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetOsVersions(); len(resources) > 0 {
			return os_version.OsVersionList(resources)
		}
	}
	return (os_version.OsVersionList)(nil)
}

func GetListOsVersionsDescriptor() *ListOsVersionsDescriptor {
	return listOsVersionsDescriptor
}

type WatchOsVersionDescriptor struct{}

type WatchOsVersionDescriptorClientMsgHandle struct{}

type WatchOsVersionDescriptorServerMsgHandle struct{}

func (d *WatchOsVersionDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchOsVersionRequest{}
}

func (d *WatchOsVersionDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchOsVersionResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchOsVersionDescriptor) GetMethodName() string {
	return "WatchOsVersion"
}

func (d *WatchOsVersionDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/WatchOsVersion"
}

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

func (d *WatchOsVersionDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *WatchOsVersionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *WatchOsVersionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *WatchOsVersionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchOsVersionDescriptorClientMsgHandle{}
}

func (d *WatchOsVersionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchOsVersionDescriptorServerMsgHandle{}
}

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

func (h *WatchOsVersionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchOsVersionRequest) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchOsVersionDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchOsVersionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchOsVersionRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchOsVersionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchOsVersionRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchOsVersionDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchOsVersionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchOsVersionResponse) *os_version.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *os_version.OsVersionChange_Added_:
				return tResChange.Added.GetOsVersion().GetName()
			case *os_version.OsVersionChange_Modified_:
				return tResChange.Modified.GetName()
			case *os_version.OsVersionChange_Removed_:
				return tResChange.Removed.GetName()
			case *os_version.OsVersionChange_Current_:
				return tResChange.Current.GetOsVersion().GetName()
			}
		}
	}
	return (*os_version.Name)(nil)
}

func (h *WatchOsVersionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchOsVersionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchOsVersionResponse) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchOsVersionDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchOsVersionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchOsVersionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchOsVersionResponse) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *os_version.OsVersionChange_Added_:
				return tResChange.Added.GetOsVersion()
			case *os_version.OsVersionChange_Modified_:
				return tResChange.Modified.GetOsVersion()
			case *os_version.OsVersionChange_Current_:
				return tResChange.Current.GetOsVersion()
			}
		}
	}
	return (*os_version.OsVersion)(nil)
}

func (h *WatchOsVersionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchOsVersionResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchOsVersionResponse) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchOsVersionDescriptor() *WatchOsVersionDescriptor {
	return watchOsVersionDescriptor
}

type WatchOsVersionsDescriptor struct{}

type WatchOsVersionsDescriptorClientMsgHandle struct{}

type WatchOsVersionsDescriptorServerMsgHandle struct{}

func (d *WatchOsVersionsDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchOsVersionsRequest{}
}

func (d *WatchOsVersionsDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchOsVersionsResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchOsVersionsDescriptor) GetMethodName() string {
	return "WatchOsVersions"
}

func (d *WatchOsVersionsDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/WatchOsVersions"
}

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

func (d *WatchOsVersionsDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *WatchOsVersionsDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *WatchOsVersionsDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *WatchOsVersionsDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchOsVersionsDescriptorClientMsgHandle{}
}

func (d *WatchOsVersionsDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchOsVersionsDescriptorServerMsgHandle{}
}

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

func (h *WatchOsVersionsDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchOsVersionsRequest) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *WatchOsVersionsDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchOsVersionsDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchOsVersionsRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchOsVersionsDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchOsVersionsRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchOsVersionsRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchOsVersionsDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchOsVersionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchOsVersionsResponse) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetOsVersionChanges(); len(resChanges) > 0 {
			list := make(os_version.OsVersionNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *os_version.OsVersionChange_Added_:
					list = append(list, tResChange.Added.GetOsVersion().GetName())
				case *os_version.OsVersionChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *os_version.OsVersionChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *os_version.OsVersionChange_Current_:
					list = append(list, tResChange.Current.GetOsVersion().GetName())
				}
			}
			return list
		}
	}
	return (os_version.OsVersionNameList)(nil)
}

func (h *WatchOsVersionsDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *WatchOsVersionsDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchOsVersionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchOsVersionsResponse) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchOsVersionsDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchOsVersionsResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchOsVersionsResponse) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetOsVersionChanges(); len(resChanges) > 0 {
			list := make(os_version.OsVersionList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *os_version.OsVersionChange_Added_:
					list = append(list, tResChange.Added.GetOsVersion())
				case *os_version.OsVersionChange_Modified_:
					list = append(list, tResChange.Modified.GetOsVersion())
				case *os_version.OsVersionChange_Current_:
					list = append(list, tResChange.Current.GetOsVersion())
				}
			}
			return list
		}
	}
	return (os_version.OsVersionList)(nil)
}

func GetWatchOsVersionsDescriptor() *WatchOsVersionsDescriptor {
	return watchOsVersionsDescriptor
}

type CreateOsVersionDescriptor struct{}

type CreateOsVersionDescriptorClientMsgHandle struct{}

type CreateOsVersionDescriptorServerMsgHandle struct{}

func (d *CreateOsVersionDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateOsVersionRequest{}
}

func (d *CreateOsVersionDescriptor) NewEmptyServerMsg() proto.Message {
	return &os_version.OsVersion{}
}

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

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

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

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

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

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

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

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

func (d *CreateOsVersionDescriptor) GetMethodName() string {
	return "CreateOsVersion"
}

func (d *CreateOsVersionDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/CreateOsVersion"
}

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

func (d *CreateOsVersionDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *CreateOsVersionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *CreateOsVersionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *CreateOsVersionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateOsVersionDescriptorClientMsgHandle{}
}

func (d *CreateOsVersionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateOsVersionDescriptorServerMsgHandle{}
}

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

func (h *CreateOsVersionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateOsVersionRequest) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateOsVersionDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *CreateOsVersionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateOsVersionRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetOsVersion()
	}
	return (*os_version.OsVersion)(nil)
}

func (h *CreateOsVersionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateOsVersionRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateOsVersionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*os_version.OsVersion)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*os_version.OsVersion) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *CreateOsVersionDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *CreateOsVersionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*os_version.OsVersion)
}

func (h *CreateOsVersionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*os_version.OsVersion)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*os_version.OsVersion) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateOsVersionDescriptor() *CreateOsVersionDescriptor {
	return createOsVersionDescriptor
}

type UpdateOsVersionDescriptor struct{}

type UpdateOsVersionDescriptorClientMsgHandle struct{}

type UpdateOsVersionDescriptorServerMsgHandle struct{}

func (d *UpdateOsVersionDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateOsVersionRequest{}
}

func (d *UpdateOsVersionDescriptor) NewEmptyServerMsg() proto.Message {
	return &os_version.OsVersion{}
}

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

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

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

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

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

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

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

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

func (d *UpdateOsVersionDescriptor) GetMethodName() string {
	return "UpdateOsVersion"
}

func (d *UpdateOsVersionDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/UpdateOsVersion"
}

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

func (d *UpdateOsVersionDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *UpdateOsVersionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *UpdateOsVersionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *UpdateOsVersionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateOsVersionDescriptorClientMsgHandle{}
}

func (d *UpdateOsVersionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateOsVersionDescriptorServerMsgHandle{}
}

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

func (h *UpdateOsVersionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateOsVersionRequest) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *UpdateOsVersionDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *UpdateOsVersionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateOsVersionRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetOsVersion()
	}
	return (*os_version.OsVersion)(nil)
}

func (h *UpdateOsVersionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateOsVersionRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateOsVersionDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*os_version.OsVersion)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*os_version.OsVersion) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *UpdateOsVersionDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *UpdateOsVersionDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*os_version.OsVersion)
}

func (h *UpdateOsVersionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*os_version.OsVersion)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*os_version.OsVersion) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateOsVersionDescriptor() *UpdateOsVersionDescriptor {
	return updateOsVersionDescriptor
}

type DeleteOsVersionDescriptor struct{}

type DeleteOsVersionDescriptorClientMsgHandle struct{}

type DeleteOsVersionDescriptorServerMsgHandle struct{}

func (d *DeleteOsVersionDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteOsVersionRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteOsVersionDescriptor) GetMethodName() string {
	return "DeleteOsVersion"
}

func (d *DeleteOsVersionDescriptor) GetFullMethodName() string {
	return "/ntt.devices.v1.OsVersionService/DeleteOsVersion"
}

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

func (d *DeleteOsVersionDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func (d *DeleteOsVersionDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return osVersionServiceDescriptor
}

func (d *DeleteOsVersionDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return os_version.GetDescriptor()
}

func (d *DeleteOsVersionDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteOsVersionDescriptorClientMsgHandle{}
}

func (d *DeleteOsVersionDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteOsVersionDescriptorServerMsgHandle{}
}

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

func (h *DeleteOsVersionDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteOsVersionRequest) []*os_version.Name
	})
	if ok {
		return os_version.OsVersionNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

func (h *DeleteOsVersionDescriptorClientMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

func (h *DeleteOsVersionDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteOsVersionRequest) *os_version.OsVersion
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteOsVersionDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteOsVersionRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteOsVersionRequest) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

func (h *DeleteOsVersionDescriptorServerMsgHandle) ExtractCollectionName(msg proto.Message) gotenresource.Name {
	return nil
}

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

func (h *DeleteOsVersionDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*os_version.OsVersion
	})
	if ok {
		return os_version.OsVersionList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteOsVersionDescriptor() *DeleteOsVersionDescriptor {
	return deleteOsVersionDescriptor
}

type OsVersionServiceDescriptor struct{}

func (d *OsVersionServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getOsVersionDescriptor,
		batchGetOsVersionsDescriptor,
		listOsVersionsDescriptor,
		watchOsVersionDescriptor,
		watchOsVersionsDescriptor,
		createOsVersionDescriptor,
		updateOsVersionDescriptor,
		deleteOsVersionDescriptor,
	}
}

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

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

func (d *OsVersionServiceDescriptor) GetApiName() string {
	return "OsVersionService"
}

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

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

func GetOsVersionServiceDescriptor() *OsVersionServiceDescriptor {
	return osVersionServiceDescriptor
}

func initDescriptors() {
	osVersionServiceDescriptor = &OsVersionServiceDescriptor{}
	getOsVersionDescriptor = &GetOsVersionDescriptor{}
	batchGetOsVersionsDescriptor = &BatchGetOsVersionsDescriptor{}
	listOsVersionsDescriptor = &ListOsVersionsDescriptor{}
	watchOsVersionDescriptor = &WatchOsVersionDescriptor{}
	watchOsVersionsDescriptor = &WatchOsVersionsDescriptor{}
	createOsVersionDescriptor = &CreateOsVersionDescriptor{}
	updateOsVersionDescriptor = &UpdateOsVersionDescriptor{}
	deleteOsVersionDescriptor = &DeleteOsVersionDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(osVersionServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getOsVersionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetOsVersionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listOsVersionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchOsVersionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchOsVersionsDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createOsVersionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateOsVersionDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteOsVersionDescriptor)
}

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