github.com/cloudwan/edgelq-sdk@v1.15.4/cellular-api/resources/v1/sim_card/sim_card.pb.fieldpathbuilder.go

// Code generated by protoc-gen-goten-object
// File: edgelq/cellular-api/proto/v1/sim_card.proto
// DO NOT EDIT!!!

package sim_card

// proto imports
import (
	carrier "github.com/cloudwan/edgelq-sdk/cellular-api/carrier"
	contract "github.com/cloudwan/edgelq-sdk/cellular-api/resources/v1/contract"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1/organization"
	iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1/project"
	secrets_project "github.com/cloudwan/edgelq-sdk/secrets/resources/v1/project"
	secrets_secret "github.com/cloudwan/edgelq-sdk/secrets/resources/v1/secret"
	meta_common "github.com/cloudwan/goten-sdk/meta-service/resources/v1/common"
	meta_service "github.com/cloudwan/goten-sdk/meta-service/resources/v1/service"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	multi_region_policy "github.com/cloudwan/goten-sdk/types/multi_region_policy"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// make sure we're using proto imports
var (
	_ = &carrier.TransatelAccount{}
	_ = &contract.Contract{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_organization.Organization{}
	_ = &iam_project.Project{}
	_ = &secrets_project.Project{}
	_ = &secrets_secret.Secret{}
	_ = &timestamppb.Timestamp{}
	_ = &meta_common.LabelledDomain{}
	_ = &meta_service.Service{}
	_ = &meta.Meta{}
	_ = &multi_region_policy.MultiRegionPolicy{}
)

type SimCardFieldPathBuilder struct{}

func NewSimCardFieldPathBuilder() SimCardFieldPathBuilder {
	return SimCardFieldPathBuilder{}
}
func (SimCardFieldPathBuilder) Name() SimCardPathSelectorName {
	return SimCardPathSelectorName{}
}
func (SimCardFieldPathBuilder) Metadata() SimCardPathSelectorMetadata {
	return SimCardPathSelectorMetadata{}
}
func (SimCardFieldPathBuilder) Contract() SimCardPathSelectorContract {
	return SimCardPathSelectorContract{}
}
func (SimCardFieldPathBuilder) Imsi() SimCardPathSelectorImsi {
	return SimCardPathSelectorImsi{}
}
func (SimCardFieldPathBuilder) RatePlan() SimCardPathSelectorRatePlan {
	return SimCardPathSelectorRatePlan{}
}
func (SimCardFieldPathBuilder) Status() SimCardPathSelectorStatus {
	return SimCardPathSelectorStatus{}
}

type SimCardPathSelectorName struct{}

func (SimCardPathSelectorName) FieldPath() *SimCard_FieldTerminalPath {
	return &SimCard_FieldTerminalPath{selector: SimCard_FieldPathSelectorName}
}

func (s SimCardPathSelectorName) WithValue(value *Name) *SimCard_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldTerminalPathValue)
}

func (s SimCardPathSelectorName) WithArrayOfValues(values []*Name) *SimCard_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldTerminalPathArrayOfValues)
}

type SimCardPathSelectorMetadata struct{}

func (SimCardPathSelectorMetadata) FieldPath() *SimCard_FieldTerminalPath {
	return &SimCard_FieldTerminalPath{selector: SimCard_FieldPathSelectorMetadata}
}

func (s SimCardPathSelectorMetadata) WithValue(value *meta.Meta) *SimCard_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldTerminalPathValue)
}

func (s SimCardPathSelectorMetadata) WithArrayOfValues(values []*meta.Meta) *SimCard_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldTerminalPathArrayOfValues)
}

func (SimCardPathSelectorMetadata) WithSubPath(subPath meta.Meta_FieldPath) *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{selector: SimCard_FieldPathSelectorMetadata, subPath: subPath}
}

