zz_generated.resources.go

// Generated by tools/resource-gen.
// Run "make generate" to update this file.

// nolint:whitespace
package mesh

import (
	"fmt"
)

import (
	mesh_proto "github.com/apache/dubbo-kubernetes/api/mesh/v1alpha1"
	"github.com/apache/dubbo-kubernetes/pkg/core/resources/model"
	"github.com/apache/dubbo-kubernetes/pkg/core/resources/registry"
)

const (
	ConditionRouteType model.ResourceType = "ConditionRoute"
)

var _ model.Resource = &ConditionRouteResource{}

type ConditionRouteResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.ConditionRoute
}

func NewConditionRouteResource() *ConditionRouteResource {
	return &ConditionRouteResource{
		Spec: &mesh_proto.ConditionRoute{},
	}
}

func (t *ConditionRouteResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *ConditionRouteResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *ConditionRouteResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *ConditionRouteResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.ConditionRoute)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.ConditionRoute{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *ConditionRouteResource) Descriptor() model.ResourceTypeDescriptor {
	return ConditionRouteResourceTypeDescriptor
}

var _ model.ResourceList = &ConditionRouteResourceList{}

type ConditionRouteResourceList struct {
	Items      []*ConditionRouteResource
	Pagination model.Pagination
}

func (l *ConditionRouteResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *ConditionRouteResourceList) GetItemType() model.ResourceType {
	return ConditionRouteType
}

func (l *ConditionRouteResourceList) NewItem() model.Resource {
	return NewConditionRouteResource()
}

func (l *ConditionRouteResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*ConditionRouteResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*ConditionRouteResource)(nil), r)
	}
}

func (l *ConditionRouteResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *ConditionRouteResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var ConditionRouteResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                ConditionRouteType,
	Resource:            NewConditionRouteResource(),
	ResourceList:        &ConditionRouteResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeMesh,
	DDSFlags:            model.GlobalToAllZonesFlag,
	WsPath:              "conditionroutes",
	DubboctlArg:         "conditionroute",
	DubboctlListArg:     "conditionroutes",
	AllowToInspect:      true,
	IsPolicy:            true,
	SingularDisplayName: "Condition Route",
	PluralDisplayName:   "Condition Routes",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(ConditionRouteResourceTypeDescriptor)
}

const (
	DataplaneType model.ResourceType = "Dataplane"
)

var _ model.Resource = &DataplaneResource{}

type DataplaneResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.Dataplane
}

func NewDataplaneResource() *DataplaneResource {
	return &DataplaneResource{
		Spec: &mesh_proto.Dataplane{},
	}
}

func (t *DataplaneResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *DataplaneResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *DataplaneResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *DataplaneResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.Dataplane)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.Dataplane{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *DataplaneResource) Descriptor() model.ResourceTypeDescriptor {
	return DataplaneResourceTypeDescriptor
}

var _ model.ResourceList = &DataplaneResourceList{}

type DataplaneResourceList struct {
	Items      []*DataplaneResource
	Pagination model.Pagination
}

func (l *DataplaneResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *DataplaneResourceList) GetItemType() model.ResourceType {
	return DataplaneType
}

func (l *DataplaneResourceList) NewItem() model.Resource {
	return NewDataplaneResource()
}

func (l *DataplaneResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*DataplaneResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*DataplaneResource)(nil), r)
	}
}

func (l *DataplaneResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *DataplaneResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var DataplaneResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                DataplaneType,
	Resource:            NewDataplaneResource(),
	ResourceList:        &DataplaneResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeMesh,
	DDSFlags:            model.ZoneToGlobalFlag,
	WsPath:              "dataplanes",
	DubboctlArg:         "dataplane",
	DubboctlListArg:     "dataplanes",
	AllowToInspect:      true,
	IsPolicy:            false,
	SingularDisplayName: "Dataplane",
	PluralDisplayName:   "Dataplanes",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(DataplaneResourceTypeDescriptor)
}

const (
	DataplaneInsightType model.ResourceType = "DataplaneInsight"
)

var _ model.Resource = &DataplaneInsightResource{}

type DataplaneInsightResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.DataplaneInsight
}

func NewDataplaneInsightResource() *DataplaneInsightResource {
	return &DataplaneInsightResource{
		Spec: &mesh_proto.DataplaneInsight{},
	}
}

