github.com/cloudwan/edgelq-sdk@v1.15.4/secrets/client/v1/crypto_key/crypto_key_service.pb.descriptors.go

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

package crypto_key_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 (
	crypto_key "github.com/cloudwan/edgelq-sdk/secrets/resources/v1/crypto_key"
	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 (
	_ = &crypto_key.CryptoKey{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized       bool
	cryptoKeyServiceDescriptor   *CryptoKeyServiceDescriptor
	getCryptoKeyDescriptor       *GetCryptoKeyDescriptor
	batchGetCryptoKeysDescriptor *BatchGetCryptoKeysDescriptor
	listCryptoKeysDescriptor     *ListCryptoKeysDescriptor
	watchCryptoKeyDescriptor     *WatchCryptoKeyDescriptor
	watchCryptoKeysDescriptor    *WatchCryptoKeysDescriptor
	deleteCryptoKeyDescriptor    *DeleteCryptoKeyDescriptor
)

type GetCryptoKeyDescriptor struct{}

type GetCryptoKeyDescriptorClientMsgHandle struct{}

type GetCryptoKeyDescriptorServerMsgHandle struct{}

func (d *GetCryptoKeyDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetCryptoKeyRequest{}
}

func (d *GetCryptoKeyDescriptor) NewEmptyServerMsg() proto.Message {
	return &crypto_key.CryptoKey{}
}

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

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

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

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

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

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

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

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

func (d *GetCryptoKeyDescriptor) GetMethodName() string {
	return "GetCryptoKey"
}

func (d *GetCryptoKeyDescriptor) GetFullMethodName() string {
	return "/ntt.secrets.v1.CryptoKeyService/GetCryptoKey"
}

func (d *GetCryptoKeyDescriptor) GetProtoPkgName() string {
	return "ntt.secrets.v1"
}

func (d *GetCryptoKeyDescriptor) GetApiName() string {
	return "CryptoKeyService"
}

func (d *GetCryptoKeyDescriptor) GetServiceDomain() string {
	return "secrets.edgelq.com"
}

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

func (d *GetCryptoKeyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return cryptoKeyServiceDescriptor
}

func (d *GetCryptoKeyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return crypto_key.GetDescriptor()
}

func (d *GetCryptoKeyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetCryptoKeyDescriptorClientMsgHandle{}
}

func (d *GetCryptoKeyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetCryptoKeyDescriptorServerMsgHandle{}
}

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

func (h *GetCryptoKeyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetCryptoKeyRequest) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetCryptoKeyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetCryptoKeyRequest) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetCryptoKeyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetCryptoKeyRequest) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetCryptoKeyDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*crypto_key.CryptoKey)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*crypto_key.CryptoKey) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetCryptoKeyDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*crypto_key.CryptoKey)
}

func (h *GetCryptoKeyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*crypto_key.CryptoKey)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*crypto_key.CryptoKey) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetCryptoKeyDescriptor() *GetCryptoKeyDescriptor {
	return getCryptoKeyDescriptor
}

type BatchGetCryptoKeysDescriptor struct{}

type BatchGetCryptoKeysDescriptorClientMsgHandle struct{}

type BatchGetCryptoKeysDescriptorServerMsgHandle struct{}

func (d *BatchGetCryptoKeysDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetCryptoKeysRequest{}
}

func (d *BatchGetCryptoKeysDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetCryptoKeysResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetCryptoKeysDescriptor) GetMethodName() string {
	return "BatchGetCryptoKeys"
}

func (d *BatchGetCryptoKeysDescriptor) GetFullMethodName() string {
	return "/ntt.secrets.v1.CryptoKeyService/BatchGetCryptoKeys"
}

func (d *BatchGetCryptoKeysDescriptor) GetProtoPkgName() string {
	return "ntt.secrets.v1"
}

func (d *BatchGetCryptoKeysDescriptor) GetApiName() string {
	return "CryptoKeyService"
}

func (d *BatchGetCryptoKeysDescriptor) GetServiceDomain() string {
	return "secrets.edgelq.com"
}

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

func (d *BatchGetCryptoKeysDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return cryptoKeyServiceDescriptor
}

func (d *BatchGetCryptoKeysDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return crypto_key.GetDescriptor()
}

func (d *BatchGetCryptoKeysDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetCryptoKeysDescriptorClientMsgHandle{}
}

func (d *BatchGetCryptoKeysDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetCryptoKeysDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetCryptoKeysDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetCryptoKeysRequest) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetCryptoKeysDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetCryptoKeysRequest) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetCryptoKeysDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetCryptoKeysResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetCryptoKeysResponse) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetCryptoKeysDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetCryptoKeysResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetCryptoKeysResponse) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetCryptoKeys(); len(resources) > 0 {
			return crypto_key.CryptoKeyList(resources)
		}
	}
	return (crypto_key.CryptoKeyList)(nil)
}

func GetBatchGetCryptoKeysDescriptor() *BatchGetCryptoKeysDescriptor {
	return batchGetCryptoKeysDescriptor
}

type ListCryptoKeysDescriptor struct{}

type ListCryptoKeysDescriptorClientMsgHandle struct{}

type ListCryptoKeysDescriptorServerMsgHandle struct{}

func (d *ListCryptoKeysDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListCryptoKeysRequest{}
}

func (d *ListCryptoKeysDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListCryptoKeysResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListCryptoKeysDescriptor) GetMethodName() string {
	return "ListCryptoKeys"
}

func (d *ListCryptoKeysDescriptor) GetFullMethodName() string {
	return "/ntt.secrets.v1.CryptoKeyService/ListCryptoKeys"
}

func (d *ListCryptoKeysDescriptor) GetProtoPkgName() string {
	return "ntt.secrets.v1"
}

func (d *ListCryptoKeysDescriptor) GetApiName() string {
	return "CryptoKeyService"
}

func (d *ListCryptoKeysDescriptor) GetServiceDomain() string {
	return "secrets.edgelq.com"
}

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

func (d *ListCryptoKeysDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return cryptoKeyServiceDescriptor
}

func (d *ListCryptoKeysDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return crypto_key.GetDescriptor()
}

func (d *ListCryptoKeysDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListCryptoKeysDescriptorClientMsgHandle{}
}

func (d *ListCryptoKeysDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListCryptoKeysDescriptorServerMsgHandle{}
}

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

func (h *ListCryptoKeysDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListCryptoKeysRequest) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListCryptoKeysDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListCryptoKeysRequest) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListCryptoKeysDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListCryptoKeysRequest) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListCryptoKeysDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListCryptoKeysResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListCryptoKeysResponse) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListCryptoKeysDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListCryptoKeysResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListCryptoKeysResponse) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetCryptoKeys(); len(resources) > 0 {
			return crypto_key.CryptoKeyList(resources)
		}
	}
	return (crypto_key.CryptoKeyList)(nil)
}

func GetListCryptoKeysDescriptor() *ListCryptoKeysDescriptor {
	return listCryptoKeysDescriptor
}

type WatchCryptoKeyDescriptor struct{}

type WatchCryptoKeyDescriptorClientMsgHandle struct{}

type WatchCryptoKeyDescriptorServerMsgHandle struct{}

func (d *WatchCryptoKeyDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchCryptoKeyRequest{}
}

func (d *WatchCryptoKeyDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchCryptoKeyResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchCryptoKeyDescriptor) GetMethodName() string {
	return "WatchCryptoKey"
}

func (d *WatchCryptoKeyDescriptor) GetFullMethodName() string {
	return "/ntt.secrets.v1.CryptoKeyService/WatchCryptoKey"
}

func (d *WatchCryptoKeyDescriptor) GetProtoPkgName() string {
	return "ntt.secrets.v1"
}

func (d *WatchCryptoKeyDescriptor) GetApiName() string {
	return "CryptoKeyService"
}

func (d *WatchCryptoKeyDescriptor) GetServiceDomain() string {
	return "secrets.edgelq.com"
}

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

func (d *WatchCryptoKeyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return cryptoKeyServiceDescriptor
}

func (d *WatchCryptoKeyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return crypto_key.GetDescriptor()
}

func (d *WatchCryptoKeyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchCryptoKeyDescriptorClientMsgHandle{}
}

func (d *WatchCryptoKeyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchCryptoKeyDescriptorServerMsgHandle{}
}

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