func (s SimCardPathSelectorMetadata) WithSubValue(subPathValue meta.Meta_FieldPathValue) *SimCard_FieldSubPathValue {
	return &SimCard_FieldSubPathValue{SimCard_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s SimCardPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues meta.Meta_FieldPathArrayOfValues) *SimCard_FieldSubPathArrayOfValues {
	return &SimCard_FieldSubPathArrayOfValues{SimCard_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s SimCardPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue meta.Meta_FieldPathArrayItemValue) *SimCard_FieldSubPathArrayItemValue {
	return &SimCard_FieldSubPathArrayItemValue{SimCard_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (SimCardPathSelectorMetadata) CreateTime() SimCardPathSelectorMetadataCreateTime {
	return SimCardPathSelectorMetadataCreateTime{}
}

func (SimCardPathSelectorMetadata) UpdateTime() SimCardPathSelectorMetadataUpdateTime {
	return SimCardPathSelectorMetadataUpdateTime{}
}

func (SimCardPathSelectorMetadata) DeleteTime() SimCardPathSelectorMetadataDeleteTime {
	return SimCardPathSelectorMetadataDeleteTime{}
}

func (SimCardPathSelectorMetadata) Uuid() SimCardPathSelectorMetadataUuid {
	return SimCardPathSelectorMetadataUuid{}
}

func (SimCardPathSelectorMetadata) Tags() SimCardPathSelectorMetadataTags {
	return SimCardPathSelectorMetadataTags{}
}

func (SimCardPathSelectorMetadata) Labels() SimCardPathSelectorMetadataLabels {
	return SimCardPathSelectorMetadataLabels{}
}

func (SimCardPathSelectorMetadata) Annotations() SimCardPathSelectorMetadataAnnotations {
	return SimCardPathSelectorMetadataAnnotations{}
}

func (SimCardPathSelectorMetadata) Generation() SimCardPathSelectorMetadataGeneration {
	return SimCardPathSelectorMetadataGeneration{}
}

func (SimCardPathSelectorMetadata) ResourceVersion() SimCardPathSelectorMetadataResourceVersion {
	return SimCardPathSelectorMetadataResourceVersion{}
}

func (SimCardPathSelectorMetadata) OwnerReferences() SimCardPathSelectorMetadataOwnerReferences {
	return SimCardPathSelectorMetadataOwnerReferences{}
}

func (SimCardPathSelectorMetadata) Shards() SimCardPathSelectorMetadataShards {
	return SimCardPathSelectorMetadataShards{}
}

func (SimCardPathSelectorMetadata) Syncing() SimCardPathSelectorMetadataSyncing {
	return SimCardPathSelectorMetadataSyncing{}
}

func (SimCardPathSelectorMetadata) Lifecycle() SimCardPathSelectorMetadataLifecycle {
	return SimCardPathSelectorMetadataLifecycle{}
}

func (SimCardPathSelectorMetadata) Services() SimCardPathSelectorMetadataServices {
	return SimCardPathSelectorMetadataServices{}
}

type SimCardPathSelectorMetadataCreateTime struct{}

func (SimCardPathSelectorMetadataCreateTime) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().CreateTime().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataCreateTime) WithValue(value *timestamppb.Timestamp) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataCreateTime) WithArrayOfValues(values []*timestamppb.Timestamp) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataUpdateTime struct{}

func (SimCardPathSelectorMetadataUpdateTime) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().UpdateTime().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataUpdateTime) WithValue(value *timestamppb.Timestamp) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataUpdateTime) WithArrayOfValues(values []*timestamppb.Timestamp) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataDeleteTime struct{}

func (SimCardPathSelectorMetadataDeleteTime) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().DeleteTime().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataDeleteTime) WithValue(value *timestamppb.Timestamp) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataDeleteTime) WithArrayOfValues(values []*timestamppb.Timestamp) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataUuid struct{}

func (SimCardPathSelectorMetadataUuid) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Uuid().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataUuid) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataUuid) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataTags struct{}

func (SimCardPathSelectorMetadataTags) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Tags().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataTags) WithValue(value []string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataTags) WithArrayOfValues(values [][]string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (s SimCardPathSelectorMetadataTags) WithItemValue(value string) *SimCard_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*SimCard_FieldSubPathArrayItemValue)
}

type SimCardPathSelectorMetadataLabels struct{}