func (t *DataplaneInsightResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *DataplaneInsightResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *DataplaneInsightResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *DataplaneInsightResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.DataplaneInsight)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.DataplaneInsight{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *DataplaneInsightResource) Descriptor() model.ResourceTypeDescriptor {
	return DataplaneInsightResourceTypeDescriptor
}

var _ model.ResourceList = &DataplaneInsightResourceList{}

type DataplaneInsightResourceList struct {
	Items      []*DataplaneInsightResource
	Pagination model.Pagination
}

func (l *DataplaneInsightResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *DataplaneInsightResourceList) GetItemType() model.ResourceType {
	return DataplaneInsightType
}

func (l *DataplaneInsightResourceList) NewItem() model.Resource {
	return NewDataplaneInsightResource()
}

func (l *DataplaneInsightResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*DataplaneInsightResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*DataplaneInsightResource)(nil), r)
	}
}

func (l *DataplaneInsightResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *DataplaneInsightResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var DataplaneInsightResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                DataplaneInsightType,
	Resource:            NewDataplaneInsightResource(),
	ResourceList:        &DataplaneInsightResourceList{},
	ReadOnly:            true,
	AdminOnly:           false,
	Scope:               model.ScopeMesh,
	DDSFlags:            model.ZoneToGlobalFlag,
	WsPath:              "dataplane-insights",
	DubboctlArg:         "",
	DubboctlListArg:     "",
	AllowToInspect:      false,
	IsPolicy:            false,
	SingularDisplayName: "Dataplane Insight",
	PluralDisplayName:   "Dataplane Insights",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(DataplaneInsightResourceTypeDescriptor)
}

const (
	DynamicConfigType model.ResourceType = "DynamicConfig"
)

var _ model.Resource = &DynamicConfigResource{}

type DynamicConfigResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.DynamicConfig
}

func NewDynamicConfigResource() *DynamicConfigResource {
	return &DynamicConfigResource{
		Spec: &mesh_proto.DynamicConfig{},
	}
}

func (t *DynamicConfigResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *DynamicConfigResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *DynamicConfigResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *DynamicConfigResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.DynamicConfig)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.DynamicConfig{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *DynamicConfigResource) Descriptor() model.ResourceTypeDescriptor {
	return DynamicConfigResourceTypeDescriptor
}

var _ model.ResourceList = &DynamicConfigResourceList{}

type DynamicConfigResourceList struct {
	Items      []*DynamicConfigResource
	Pagination model.Pagination
}

func (l *DynamicConfigResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *DynamicConfigResourceList) GetItemType() model.ResourceType {
	return DynamicConfigType
}

func (l *DynamicConfigResourceList) NewItem() model.Resource {
	return NewDynamicConfigResource()
}

func (l *DynamicConfigResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*DynamicConfigResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*DynamicConfigResource)(nil), r)
	}
}

func (l *DynamicConfigResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *DynamicConfigResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var DynamicConfigResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                DynamicConfigType,
	Resource:            NewDynamicConfigResource(),
	ResourceList:        &DynamicConfigResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeMesh,
	DDSFlags:            model.GlobalToAllZonesFlag,
	WsPath:              "dynamicconfigs",
	DubboctlArg:         "dynamicconfig",
	DubboctlListArg:     "dynamicconfigs",
	AllowToInspect:      true,
	IsPolicy:            true,
	SingularDisplayName: "Dynamic Config",
	PluralDisplayName:   "Dynamic Configs",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(DynamicConfigResourceTypeDescriptor)
}

const (
	MappingType model.ResourceType = "Mapping"
)

var _ model.Resource = &MappingResource{}

type MappingResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.Mapping
}

func NewMappingResource() *MappingResource {
	return &MappingResource{
		Spec: &mesh_proto.Mapping{},
	}
}

func (t *MappingResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *MappingResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *MappingResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *MappingResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.Mapping)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.Mapping{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *MappingResource) Descriptor() model.ResourceTypeDescriptor {
	return MappingResourceTypeDescriptor
}

var _ model.ResourceList = &MappingResourceList{}

type MappingResourceList struct {
	Items      []*MappingResource
	Pagination model.Pagination
}