func (h *WatchCryptoKeyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchCryptoKeyRequest) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchCryptoKeyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchCryptoKeyRequest) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchCryptoKeyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchCryptoKeyRequest) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchCryptoKeyDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchCryptoKeyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchCryptoKeyResponse) *crypto_key.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *crypto_key.CryptoKeyChange_Added_:
				return tResChange.Added.GetCryptoKey().GetName()
			case *crypto_key.CryptoKeyChange_Modified_:
				return tResChange.Modified.GetName()
			case *crypto_key.CryptoKeyChange_Removed_:
				return tResChange.Removed.GetName()
			case *crypto_key.CryptoKeyChange_Current_:
				return tResChange.Current.GetCryptoKey().GetName()
			}
		}
	}
	return (*crypto_key.Name)(nil)
}

func (h *WatchCryptoKeyDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchCryptoKeyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchCryptoKeyResponse) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchCryptoKeyDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchCryptoKeyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchCryptoKeyResponse) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *crypto_key.CryptoKeyChange_Added_:
				return tResChange.Added.GetCryptoKey()
			case *crypto_key.CryptoKeyChange_Modified_:
				return tResChange.Modified.GetCryptoKey()
			case *crypto_key.CryptoKeyChange_Current_:
				return tResChange.Current.GetCryptoKey()
			}
		}
	}
	return (*crypto_key.CryptoKey)(nil)
}

func (h *WatchCryptoKeyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchCryptoKeyResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchCryptoKeyResponse) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchCryptoKeyDescriptor() *WatchCryptoKeyDescriptor {
	return watchCryptoKeyDescriptor
}

type WatchCryptoKeysDescriptor struct{}

type WatchCryptoKeysDescriptorClientMsgHandle struct{}

type WatchCryptoKeysDescriptorServerMsgHandle struct{}

func (d *WatchCryptoKeysDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchCryptoKeysRequest{}
}

func (d *WatchCryptoKeysDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchCryptoKeysResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchCryptoKeysDescriptor) GetMethodName() string {
	return "WatchCryptoKeys"
}

func (d *WatchCryptoKeysDescriptor) GetFullMethodName() string {
	return "/ntt.secrets.v1.CryptoKeyService/WatchCryptoKeys"
}

func (d *WatchCryptoKeysDescriptor) GetProtoPkgName() string {
	return "ntt.secrets.v1"
}

func (d *WatchCryptoKeysDescriptor) GetApiName() string {
	return "CryptoKeyService"
}

func (d *WatchCryptoKeysDescriptor) GetServiceDomain() string {
	return "secrets.edgelq.com"
}

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

func (d *WatchCryptoKeysDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return cryptoKeyServiceDescriptor
}

func (d *WatchCryptoKeysDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return crypto_key.GetDescriptor()
}

func (d *WatchCryptoKeysDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchCryptoKeysDescriptorClientMsgHandle{}
}

func (d *WatchCryptoKeysDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchCryptoKeysDescriptorServerMsgHandle{}
}

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

func (h *WatchCryptoKeysDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchCryptoKeysRequest) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchCryptoKeysDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchCryptoKeysRequest) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchCryptoKeysDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchCryptoKeysRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchCryptoKeysRequest) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchCryptoKeysDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchCryptoKeysResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchCryptoKeysResponse) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetCryptoKeyChanges(); len(resChanges) > 0 {
			list := make(crypto_key.CryptoKeyNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *crypto_key.CryptoKeyChange_Added_:
					list = append(list, tResChange.Added.GetCryptoKey().GetName())
				case *crypto_key.CryptoKeyChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *crypto_key.CryptoKeyChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *crypto_key.CryptoKeyChange_Current_:
					list = append(list, tResChange.Current.GetCryptoKey().GetName())
				}
			}
			return list
		}
	}
	return (crypto_key.CryptoKeyNameList)(nil)
}

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

func (h *WatchCryptoKeysDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchCryptoKeysResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchCryptoKeysResponse) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchCryptoKeysDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchCryptoKeysResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchCryptoKeysResponse) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetCryptoKeyChanges(); len(resChanges) > 0 {
			list := make(crypto_key.CryptoKeyList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *crypto_key.CryptoKeyChange_Added_:
					list = append(list, tResChange.Added.GetCryptoKey())
				case *crypto_key.CryptoKeyChange_Modified_:
					list = append(list, tResChange.Modified.GetCryptoKey())
				case *crypto_key.CryptoKeyChange_Current_:
					list = append(list, tResChange.Current.GetCryptoKey())
				}
			}
			return list
		}
	}
	return (crypto_key.CryptoKeyList)(nil)
}