func (SimCardPathSelectorMetadataLabels) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataLabels) WithValue(value map[string]string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataLabels) WithArrayOfValues(values []map[string]string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (SimCardPathSelectorMetadataLabels) WithKey(key string) SimCardMapPathSelectorMetadataLabels {
	return SimCardMapPathSelectorMetadataLabels{key: key}
}

type SimCardMapPathSelectorMetadataLabels struct {
	key string
}

func (s SimCardMapPathSelectorMetadataLabels) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Labels().WithKey(s.key).FieldPath(),
	}
}

func (s SimCardMapPathSelectorMetadataLabels) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardMapPathSelectorMetadataLabels) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataAnnotations struct{}

func (SimCardPathSelectorMetadataAnnotations) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataAnnotations) WithValue(value map[string]string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataAnnotations) WithArrayOfValues(values []map[string]string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (SimCardPathSelectorMetadataAnnotations) WithKey(key string) SimCardMapPathSelectorMetadataAnnotations {
	return SimCardMapPathSelectorMetadataAnnotations{key: key}
}

type SimCardMapPathSelectorMetadataAnnotations struct {
	key string
}

func (s SimCardMapPathSelectorMetadataAnnotations) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Annotations().WithKey(s.key).FieldPath(),
	}
}

func (s SimCardMapPathSelectorMetadataAnnotations) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardMapPathSelectorMetadataAnnotations) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataGeneration struct{}

func (SimCardPathSelectorMetadataGeneration) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Generation().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataGeneration) WithValue(value int64) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataGeneration) WithArrayOfValues(values []int64) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataResourceVersion struct{}

func (SimCardPathSelectorMetadataResourceVersion) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().ResourceVersion().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataResourceVersion) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataResourceVersion) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataOwnerReferences struct{}

func (SimCardPathSelectorMetadataOwnerReferences) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferences) WithValue(value []*meta.OwnerReference) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferences) WithArrayOfValues(values [][]*meta.OwnerReference) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (s SimCardPathSelectorMetadataOwnerReferences) WithItemValue(value *meta.OwnerReference) *SimCard_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*SimCard_FieldSubPathArrayItemValue)
}

func (SimCardPathSelectorMetadataOwnerReferences) Kind() SimCardPathSelectorMetadataOwnerReferencesKind {
	return SimCardPathSelectorMetadataOwnerReferencesKind{}
}

func (SimCardPathSelectorMetadataOwnerReferences) Version() SimCardPathSelectorMetadataOwnerReferencesVersion {
	return SimCardPathSelectorMetadataOwnerReferencesVersion{}
}

func (SimCardPathSelectorMetadataOwnerReferences) Name() SimCardPathSelectorMetadataOwnerReferencesName {
	return SimCardPathSelectorMetadataOwnerReferencesName{}
}

func (SimCardPathSelectorMetadataOwnerReferences) Region() SimCardPathSelectorMetadataOwnerReferencesRegion {
	return SimCardPathSelectorMetadataOwnerReferencesRegion{}
}

func (SimCardPathSelectorMetadataOwnerReferences) Controller() SimCardPathSelectorMetadataOwnerReferencesController {
	return SimCardPathSelectorMetadataOwnerReferencesController{}
}

func (SimCardPathSelectorMetadataOwnerReferences) RequiresOwnerReference() SimCardPathSelectorMetadataOwnerReferencesRequiresOwnerReference {
	return SimCardPathSelectorMetadataOwnerReferencesRequiresOwnerReference{}
}

func (SimCardPathSelectorMetadataOwnerReferences) UnsetOnDelete() SimCardPathSelectorMetadataOwnerReferencesUnsetOnDelete {
	return SimCardPathSelectorMetadataOwnerReferencesUnsetOnDelete{}
}

type SimCardPathSelectorMetadataOwnerReferencesKind struct{}

func (SimCardPathSelectorMetadataOwnerReferencesKind) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Kind().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferencesKind) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataOwnerReferencesVersion struct{}

func (SimCardPathSelectorMetadataOwnerReferencesVersion) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Version().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferencesVersion) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataOwnerReferencesName struct{}