func (l *MappingResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *MappingResourceList) GetItemType() model.ResourceType {
	return MappingType
}

func (l *MappingResourceList) NewItem() model.Resource {
	return NewMappingResource()
}

func (l *MappingResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*MappingResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*MappingResource)(nil), r)
	}
}

func (l *MappingResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *MappingResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var MappingResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                MappingType,
	Resource:            NewMappingResource(),
	ResourceList:        &MappingResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeMesh,
	DDSFlags:            model.ZoneToGlobalFlag | model.GlobalToAllButOriginalZoneFlag,
	WsPath:              "mappings",
	DubboctlArg:         "mapping",
	DubboctlListArg:     "mappings",
	AllowToInspect:      true,
	IsPolicy:            true,
	SingularDisplayName: "Mapping",
	PluralDisplayName:   "Mappings",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(MappingResourceTypeDescriptor)
}

const (
	MeshType model.ResourceType = "Mesh"
)

var _ model.Resource = &MeshResource{}

type MeshResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.Mesh
}

func NewMeshResource() *MeshResource {
	return &MeshResource{
		Spec: &mesh_proto.Mesh{},
	}
}

func (t *MeshResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *MeshResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *MeshResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *MeshResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.Mesh)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.Mesh{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *MeshResource) Descriptor() model.ResourceTypeDescriptor {
	return MeshResourceTypeDescriptor
}

var _ model.ResourceList = &MeshResourceList{}

type MeshResourceList struct {
	Items      []*MeshResource
	Pagination model.Pagination
}

func (l *MeshResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *MeshResourceList) GetItemType() model.ResourceType {
	return MeshType
}

func (l *MeshResourceList) NewItem() model.Resource {
	return NewMeshResource()
}

func (l *MeshResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*MeshResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*MeshResource)(nil), r)
	}
}

func (l *MeshResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *MeshResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var MeshResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                MeshType,
	Resource:            NewMeshResource(),
	ResourceList:        &MeshResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeGlobal,
	DDSFlags:            model.GlobalToAllZonesFlag,
	WsPath:              "meshes",
	DubboctlArg:         "mesh",
	DubboctlListArg:     "meshes",
	AllowToInspect:      true,
	IsPolicy:            false,
	SingularDisplayName: "Mesh",
	PluralDisplayName:   "Meshes",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(MeshResourceTypeDescriptor)
}

const (
	MeshInsightType model.ResourceType = "MeshInsight"
)

var _ model.Resource = &MeshInsightResource{}

type MeshInsightResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.MeshInsight
}

func NewMeshInsightResource() *MeshInsightResource {
	return &MeshInsightResource{
		Spec: &mesh_proto.MeshInsight{},
	}
}

func (t *MeshInsightResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *MeshInsightResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *MeshInsightResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *MeshInsightResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.MeshInsight)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.MeshInsight{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *MeshInsightResource) Descriptor() model.ResourceTypeDescriptor {
	return MeshInsightResourceTypeDescriptor
}

var _ model.ResourceList = &MeshInsightResourceList{}

type MeshInsightResourceList struct {
	Items      []*MeshInsightResource
	Pagination model.Pagination
}

func (l *MeshInsightResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *MeshInsightResourceList) GetItemType() model.ResourceType {
	return MeshInsightType
}

func (l *MeshInsightResourceList) NewItem() model.Resource {
	return NewMeshInsightResource()
}

func (l *MeshInsightResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*MeshInsightResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*MeshInsightResource)(nil), r)
	}
}

func (l *MeshInsightResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *MeshInsightResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var MeshInsightResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                MeshInsightType,
	Resource:            NewMeshInsightResource(),
	ResourceList:        &MeshInsightResourceList{},
	ReadOnly:            true,
	AdminOnly:           false,
	Scope:               model.ScopeGlobal,
	WsPath:              "mesh-insights",
	DubboctlArg:         "",
	DubboctlListArg:     "",
	AllowToInspect:      false,
	IsPolicy:            false,
	SingularDisplayName: "Mesh Insight",
	PluralDisplayName:   "Mesh Insights",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(MeshInsightResourceTypeDescriptor)
}

const (
	MetaDataType model.ResourceType = "MetaData"
)

var _ model.Resource = &MetaDataResource{}

type MetaDataResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.MetaData
}

func NewMetaDataResource() *MetaDataResource {
	return &MetaDataResource{
		Spec: &mesh_proto.MetaData{},
	}
}

func (t *MetaDataResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *MetaDataResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *MetaDataResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *MetaDataResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.MetaData)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.MetaData{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *MetaDataResource) Descriptor() model.ResourceTypeDescriptor {
	return MetaDataResourceTypeDescriptor
}

var _ model.ResourceList = &MetaDataResourceList{}

type MetaDataResourceList struct {
	Items      []*MetaDataResource
	Pagination model.Pagination
}

func (l *MetaDataResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *MetaDataResourceList) GetItemType() model.ResourceType {
	return MetaDataType
}

func (l *MetaDataResourceList) NewItem() model.Resource {
	return NewMetaDataResource()
}

func (l *MetaDataResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*MetaDataResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*MetaDataResource)(nil), r)
	}
}

func (l *MetaDataResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *MetaDataResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var MetaDataResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                MetaDataType,
	Resource:            NewMetaDataResource(),
	ResourceList:        &MetaDataResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeMesh,
	DDSFlags:            model.ZoneToGlobalFlag,
	WsPath:              "metadatas",
	DubboctlArg:         "metadata",
	DubboctlListArg:     "metadatas",
	AllowToInspect:      true,
	IsPolicy:            true,
	SingularDisplayName: "Meta Data",
	PluralDisplayName:   "Meta Datas",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(MetaDataResourceTypeDescriptor)
}

const (
	TagRouteType model.ResourceType = "TagRoute"
)

var _ model.Resource = &TagRouteResource{}

type TagRouteResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.TagRoute
}

func NewTagRouteResource() *TagRouteResource {
	return &TagRouteResource{
		Spec: &mesh_proto.TagRoute{},
	}
}

func (t *TagRouteResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *TagRouteResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *TagRouteResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *TagRouteResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.TagRoute)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.TagRoute{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *TagRouteResource) Descriptor() model.ResourceTypeDescriptor {
	return TagRouteResourceTypeDescriptor
}

var _ model.ResourceList = &TagRouteResourceList{}

type TagRouteResourceList struct {
	Items      []*TagRouteResource
	Pagination model.Pagination
}

func (l *TagRouteResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *TagRouteResourceList) GetItemType() model.ResourceType {
	return TagRouteType
}

func (l *TagRouteResourceList) NewItem() model.Resource {
	return NewTagRouteResource()
}

func (l *TagRouteResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*TagRouteResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*TagRouteResource)(nil), r)
	}
}

func (l *TagRouteResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *TagRouteResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var TagRouteResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                TagRouteType,
	Resource:            NewTagRouteResource(),
	ResourceList:        &TagRouteResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeMesh,
	DDSFlags:            model.GlobalToAllZonesFlag,
	WsPath:              "tagroutes",
	DubboctlArg:         "tagroute",
	DubboctlListArg:     "tagroutes",
	AllowToInspect:      true,
	IsPolicy:            true,
	SingularDisplayName: "Tag Route",
	PluralDisplayName:   "Tag Routes",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(TagRouteResourceTypeDescriptor)
}

const (
	ZoneEgressType model.ResourceType = "ZoneEgress"
)

var _ model.Resource = &ZoneEgressResource{}

type ZoneEgressResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.ZoneEgress
}

func NewZoneEgressResource() *ZoneEgressResource {
	return &ZoneEgressResource{
		Spec: &mesh_proto.ZoneEgress{},
	}
}

func (t *ZoneEgressResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *ZoneEgressResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *ZoneEgressResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *ZoneEgressResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.ZoneEgress)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.ZoneEgress{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *ZoneEgressResource) Descriptor() model.ResourceTypeDescriptor {
	return ZoneEgressResourceTypeDescriptor
}

var _ model.ResourceList = &ZoneEgressResourceList{}

type ZoneEgressResourceList struct {
	Items      []*ZoneEgressResource
	Pagination model.Pagination
}

func (l *ZoneEgressResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *ZoneEgressResourceList) GetItemType() model.ResourceType {
	return ZoneEgressType
}

func (l *ZoneEgressResourceList) NewItem() model.Resource {
	return NewZoneEgressResource()
}

