hardware_service.pb.descriptors.go

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

package hardware_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 (
	hardware "github.com/cloudwan/edgelq-sdk/ztp/resources/v1/hardware"
	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 (
	_ = &hardware.Hardware{}
	_ = &emptypb.Empty{}
)

var (
	descriptorsInitialized      bool
	hardwareServiceDescriptor   *HardwareServiceDescriptor
	getHardwareDescriptor       *GetHardwareDescriptor
	batchGetHardwaresDescriptor *BatchGetHardwaresDescriptor
	listHardwaresDescriptor     *ListHardwaresDescriptor
	watchHardwareDescriptor     *WatchHardwareDescriptor
	watchHardwaresDescriptor    *WatchHardwaresDescriptor
	createHardwareDescriptor    *CreateHardwareDescriptor
	updateHardwareDescriptor    *UpdateHardwareDescriptor
	deleteHardwareDescriptor    *DeleteHardwareDescriptor
)

type GetHardwareDescriptor struct{}

type GetHardwareDescriptorClientMsgHandle struct{}

type GetHardwareDescriptorServerMsgHandle struct{}

func (d *GetHardwareDescriptor) NewEmptyClientMsg() proto.Message {
	return &GetHardwareRequest{}
}

func (d *GetHardwareDescriptor) NewEmptyServerMsg() proto.Message {
	return &hardware.Hardware{}
}

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

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

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

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

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

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

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

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

func (d *GetHardwareDescriptor) GetMethodName() string {
	return "GetHardware"
}

func (d *GetHardwareDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/GetHardware"
}

func (d *GetHardwareDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *GetHardwareDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *GetHardwareDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *GetHardwareDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *GetHardwareDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *GetHardwareDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetHardwareDescriptorClientMsgHandle{}
}

func (d *GetHardwareDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &GetHardwareDescriptorServerMsgHandle{}
}

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

func (h *GetHardwareDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*GetHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*GetHardwareRequest) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetHardwareDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*GetHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*GetHardwareRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *GetHardwareDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*GetHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*GetHardwareRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *GetHardwareDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*hardware.Hardware)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*hardware.Hardware) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *GetHardwareDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*hardware.Hardware)
}

func (h *GetHardwareDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*hardware.Hardware)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*hardware.Hardware) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetGetHardwareDescriptor() *GetHardwareDescriptor {
	return getHardwareDescriptor
}

type BatchGetHardwaresDescriptor struct{}

type BatchGetHardwaresDescriptorClientMsgHandle struct{}

type BatchGetHardwaresDescriptorServerMsgHandle struct{}

func (d *BatchGetHardwaresDescriptor) NewEmptyClientMsg() proto.Message {
	return &BatchGetHardwaresRequest{}
}

func (d *BatchGetHardwaresDescriptor) NewEmptyServerMsg() proto.Message {
	return &BatchGetHardwaresResponse{}
}

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

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

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

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

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

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

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

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

func (d *BatchGetHardwaresDescriptor) GetMethodName() string {
	return "BatchGetHardwares"
}

func (d *BatchGetHardwaresDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/BatchGetHardwares"
}

func (d *BatchGetHardwaresDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *BatchGetHardwaresDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *BatchGetHardwaresDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *BatchGetHardwaresDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *BatchGetHardwaresDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *BatchGetHardwaresDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetHardwaresDescriptorClientMsgHandle{}
}

func (d *BatchGetHardwaresDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &BatchGetHardwaresDescriptorServerMsgHandle{}
}

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

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

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

func (h *BatchGetHardwaresDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetHardwaresRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetHardwaresDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetHardwaresRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *BatchGetHardwaresDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*BatchGetHardwaresResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*BatchGetHardwaresResponse) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *BatchGetHardwaresDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*BatchGetHardwaresResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*BatchGetHardwaresResponse) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetHardwares(); len(resources) > 0 {
			return hardware.HardwareList(resources)
		}
	}
	return (hardware.HardwareList)(nil)
}