func (SimCardPathSelectorMetadataOwnerReferencesName) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Name().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferencesName) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferencesName) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataOwnerReferencesRegion struct{}

func (SimCardPathSelectorMetadataOwnerReferencesRegion) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Region().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferencesRegion) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataOwnerReferencesController struct{}

func (SimCardPathSelectorMetadataOwnerReferencesController) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().Controller().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferencesController) WithArrayOfValues(values []bool) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct{}

func (SimCardPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().RequiresOwnerReference().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithArrayOfValues(values []bool) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataOwnerReferencesUnsetOnDelete struct{}

func (SimCardPathSelectorMetadataOwnerReferencesUnsetOnDelete) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().OwnerReferences().UnsetOnDelete().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataOwnerReferencesUnsetOnDelete) WithValue(value bool) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataOwnerReferencesUnsetOnDelete) WithArrayOfValues(values []bool) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataShards struct{}

func (SimCardPathSelectorMetadataShards) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataShards) WithValue(value map[string]int64) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataShards) WithArrayOfValues(values []map[string]int64) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (SimCardPathSelectorMetadataShards) WithKey(key string) SimCardMapPathSelectorMetadataShards {
	return SimCardMapPathSelectorMetadataShards{key: key}
}

type SimCardMapPathSelectorMetadataShards struct {
	key string
}

func (s SimCardMapPathSelectorMetadataShards) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Shards().WithKey(s.key).FieldPath(),
	}
}

func (s SimCardMapPathSelectorMetadataShards) WithValue(value int64) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardMapPathSelectorMetadataShards) WithArrayOfValues(values []int64) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataSyncing struct{}

func (SimCardPathSelectorMetadataSyncing) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataSyncing) WithValue(value *meta.SyncingMeta) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataSyncing) WithArrayOfValues(values []*meta.SyncingMeta) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (SimCardPathSelectorMetadataSyncing) OwningRegion() SimCardPathSelectorMetadataSyncingOwningRegion {
	return SimCardPathSelectorMetadataSyncingOwningRegion{}
}

func (SimCardPathSelectorMetadataSyncing) Regions() SimCardPathSelectorMetadataSyncingRegions {
	return SimCardPathSelectorMetadataSyncingRegions{}
}

type SimCardPathSelectorMetadataSyncingOwningRegion struct{}

func (SimCardPathSelectorMetadataSyncingOwningRegion) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().OwningRegion().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataSyncingOwningRegion) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataSyncingRegions struct{}

func (SimCardPathSelectorMetadataSyncingRegions) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Syncing().Regions().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataSyncingRegions) WithValue(value []string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataSyncingRegions) WithArrayOfValues(values [][]string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (s SimCardPathSelectorMetadataSyncingRegions) WithItemValue(value string) *SimCard_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*SimCard_FieldSubPathArrayItemValue)
}

type SimCardPathSelectorMetadataLifecycle struct{}

func (SimCardPathSelectorMetadataLifecycle) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataLifecycle) WithValue(value *meta.Lifecycle) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataLifecycle) WithArrayOfValues(values []*meta.Lifecycle) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (SimCardPathSelectorMetadataLifecycle) State() SimCardPathSelectorMetadataLifecycleState {
	return SimCardPathSelectorMetadataLifecycleState{}
}

func (SimCardPathSelectorMetadataLifecycle) BlockDeletion() SimCardPathSelectorMetadataLifecycleBlockDeletion {
	return SimCardPathSelectorMetadataLifecycleBlockDeletion{}
}

type SimCardPathSelectorMetadataLifecycleState struct{}

func (SimCardPathSelectorMetadataLifecycleState) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().State().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataLifecycleState) WithValue(value meta.Lifecycle_State) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataLifecycleState) WithArrayOfValues(values []meta.Lifecycle_State) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataLifecycleBlockDeletion struct{}

func (SimCardPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Lifecycle().BlockDeletion().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataLifecycleBlockDeletion) WithArrayOfValues(values []bool) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataServices struct{}