func (l *ZoneEgressResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*ZoneEgressResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*ZoneEgressResource)(nil), r)
	}
}

func (l *ZoneEgressResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *ZoneEgressResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var ZoneEgressResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                ZoneEgressType,
	Resource:            NewZoneEgressResource(),
	ResourceList:        &ZoneEgressResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeGlobal,
	DDSFlags:            model.ZoneToGlobalFlag | model.GlobalToAllButOriginalZoneFlag,
	WsPath:              "zoneegresses",
	DubboctlArg:         "zoneegress",
	DubboctlListArg:     "zoneegresses",
	AllowToInspect:      true,
	IsPolicy:            false,
	SingularDisplayName: "Zone Egress",
	PluralDisplayName:   "Zone Egresses",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(ZoneEgressResourceTypeDescriptor)
}

const (
	ZoneEgressInsightType model.ResourceType = "ZoneEgressInsight"
)

var _ model.Resource = &ZoneEgressInsightResource{}

type ZoneEgressInsightResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.ZoneEgressInsight
}

func NewZoneEgressInsightResource() *ZoneEgressInsightResource {
	return &ZoneEgressInsightResource{
		Spec: &mesh_proto.ZoneEgressInsight{},
	}
}

func (t *ZoneEgressInsightResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *ZoneEgressInsightResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *ZoneEgressInsightResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *ZoneEgressInsightResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.ZoneEgressInsight)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.ZoneEgressInsight{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *ZoneEgressInsightResource) Descriptor() model.ResourceTypeDescriptor {
	return ZoneEgressInsightResourceTypeDescriptor
}

var _ model.ResourceList = &ZoneEgressInsightResourceList{}

type ZoneEgressInsightResourceList struct {
	Items      []*ZoneEgressInsightResource
	Pagination model.Pagination
}

func (l *ZoneEgressInsightResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *ZoneEgressInsightResourceList) GetItemType() model.ResourceType {
	return ZoneEgressInsightType
}

func (l *ZoneEgressInsightResourceList) NewItem() model.Resource {
	return NewZoneEgressInsightResource()
}

func (l *ZoneEgressInsightResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*ZoneEgressInsightResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*ZoneEgressInsightResource)(nil), r)
	}
}

func (l *ZoneEgressInsightResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *ZoneEgressInsightResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var ZoneEgressInsightResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                ZoneEgressInsightType,
	Resource:            NewZoneEgressInsightResource(),
	ResourceList:        &ZoneEgressInsightResourceList{},
	ReadOnly:            true,
	AdminOnly:           false,
	Scope:               model.ScopeGlobal,
	DDSFlags:            model.ZoneToGlobalFlag,
	WsPath:              "zoneegressinsights",
	DubboctlArg:         "",
	DubboctlListArg:     "",
	AllowToInspect:      false,
	IsPolicy:            false,
	SingularDisplayName: "Zone Egress Insight",
	PluralDisplayName:   "Zone Egress Insights",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(ZoneEgressInsightResourceTypeDescriptor)
}

const (
	ZoneIngressType model.ResourceType = "ZoneIngress"
)

var _ model.Resource = &ZoneIngressResource{}

type ZoneIngressResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.ZoneIngress
}

func NewZoneIngressResource() *ZoneIngressResource {
	return &ZoneIngressResource{
		Spec: &mesh_proto.ZoneIngress{},
	}
}

func (t *ZoneIngressResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *ZoneIngressResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *ZoneIngressResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *ZoneIngressResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.ZoneIngress)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.ZoneIngress{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *ZoneIngressResource) Descriptor() model.ResourceTypeDescriptor {
	return ZoneIngressResourceTypeDescriptor
}

var _ model.ResourceList = &ZoneIngressResourceList{}

type ZoneIngressResourceList struct {
	Items      []*ZoneIngressResource
	Pagination model.Pagination
}

func (l *ZoneIngressResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *ZoneIngressResourceList) GetItemType() model.ResourceType {
	return ZoneIngressType
}

func (l *ZoneIngressResourceList) NewItem() model.Resource {
	return NewZoneIngressResource()
}

func (l *ZoneIngressResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*ZoneIngressResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*ZoneIngressResource)(nil), r)
	}
}