func GetBatchGetHardwaresDescriptor() *BatchGetHardwaresDescriptor {
	return batchGetHardwaresDescriptor
}

type ListHardwaresDescriptor struct{}

type ListHardwaresDescriptorClientMsgHandle struct{}

type ListHardwaresDescriptorServerMsgHandle struct{}

func (d *ListHardwaresDescriptor) NewEmptyClientMsg() proto.Message {
	return &ListHardwaresRequest{}
}

func (d *ListHardwaresDescriptor) NewEmptyServerMsg() proto.Message {
	return &ListHardwaresResponse{}
}

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

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

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

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

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

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

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

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

func (d *ListHardwaresDescriptor) GetMethodName() string {
	return "ListHardwares"
}

func (d *ListHardwaresDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/ListHardwares"
}

func (d *ListHardwaresDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *ListHardwaresDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *ListHardwaresDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *ListHardwaresDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *ListHardwaresDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *ListHardwaresDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListHardwaresDescriptorClientMsgHandle{}
}

func (d *ListHardwaresDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &ListHardwaresDescriptorServerMsgHandle{}
}

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

func (h *ListHardwaresDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*ListHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*ListHardwaresRequest) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *ListHardwaresDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListHardwaresRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListHardwaresDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListHardwaresRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

func (h *ListHardwaresDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*ListHardwaresResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*ListHardwaresResponse) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *ListHardwaresDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*ListHardwaresResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*ListHardwaresResponse) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resources := typedMsg.GetHardwares(); len(resources) > 0 {
			return hardware.HardwareList(resources)
		}
	}
	return (hardware.HardwareList)(nil)
}

func GetListHardwaresDescriptor() *ListHardwaresDescriptor {
	return listHardwaresDescriptor
}

type WatchHardwareDescriptor struct{}

type WatchHardwareDescriptorClientMsgHandle struct{}

type WatchHardwareDescriptorServerMsgHandle struct{}

func (d *WatchHardwareDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchHardwareRequest{}
}

func (d *WatchHardwareDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchHardwareResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchHardwareDescriptor) GetMethodName() string {
	return "WatchHardware"
}

func (d *WatchHardwareDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/WatchHardware"
}

func (d *WatchHardwareDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *WatchHardwareDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *WatchHardwareDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *WatchHardwareDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *WatchHardwareDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *WatchHardwareDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchHardwareDescriptorClientMsgHandle{}
}

func (d *WatchHardwareDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchHardwareDescriptorServerMsgHandle{}
}

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

func (h *WatchHardwareDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchHardwareRequest) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchHardwareDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchHardwareRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchHardwareDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchHardwareRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func (h *WatchHardwareDescriptorServerMsgHandle) ExtractResourceName(msg proto.Message) gotenresource.Name {
	typedMsg := msg.(*WatchHardwareResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceName(*WatchHardwareResponse) *hardware.Name
	})
	if ok {
		return override.OverrideExtractResourceName(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *hardware.HardwareChange_Added_:
				return tResChange.Added.GetHardware().GetName()
			case *hardware.HardwareChange_Modified_:
				return tResChange.Modified.GetName()
			case *hardware.HardwareChange_Removed_:
				return tResChange.Removed.GetName()
			case *hardware.HardwareChange_Current_:
				return tResChange.Current.GetHardware().GetName()
			}
		}
	}
	return (*hardware.Name)(nil)
}

func (h *WatchHardwareDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchHardwareResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchHardwareResponse) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchHardwareDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchHardwareResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchHardwareResponse) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		if resChange := typedMsg.GetChange(); resChange != nil {
			switch tResChange := resChange.ChangeType.(type) {
			case *hardware.HardwareChange_Added_:
				return tResChange.Added.GetHardware()
			case *hardware.HardwareChange_Modified_:
				return tResChange.Modified.GetHardware()
			case *hardware.HardwareChange_Current_:
				return tResChange.Current.GetHardware()
			}
		}
	}
	return (*hardware.Hardware)(nil)
}