func (SimCardPathSelectorMetadataServices) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataServices) WithValue(value *meta.ServicesInfo) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataServices) WithArrayOfValues(values []*meta.ServicesInfo) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (SimCardPathSelectorMetadataServices) OwningService() SimCardPathSelectorMetadataServicesOwningService {
	return SimCardPathSelectorMetadataServicesOwningService{}
}

func (SimCardPathSelectorMetadataServices) AllowedServices() SimCardPathSelectorMetadataServicesAllowedServices {
	return SimCardPathSelectorMetadataServicesAllowedServices{}
}

type SimCardPathSelectorMetadataServicesOwningService struct{}

func (SimCardPathSelectorMetadataServicesOwningService) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().OwningService().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataServicesOwningService) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataServicesOwningService) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorMetadataServicesAllowedServices struct{}

func (SimCardPathSelectorMetadataServicesAllowedServices) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorMetadata,
		subPath:  meta.NewMetaFieldPathBuilder().Services().AllowedServices().FieldPath(),
	}
}

func (s SimCardPathSelectorMetadataServicesAllowedServices) WithValue(value []string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorMetadataServicesAllowedServices) WithArrayOfValues(values [][]string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

func (s SimCardPathSelectorMetadataServicesAllowedServices) WithItemValue(value string) *SimCard_FieldSubPathArrayItemValue {
	return s.FieldPath().WithIArrayItemValue(value).(*SimCard_FieldSubPathArrayItemValue)
}

type SimCardPathSelectorContract struct{}

func (SimCardPathSelectorContract) FieldPath() *SimCard_FieldTerminalPath {
	return &SimCard_FieldTerminalPath{selector: SimCard_FieldPathSelectorContract}
}

func (s SimCardPathSelectorContract) WithValue(value *contract.Reference) *SimCard_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldTerminalPathValue)
}

func (s SimCardPathSelectorContract) WithArrayOfValues(values []*contract.Reference) *SimCard_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldTerminalPathArrayOfValues)
}

type SimCardPathSelectorImsi struct{}

func (SimCardPathSelectorImsi) FieldPath() *SimCard_FieldTerminalPath {
	return &SimCard_FieldTerminalPath{selector: SimCard_FieldPathSelectorImsi}
}

func (s SimCardPathSelectorImsi) WithValue(value string) *SimCard_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldTerminalPathValue)
}

func (s SimCardPathSelectorImsi) WithArrayOfValues(values []string) *SimCard_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldTerminalPathArrayOfValues)
}

type SimCardPathSelectorRatePlan struct{}

func (SimCardPathSelectorRatePlan) FieldPath() *SimCard_FieldTerminalPath {
	return &SimCard_FieldTerminalPath{selector: SimCard_FieldPathSelectorRatePlan}
}

func (s SimCardPathSelectorRatePlan) WithValue(value string) *SimCard_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldTerminalPathValue)
}

func (s SimCardPathSelectorRatePlan) WithArrayOfValues(values []string) *SimCard_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldTerminalPathArrayOfValues)
}

type SimCardPathSelectorStatus struct{}

func (SimCardPathSelectorStatus) FieldPath() *SimCard_FieldTerminalPath {
	return &SimCard_FieldTerminalPath{selector: SimCard_FieldPathSelectorStatus}
}

func (s SimCardPathSelectorStatus) WithValue(value *SimCard_Status) *SimCard_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldTerminalPathValue)
}

func (s SimCardPathSelectorStatus) WithArrayOfValues(values []*SimCard_Status) *SimCard_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldTerminalPathArrayOfValues)
}

func (SimCardPathSelectorStatus) WithSubPath(subPath SimCardStatus_FieldPath) *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{selector: SimCard_FieldPathSelectorStatus, subPath: subPath}
}

func (s SimCardPathSelectorStatus) WithSubValue(subPathValue SimCardStatus_FieldPathValue) *SimCard_FieldSubPathValue {
	return &SimCard_FieldSubPathValue{SimCard_FieldPath: s.WithSubPath(subPathValue), subPathValue: subPathValue}
}