func (l *ZoneIngressResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *ZoneIngressResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var ZoneIngressResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                ZoneIngressType,
	Resource:            NewZoneIngressResource(),
	ResourceList:        &ZoneIngressResourceList{},
	ReadOnly:            false,
	AdminOnly:           false,
	Scope:               model.ScopeGlobal,
	DDSFlags:            model.ZoneToGlobalFlag | model.GlobalToAllButOriginalZoneFlag,
	WsPath:              "zoneingresses",
	DubboctlArg:         "zoneingress",
	DubboctlListArg:     "zoneingresses",
	AllowToInspect:      true,
	IsPolicy:            false,
	SingularDisplayName: "Zone Ingress",
	PluralDisplayName:   "Zone Ingresses",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(ZoneIngressResourceTypeDescriptor)
}

const (
	ZoneIngressInsightType model.ResourceType = "ZoneIngressInsight"
)

var _ model.Resource = &ZoneIngressInsightResource{}

type ZoneIngressInsightResource struct {
	Meta model.ResourceMeta
	Spec *mesh_proto.ZoneIngressInsight
}

func NewZoneIngressInsightResource() *ZoneIngressInsightResource {
	return &ZoneIngressInsightResource{
		Spec: &mesh_proto.ZoneIngressInsight{},
	}
}

func (t *ZoneIngressInsightResource) GetMeta() model.ResourceMeta {
	return t.Meta
}

func (t *ZoneIngressInsightResource) SetMeta(m model.ResourceMeta) {
	t.Meta = m
}

func (t *ZoneIngressInsightResource) GetSpec() model.ResourceSpec {
	return t.Spec
}

func (t *ZoneIngressInsightResource) SetSpec(spec model.ResourceSpec) error {
	protoType, ok := spec.(*mesh_proto.ZoneIngressInsight)
	if !ok {
		return fmt.Errorf("invalid type %T for Spec", spec)
	} else {
		if protoType == nil {
			t.Spec = &mesh_proto.ZoneIngressInsight{}
		} else {
			t.Spec = protoType
		}
		return nil
	}
}

func (t *ZoneIngressInsightResource) Descriptor() model.ResourceTypeDescriptor {
	return ZoneIngressInsightResourceTypeDescriptor
}

var _ model.ResourceList = &ZoneIngressInsightResourceList{}

type ZoneIngressInsightResourceList struct {
	Items      []*ZoneIngressInsightResource
	Pagination model.Pagination
}

func (l *ZoneIngressInsightResourceList) GetItems() []model.Resource {
	res := make([]model.Resource, len(l.Items))
	for i, elem := range l.Items {
		res[i] = elem
	}
	return res
}

func (l *ZoneIngressInsightResourceList) GetItemType() model.ResourceType {
	return ZoneIngressInsightType
}

func (l *ZoneIngressInsightResourceList) NewItem() model.Resource {
	return NewZoneIngressInsightResource()
}

func (l *ZoneIngressInsightResourceList) AddItem(r model.Resource) error {
	if trr, ok := r.(*ZoneIngressInsightResource); ok {
		l.Items = append(l.Items, trr)
		return nil
	} else {
		return model.ErrorInvalidItemType((*ZoneIngressInsightResource)(nil), r)
	}
}

func (l *ZoneIngressInsightResourceList) GetPagination() *model.Pagination {
	return &l.Pagination
}

func (l *ZoneIngressInsightResourceList) SetPagination(p model.Pagination) {
	l.Pagination = p
}

var ZoneIngressInsightResourceTypeDescriptor = model.ResourceTypeDescriptor{
	Name:                ZoneIngressInsightType,
	Resource:            NewZoneIngressInsightResource(),
	ResourceList:        &ZoneIngressInsightResourceList{},
	ReadOnly:            true,
	AdminOnly:           false,
	Scope:               model.ScopeGlobal,
	DDSFlags:            model.ZoneToGlobalFlag,
	WsPath:              "zone-ingress-insights",
	DubboctlArg:         "",
	DubboctlListArg:     "",
	AllowToInspect:      false,
	IsPolicy:            false,
	SingularDisplayName: "Zone Ingress Insight",
	PluralDisplayName:   "Zone Ingress Insights",
	IsExperimental:      false,
}

func init() {
	registry.RegisterType(ZoneIngressInsightResourceTypeDescriptor)
}