func (h *WatchHardwareDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchHardwareResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchHardwareResponse) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetWatchHardwareDescriptor() *WatchHardwareDescriptor {
	return watchHardwareDescriptor
}

type WatchHardwaresDescriptor struct{}

type WatchHardwaresDescriptorClientMsgHandle struct{}

type WatchHardwaresDescriptorServerMsgHandle struct{}

func (d *WatchHardwaresDescriptor) NewEmptyClientMsg() proto.Message {
	return &WatchHardwaresRequest{}
}

func (d *WatchHardwaresDescriptor) NewEmptyServerMsg() proto.Message {
	return &WatchHardwaresResponse{}
}

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

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

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

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

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

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

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

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

func (d *WatchHardwaresDescriptor) GetMethodName() string {
	return "WatchHardwares"
}

func (d *WatchHardwaresDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/WatchHardwares"
}

func (d *WatchHardwaresDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *WatchHardwaresDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *WatchHardwaresDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *WatchHardwaresDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *WatchHardwaresDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *WatchHardwaresDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchHardwaresDescriptorClientMsgHandle{}
}

func (d *WatchHardwaresDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &WatchHardwaresDescriptorServerMsgHandle{}
}

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

func (h *WatchHardwaresDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchHardwaresRequest) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *WatchHardwaresDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchHardwaresRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchHardwaresDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchHardwaresRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchHardwaresRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *WatchHardwaresDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*WatchHardwaresResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*WatchHardwaresResponse) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	{
		if resChanges := typedMsg.GetHardwareChanges(); len(resChanges) > 0 {
			list := make(hardware.HardwareNameList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *hardware.HardwareChange_Added_:
					list = append(list, tResChange.Added.GetHardware().GetName())
				case *hardware.HardwareChange_Modified_:
					list = append(list, tResChange.Modified.GetName())
				case *hardware.HardwareChange_Removed_:
					list = append(list, tResChange.Removed.GetName())
				case *hardware.HardwareChange_Current_:
					list = append(list, tResChange.Current.GetHardware().GetName())
				}
			}
			return list
		}
	}
	return (hardware.HardwareNameList)(nil)
}

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

func (h *WatchHardwaresDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*WatchHardwaresResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*WatchHardwaresResponse) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *WatchHardwaresDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*WatchHardwaresResponse)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*WatchHardwaresResponse) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	{
		if resChanges := typedMsg.GetHardwareChanges(); len(resChanges) > 0 {
			list := make(hardware.HardwareList, 0, len(resChanges))
			for _, resChange := range resChanges {
				switch tResChange := resChange.ChangeType.(type) {
				case *hardware.HardwareChange_Added_:
					list = append(list, tResChange.Added.GetHardware())
				case *hardware.HardwareChange_Modified_:
					list = append(list, tResChange.Modified.GetHardware())
				case *hardware.HardwareChange_Current_:
					list = append(list, tResChange.Current.GetHardware())
				}
			}
			return list
		}
	}
	return (hardware.HardwareList)(nil)
}

func GetWatchHardwaresDescriptor() *WatchHardwaresDescriptor {
	return watchHardwaresDescriptor
}

type CreateHardwareDescriptor struct{}

type CreateHardwareDescriptorClientMsgHandle struct{}

type CreateHardwareDescriptorServerMsgHandle struct{}

func (d *CreateHardwareDescriptor) NewEmptyClientMsg() proto.Message {
	return &CreateHardwareRequest{}
}

func (d *CreateHardwareDescriptor) NewEmptyServerMsg() proto.Message {
	return &hardware.Hardware{}
}

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

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

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

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

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

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

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

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

func (d *CreateHardwareDescriptor) GetMethodName() string {
	return "CreateHardware"
}