func GetWatchCryptoKeysDescriptor() *WatchCryptoKeysDescriptor {
	return watchCryptoKeysDescriptor
}

type DeleteCryptoKeyDescriptor struct{}

type DeleteCryptoKeyDescriptorClientMsgHandle struct{}

type DeleteCryptoKeyDescriptorServerMsgHandle struct{}

func (d *DeleteCryptoKeyDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteCryptoKeyRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteCryptoKeyDescriptor) GetMethodName() string {
	return "DeleteCryptoKey"
}

func (d *DeleteCryptoKeyDescriptor) GetFullMethodName() string {
	return "/ntt.secrets.v1.CryptoKeyService/DeleteCryptoKey"
}

func (d *DeleteCryptoKeyDescriptor) GetProtoPkgName() string {
	return "ntt.secrets.v1"
}

func (d *DeleteCryptoKeyDescriptor) GetApiName() string {
	return "CryptoKeyService"
}

func (d *DeleteCryptoKeyDescriptor) GetServiceDomain() string {
	return "secrets.edgelq.com"
}

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

func (d *DeleteCryptoKeyDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return cryptoKeyServiceDescriptor
}

func (d *DeleteCryptoKeyDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return crypto_key.GetDescriptor()
}

func (d *DeleteCryptoKeyDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteCryptoKeyDescriptorClientMsgHandle{}
}

func (d *DeleteCryptoKeyDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteCryptoKeyDescriptorServerMsgHandle{}
}

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

func (h *DeleteCryptoKeyDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteCryptoKeyRequest) []*crypto_key.Name
	})
	if ok {
		return crypto_key.CryptoKeyNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteCryptoKeyDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteCryptoKeyRequest) *crypto_key.CryptoKey
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteCryptoKeyDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteCryptoKeyRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteCryptoKeyRequest) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteCryptoKeyDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*crypto_key.CryptoKey
	})
	if ok {
		return crypto_key.CryptoKeyList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteCryptoKeyDescriptor() *DeleteCryptoKeyDescriptor {
	return deleteCryptoKeyDescriptor
}

type CryptoKeyServiceDescriptor struct{}

func (d *CryptoKeyServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getCryptoKeyDescriptor,
		batchGetCryptoKeysDescriptor,
		listCryptoKeysDescriptor,
		watchCryptoKeyDescriptor,
		watchCryptoKeysDescriptor,
		deleteCryptoKeyDescriptor,
	}
}

func (d *CryptoKeyServiceDescriptor) GetFullAPIName() string {
	return "/ntt.secrets.v1.CryptoKeyService"
}

func (d *CryptoKeyServiceDescriptor) GetProtoPkgName() string {
	return "ntt.secrets.v1"
}

func (d *CryptoKeyServiceDescriptor) GetApiName() string {
	return "CryptoKeyService"
}

func (d *CryptoKeyServiceDescriptor) GetServiceDomain() string {
	return "secrets.edgelq.com"
}

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

func GetCryptoKeyServiceDescriptor() *CryptoKeyServiceDescriptor {
	return cryptoKeyServiceDescriptor
}

func initDescriptors() {
	cryptoKeyServiceDescriptor = &CryptoKeyServiceDescriptor{}
	getCryptoKeyDescriptor = &GetCryptoKeyDescriptor{}
	batchGetCryptoKeysDescriptor = &BatchGetCryptoKeysDescriptor{}
	listCryptoKeysDescriptor = &ListCryptoKeysDescriptor{}
	watchCryptoKeyDescriptor = &WatchCryptoKeyDescriptor{}
	watchCryptoKeysDescriptor = &WatchCryptoKeysDescriptor{}
	deleteCryptoKeyDescriptor = &DeleteCryptoKeyDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(cryptoKeyServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getCryptoKeyDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetCryptoKeysDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listCryptoKeysDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchCryptoKeyDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchCryptoKeysDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteCryptoKeyDescriptor)
}

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