func (s SimCardPathSelectorStatus) WithSubArrayOfValues(subPathArrayOfValues SimCardStatus_FieldPathArrayOfValues) *SimCard_FieldSubPathArrayOfValues {
	return &SimCard_FieldSubPathArrayOfValues{SimCard_FieldPath: s.WithSubPath(subPathArrayOfValues), subPathArrayOfValues: subPathArrayOfValues}
}

func (s SimCardPathSelectorStatus) WithSubArrayItemValue(subPathArrayItemValue SimCardStatus_FieldPathArrayItemValue) *SimCard_FieldSubPathArrayItemValue {
	return &SimCard_FieldSubPathArrayItemValue{SimCard_FieldPath: s.WithSubPath(subPathArrayItemValue), subPathItemValue: subPathArrayItemValue}
}

func (SimCardPathSelectorStatus) State() SimCardPathSelectorStatusState {
	return SimCardPathSelectorStatusState{}
}

func (SimCardPathSelectorStatus) Error() SimCardPathSelectorStatusError {
	return SimCardPathSelectorStatusError{}
}

type SimCardPathSelectorStatusState struct{}

func (SimCardPathSelectorStatusState) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorStatus,
		subPath:  NewSimCardStatusFieldPathBuilder().State().FieldPath(),
	}
}

func (s SimCardPathSelectorStatusState) WithValue(value carrier.SimState) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorStatusState) WithArrayOfValues(values []carrier.SimState) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardPathSelectorStatusError struct{}

func (SimCardPathSelectorStatusError) FieldPath() *SimCard_FieldSubPath {
	return &SimCard_FieldSubPath{
		selector: SimCard_FieldPathSelectorStatus,
		subPath:  NewSimCardStatusFieldPathBuilder().Error().FieldPath(),
	}
}

func (s SimCardPathSelectorStatusError) WithValue(value string) *SimCard_FieldSubPathValue {
	return s.FieldPath().WithIValue(value).(*SimCard_FieldSubPathValue)
}

func (s SimCardPathSelectorStatusError) WithArrayOfValues(values []string) *SimCard_FieldSubPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCard_FieldSubPathArrayOfValues)
}

type SimCardStatusFieldPathBuilder struct{}

func NewSimCardStatusFieldPathBuilder() SimCardStatusFieldPathBuilder {
	return SimCardStatusFieldPathBuilder{}
}
func (SimCardStatusFieldPathBuilder) State() SimCard_StatusPathSelectorState {
	return SimCard_StatusPathSelectorState{}
}
func (SimCardStatusFieldPathBuilder) Error() SimCard_StatusPathSelectorError {
	return SimCard_StatusPathSelectorError{}
}

type SimCard_StatusPathSelectorState struct{}

func (SimCard_StatusPathSelectorState) FieldPath() *SimCardStatus_FieldTerminalPath {
	return &SimCardStatus_FieldTerminalPath{selector: SimCardStatus_FieldPathSelectorState}
}

func (s SimCard_StatusPathSelectorState) WithValue(value carrier.SimState) *SimCardStatus_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCardStatus_FieldTerminalPathValue)
}

func (s SimCard_StatusPathSelectorState) WithArrayOfValues(values []carrier.SimState) *SimCardStatus_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCardStatus_FieldTerminalPathArrayOfValues)
}

type SimCard_StatusPathSelectorError struct{}

func (SimCard_StatusPathSelectorError) FieldPath() *SimCardStatus_FieldTerminalPath {
	return &SimCardStatus_FieldTerminalPath{selector: SimCardStatus_FieldPathSelectorError}
}

func (s SimCard_StatusPathSelectorError) WithValue(value string) *SimCardStatus_FieldTerminalPathValue {
	return s.FieldPath().WithIValue(value).(*SimCardStatus_FieldTerminalPathValue)
}

func (s SimCard_StatusPathSelectorError) WithArrayOfValues(values []string) *SimCardStatus_FieldTerminalPathArrayOfValues {
	return s.FieldPath().WithIArrayOfValues(values).(*SimCardStatus_FieldTerminalPathArrayOfValues)
}