func (d *CreateHardwareDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/CreateHardware"
}

func (d *CreateHardwareDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *CreateHardwareDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *CreateHardwareDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *CreateHardwareDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *CreateHardwareDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *CreateHardwareDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateHardwareDescriptorClientMsgHandle{}
}

func (d *CreateHardwareDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &CreateHardwareDescriptorServerMsgHandle{}
}

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

func (h *CreateHardwareDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*CreateHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*CreateHardwareRequest) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateHardwareDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*CreateHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*CreateHardwareRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetHardware()
	}
	return (*hardware.Hardware)(nil)
}

func (h *CreateHardwareDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*CreateHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*CreateHardwareRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *CreateHardwareDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*hardware.Hardware)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*hardware.Hardware) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *CreateHardwareDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*hardware.Hardware)
}

func (h *CreateHardwareDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*hardware.Hardware)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*hardware.Hardware) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetCreateHardwareDescriptor() *CreateHardwareDescriptor {
	return createHardwareDescriptor
}

type UpdateHardwareDescriptor struct{}

type UpdateHardwareDescriptorClientMsgHandle struct{}

type UpdateHardwareDescriptorServerMsgHandle struct{}

func (d *UpdateHardwareDescriptor) NewEmptyClientMsg() proto.Message {
	return &UpdateHardwareRequest{}
}

func (d *UpdateHardwareDescriptor) NewEmptyServerMsg() proto.Message {
	return &hardware.Hardware{}
}

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

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

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

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

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

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

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

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

func (d *UpdateHardwareDescriptor) GetMethodName() string {
	return "UpdateHardware"
}

func (d *UpdateHardwareDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/UpdateHardware"
}

func (d *UpdateHardwareDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *UpdateHardwareDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *UpdateHardwareDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *UpdateHardwareDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *UpdateHardwareDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *UpdateHardwareDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateHardwareDescriptorClientMsgHandle{}
}

func (d *UpdateHardwareDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &UpdateHardwareDescriptorServerMsgHandle{}
}

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

func (h *UpdateHardwareDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*UpdateHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*UpdateHardwareRequest) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateHardwareDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*UpdateHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*UpdateHardwareRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	{
		return typedMsg.GetHardware()
	}
	return (*hardware.Hardware)(nil)
}

func (h *UpdateHardwareDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*UpdateHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*UpdateHardwareRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

func (h *UpdateHardwareDescriptorServerMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*hardware.Hardware)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*hardware.Hardware) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *UpdateHardwareDescriptorServerMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	return msg.(*hardware.Hardware)
}

func (h *UpdateHardwareDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*hardware.Hardware)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*hardware.Hardware) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetUpdateHardwareDescriptor() *UpdateHardwareDescriptor {
	return updateHardwareDescriptor
}

type DeleteHardwareDescriptor struct{}

type DeleteHardwareDescriptorClientMsgHandle struct{}

type DeleteHardwareDescriptorServerMsgHandle struct{}

func (d *DeleteHardwareDescriptor) NewEmptyClientMsg() proto.Message {
	return &DeleteHardwareRequest{}
}

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

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

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

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

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

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

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

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

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

func (d *DeleteHardwareDescriptor) GetMethodName() string {
	return "DeleteHardware"
}

func (d *DeleteHardwareDescriptor) GetFullMethodName() string {
	return "/ntt.ztp.v1.HardwareService/DeleteHardware"
}

func (d *DeleteHardwareDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *DeleteHardwareDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *DeleteHardwareDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func (d *DeleteHardwareDescriptor) GetApiDescriptor() gotenclient.ApiDescriptor {
	return hardwareServiceDescriptor
}

func (d *DeleteHardwareDescriptor) GetResourceDescriptor() gotenresource.Descriptor {
	return hardware.GetDescriptor()
}

func (d *DeleteHardwareDescriptor) GetClientMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteHardwareDescriptorClientMsgHandle{}
}

func (d *DeleteHardwareDescriptor) GetServerMsgReflectHandle() gotenclient.MethodMsgHandle {
	return &DeleteHardwareDescriptorServerMsgHandle{}
}

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

func (h *DeleteHardwareDescriptorClientMsgHandle) ExtractResourceNames(msg proto.Message) gotenresource.NameList {
	typedMsg := msg.(*DeleteHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceNames(*DeleteHardwareRequest) []*hardware.Name
	})
	if ok {
		return hardware.HardwareNameList(override.OverrideExtractResourceNames(typedMsg))
	}
	return nil
}

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

func (h *DeleteHardwareDescriptorClientMsgHandle) ExtractResourceBody(msg proto.Message) gotenresource.Resource {
	typedMsg := msg.(*DeleteHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBody(*DeleteHardwareRequest) *hardware.Hardware
	})
	if ok {
		return override.OverrideExtractResourceBody(typedMsg)
	}
	return nil
}

func (h *DeleteHardwareDescriptorClientMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*DeleteHardwareRequest)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*DeleteHardwareRequest) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

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

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

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

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

func (h *DeleteHardwareDescriptorServerMsgHandle) ExtractResourceBodies(msg proto.Message) gotenresource.ResourceList {
	typedMsg := msg.(*emptypb.Empty)
	var asInterface interface{} = h
	override, ok := asInterface.(interface {
		OverrideExtractResourceBodies(*emptypb.Empty) []*hardware.Hardware
	})
	if ok {
		return hardware.HardwareList(override.OverrideExtractResourceBodies(typedMsg))
	}
	return nil
}

func GetDeleteHardwareDescriptor() *DeleteHardwareDescriptor {
	return deleteHardwareDescriptor
}

type HardwareServiceDescriptor struct{}

func (d *HardwareServiceDescriptor) AllMethodDescriptors() []gotenclient.MethodDescriptor {
	return []gotenclient.MethodDescriptor{
		getHardwareDescriptor,
		batchGetHardwaresDescriptor,
		listHardwaresDescriptor,
		watchHardwareDescriptor,
		watchHardwaresDescriptor,
		createHardwareDescriptor,
		updateHardwareDescriptor,
		deleteHardwareDescriptor,
	}
}

func (d *HardwareServiceDescriptor) GetFullAPIName() string {
	return "/ntt.ztp.v1.HardwareService"
}

func (d *HardwareServiceDescriptor) GetProtoPkgName() string {
	return "ntt.ztp.v1"
}

func (d *HardwareServiceDescriptor) GetApiName() string {
	return "HardwareService"
}

func (d *HardwareServiceDescriptor) GetServiceDomain() string {
	return "ztp.edgelq.com"
}

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

func GetHardwareServiceDescriptor() *HardwareServiceDescriptor {
	return hardwareServiceDescriptor
}

func initDescriptors() {
	hardwareServiceDescriptor = &HardwareServiceDescriptor{}
	getHardwareDescriptor = &GetHardwareDescriptor{}
	batchGetHardwaresDescriptor = &BatchGetHardwaresDescriptor{}
	listHardwaresDescriptor = &ListHardwaresDescriptor{}
	watchHardwareDescriptor = &WatchHardwareDescriptor{}
	watchHardwaresDescriptor = &WatchHardwaresDescriptor{}
	createHardwareDescriptor = &CreateHardwareDescriptor{}
	updateHardwareDescriptor = &UpdateHardwareDescriptor{}
	deleteHardwareDescriptor = &DeleteHardwareDescriptor{}
	gotenclient.GetRegistry().RegisterApiDescriptor(hardwareServiceDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(getHardwareDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(batchGetHardwaresDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(listHardwaresDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchHardwareDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(watchHardwaresDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(createHardwareDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(updateHardwareDescriptor)
	gotenclient.GetRegistry().RegisterMethodDescriptor(deleteHardwareDescriptor)
}

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