iam_common

Mar 3, 2023

Changes in this version

type BusinessTier

+ const BusinessTier_XSMALL

Jan 13, 2023

Changes in this version

+ var BusinessTier_name = map[int32]string

+ var BusinessTier_value = map[string]int32

+ type BusinessTier int32

+ const BusinessTier_LARGE

+ const BusinessTier_MEDIUM

+ const BusinessTier_SMALL

+ const BusinessTier_TINY

+ const BusinessTier_UNDEFINED

+ func (BusinessTier) Descriptor() preflect.EnumDescriptor

+ func (BusinessTier) EnumDescriptor() ([]byte, []int)

+ func (BusinessTier) Type() preflect.EnumType

+ func (x BusinessTier) Enum() *BusinessTier

+ func (x BusinessTier) Number() preflect.EnumNumber

+ func (x BusinessTier) String() string

+ type ServiceBusinessTier struct

+ BusinessTier BusinessTier

+ Service *meta_service.Reference

+ func (*ServiceBusinessTier) Descriptor() ([]byte, []int)

+ func (*ServiceBusinessTier) GotenMessage()

+ func (*ServiceBusinessTier) ProtoMessage()

+ func (m *ServiceBusinessTier) GetBusinessTier() BusinessTier

+ func (m *ServiceBusinessTier) GetService() *meta_service.Reference

+ func (m *ServiceBusinessTier) Marshal() ([]byte, error)

+ func (m *ServiceBusinessTier) MarshalJSON() ([]byte, error)

+ func (m *ServiceBusinessTier) ProtoReflect() preflect.Message

+ func (m *ServiceBusinessTier) Reset()

+ func (m *ServiceBusinessTier) SetBusinessTier(fv BusinessTier)

+ func (m *ServiceBusinessTier) SetService(fv *meta_service.Reference)

+ func (m *ServiceBusinessTier) String() string

+ func (m *ServiceBusinessTier) Unmarshal(b []byte) error

+ func (m *ServiceBusinessTier) UnmarshalJSON(data []byte) error

+ func (o *ServiceBusinessTier) Clone() *ServiceBusinessTier

+ func (o *ServiceBusinessTier) CloneRaw() gotenobject.GotenObjectExt

+ func (o *ServiceBusinessTier) GotenObjectExt()

+ func (o *ServiceBusinessTier) MakeDiffFieldMask(other *ServiceBusinessTier) *ServiceBusinessTier_FieldMask

+ func (o *ServiceBusinessTier) MakeFullFieldMask() *ServiceBusinessTier_FieldMask

+ func (o *ServiceBusinessTier) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

+ func (o *ServiceBusinessTier) MakeRawFullFieldMask() gotenobject.FieldMask

+ func (o *ServiceBusinessTier) Merge(source *ServiceBusinessTier)

+ func (o *ServiceBusinessTier) MergeRaw(source gotenobject.GotenObjectExt)

+ func (obj *ServiceBusinessTier) GotenValidate() error

+ type ServiceBusinessTierFieldPathBuilder struct

+ func NewServiceBusinessTierFieldPathBuilder() ServiceBusinessTierFieldPathBuilder

+ func (ServiceBusinessTierFieldPathBuilder) BusinessTier() ServiceBusinessTierPathSelectorBusinessTier

+ func (ServiceBusinessTierFieldPathBuilder) Service() ServiceBusinessTierPathSelectorService

+ type ServiceBusinessTierPathSelectorBusinessTier struct

+ func (ServiceBusinessTierPathSelectorBusinessTier) FieldPath() *ServiceBusinessTier_FieldTerminalPath

+ func (s ServiceBusinessTierPathSelectorBusinessTier) WithArrayOfValues(values []BusinessTier) *ServiceBusinessTier_FieldTerminalPathArrayOfValues

+ func (s ServiceBusinessTierPathSelectorBusinessTier) WithValue(value BusinessTier) *ServiceBusinessTier_FieldTerminalPathValue

+ type ServiceBusinessTierPathSelectorService struct

+ func (ServiceBusinessTierPathSelectorService) FieldPath() *ServiceBusinessTier_FieldTerminalPath

+ func (s ServiceBusinessTierPathSelectorService) WithArrayOfValues(values []*meta_service.Reference) *ServiceBusinessTier_FieldTerminalPathArrayOfValues

+ func (s ServiceBusinessTierPathSelectorService) WithValue(value *meta_service.Reference) *ServiceBusinessTier_FieldTerminalPathValue

+ type ServiceBusinessTier_FieldMask struct

+ Paths []ServiceBusinessTier_FieldPath

+ func FullServiceBusinessTier_FieldMask() *ServiceBusinessTier_FieldMask

+ func (fieldMask *ServiceBusinessTier_FieldMask) AppendPath(path ServiceBusinessTier_FieldPath)

+ func (fieldMask *ServiceBusinessTier_FieldMask) AppendRawPath(path gotenobject.FieldPath)

+ func (fieldMask *ServiceBusinessTier_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

+ func (fieldMask *ServiceBusinessTier_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

+ func (fieldMask *ServiceBusinessTier_FieldMask) FilterInputFields() *ServiceBusinessTier_FieldMask

+ func (fieldMask *ServiceBusinessTier_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

+ func (fieldMask *ServiceBusinessTier_FieldMask) GetPaths() []ServiceBusinessTier_FieldPath

+ func (fieldMask *ServiceBusinessTier_FieldMask) GetRawPaths() []gotenobject.FieldPath

+ func (fieldMask *ServiceBusinessTier_FieldMask) IsFull() bool

+ func (fieldMask *ServiceBusinessTier_FieldMask) PathsCount() int

+ func (fieldMask *ServiceBusinessTier_FieldMask) Project(source *ServiceBusinessTier) *ServiceBusinessTier

+ func (fieldMask *ServiceBusinessTier_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

+ func (fieldMask *ServiceBusinessTier_FieldMask) ProtoMessage()

+ func (fieldMask *ServiceBusinessTier_FieldMask) ProtoReflect() preflect.Message

+ func (fieldMask *ServiceBusinessTier_FieldMask) Reset()

+ func (fieldMask *ServiceBusinessTier_FieldMask) Set(target, source *ServiceBusinessTier)

+ func (fieldMask *ServiceBusinessTier_FieldMask) SetFromCliFlag(raw string) error

+ func (fieldMask *ServiceBusinessTier_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt)

+ func (fieldMask *ServiceBusinessTier_FieldMask) Size() int

+ func (fieldMask *ServiceBusinessTier_FieldMask) String() string

+ func (fieldMask *ServiceBusinessTier_FieldMask) Subtract(other *ServiceBusinessTier_FieldMask) *ServiceBusinessTier_FieldMask

+ func (fieldMask *ServiceBusinessTier_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

+ func (fieldMask *ServiceBusinessTier_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

+ func (fieldMask *ServiceBusinessTier_FieldMask) Unmarshal(data []byte) error

+ func (fieldMask *ServiceBusinessTier_FieldMask) UnmarshalJSON(data []byte) error

+ func (fieldMask ServiceBusinessTier_FieldMask) Marshal() ([]byte, error)

+ func (fieldMask ServiceBusinessTier_FieldMask) MarshalJSON() ([]byte, error)

+ type ServiceBusinessTier_FieldPath interface

+ ClearValue func(item *ServiceBusinessTier)

+ Get func(source *ServiceBusinessTier) []interface{}

+ GetSingle func(source *ServiceBusinessTier) (interface{}, bool)

+ Selector func() ServiceBusinessTier_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) ServiceBusinessTier_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) ServiceBusinessTier_FieldPathArrayOfValues

+ WithIValue func(value interface{}) ServiceBusinessTier_FieldPathValue

+ func BuildServiceBusinessTier_FieldPath(fp gotenobject.RawFieldPath) (ServiceBusinessTier_FieldPath, error)

+ func MustParseServiceBusinessTier_FieldPath(rawField string) ServiceBusinessTier_FieldPath

+ func ParseServiceBusinessTier_FieldPath(rawField string) (ServiceBusinessTier_FieldPath, error)

+ type ServiceBusinessTier_FieldPathArrayItemValue interface

+ ContainsValue func(*ServiceBusinessTier) bool

+ func MustParseServiceBusinessTier_FieldPathArrayItemValue(pathStr, valueStr string) ServiceBusinessTier_FieldPathArrayItemValue

+ func ParseServiceBusinessTier_FieldPathArrayItemValue(pathStr, valueStr string) (ServiceBusinessTier_FieldPathArrayItemValue, error)

+ type ServiceBusinessTier_FieldPathArrayOfValues interface

+ func MustParseServiceBusinessTier_FieldPathArrayOfValues(pathStr, valuesStr string) ServiceBusinessTier_FieldPathArrayOfValues

+ func ParseServiceBusinessTier_FieldPathArrayOfValues(pathStr, valuesStr string) (ServiceBusinessTier_FieldPathArrayOfValues, error)

+ type ServiceBusinessTier_FieldPathSelector int32

+ const ServiceBusinessTier_FieldPathSelectorBusinessTier

+ const ServiceBusinessTier_FieldPathSelectorService

+ func (s ServiceBusinessTier_FieldPathSelector) String() string

+ type ServiceBusinessTier_FieldPathValue interface

+ CompareWith func(*ServiceBusinessTier) (cmp int, comparable bool)

+ SetTo func(target **ServiceBusinessTier)

+ func MustParseServiceBusinessTier_FieldPathValue(pathStr, valueStr string) ServiceBusinessTier_FieldPathValue

+ func ParseServiceBusinessTier_FieldPathValue(pathStr, valueStr string) (ServiceBusinessTier_FieldPathValue, error)

+ type ServiceBusinessTier_FieldTerminalPath struct

+ func (fp *ServiceBusinessTier_FieldTerminalPath) ClearValue(item *ServiceBusinessTier)

+ func (fp *ServiceBusinessTier_FieldTerminalPath) ClearValueRaw(item proto.Message)

+ func (fp *ServiceBusinessTier_FieldTerminalPath) Get(source *ServiceBusinessTier) (values []interface{})

+ func (fp *ServiceBusinessTier_FieldTerminalPath) GetDefault() interface{}

+ func (fp *ServiceBusinessTier_FieldTerminalPath) GetRaw(source proto.Message) []interface{}

+ func (fp *ServiceBusinessTier_FieldTerminalPath) GetSingle(source *ServiceBusinessTier) (interface{}, bool)

+ func (fp *ServiceBusinessTier_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fp *ServiceBusinessTier_FieldTerminalPath) IsLeaf() bool

+ func (fp *ServiceBusinessTier_FieldTerminalPath) JSONString() string

+ func (fp *ServiceBusinessTier_FieldTerminalPath) Selector() ServiceBusinessTier_FieldPathSelector

+ func (fp *ServiceBusinessTier_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

+ func (fp *ServiceBusinessTier_FieldTerminalPath) String() string

+ func (fp *ServiceBusinessTier_FieldTerminalPath) WithIArrayItemValue(value interface{}) ServiceBusinessTier_FieldPathArrayItemValue

+ func (fp *ServiceBusinessTier_FieldTerminalPath) WithIArrayOfValues(values interface{}) ServiceBusinessTier_FieldPathArrayOfValues

+ func (fp *ServiceBusinessTier_FieldTerminalPath) WithIValue(value interface{}) ServiceBusinessTier_FieldPathValue

+ func (fp *ServiceBusinessTier_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fp *ServiceBusinessTier_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fp *ServiceBusinessTier_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type ServiceBusinessTier_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *ServiceBusinessTier_FieldTerminalPathArrayItemValue) ContainsValue(source *ServiceBusinessTier) bool

+ func (fpaiv *ServiceBusinessTier_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

+ func (fpaiv *ServiceBusinessTier_FieldTerminalPathArrayItemValue) GetSingle(source *ServiceBusinessTier) (interface{}, bool)

+ func (fpaiv *ServiceBusinessTier_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool)

+ type ServiceBusinessTier_FieldTerminalPathArrayOfValues struct

+ func (fpaov *ServiceBusinessTier_FieldTerminalPathArrayOfValues) AsBusinessTierArrayOfValues() ([]BusinessTier, bool)

+ func (fpaov *ServiceBusinessTier_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*meta_service.Reference, bool)

+ func (fpaov *ServiceBusinessTier_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{})

+ type ServiceBusinessTier_FieldTerminalPathValue struct

+ func (fpv *ServiceBusinessTier_FieldTerminalPathValue) AsBusinessTierValue() (BusinessTier, bool)

+ func (fpv *ServiceBusinessTier_FieldTerminalPathValue) AsServiceValue() (*meta_service.Reference, bool)

+ func (fpv *ServiceBusinessTier_FieldTerminalPathValue) CompareWith(source *ServiceBusinessTier) (int, bool)

+ func (fpv *ServiceBusinessTier_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpv *ServiceBusinessTier_FieldTerminalPathValue) GetRawValue() interface{}

+ func (fpv *ServiceBusinessTier_FieldTerminalPathValue) SetTo(target **ServiceBusinessTier)

+ func (fpv *ServiceBusinessTier_FieldTerminalPathValue) SetToRaw(target proto.Message)

+ type ServiceErrors struct

+ Errors []*ServiceErrors_Error

+ func (*ServiceErrors) Descriptor() ([]byte, []int)

+ func (*ServiceErrors) GotenMessage()

+ func (*ServiceErrors) ProtoMessage()

+ func (m *ServiceErrors) GetErrors() []*ServiceErrors_Error

+ func (m *ServiceErrors) Marshal() ([]byte, error)

+ func (m *ServiceErrors) MarshalJSON() ([]byte, error)

+ func (m *ServiceErrors) ProtoReflect() preflect.Message

+ func (m *ServiceErrors) Reset()

+ func (m *ServiceErrors) SetErrors(fv []*ServiceErrors_Error)

+ func (m *ServiceErrors) String() string

+ func (m *ServiceErrors) Unmarshal(b []byte) error

+ func (m *ServiceErrors) UnmarshalJSON(data []byte) error

+ func (o *ServiceErrors) Clone() *ServiceErrors

+ func (o *ServiceErrors) CloneRaw() gotenobject.GotenObjectExt

+ func (o *ServiceErrors) GotenObjectExt()

+ func (o *ServiceErrors) MakeDiffFieldMask(other *ServiceErrors) *ServiceErrors_FieldMask

+ func (o *ServiceErrors) MakeFullFieldMask() *ServiceErrors_FieldMask

+ func (o *ServiceErrors) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

+ func (o *ServiceErrors) MakeRawFullFieldMask() gotenobject.FieldMask

+ func (o *ServiceErrors) Merge(source *ServiceErrors)

+ func (o *ServiceErrors) MergeRaw(source gotenobject.GotenObjectExt)

+ func (obj *ServiceErrors) GotenValidate() error

+ type ServiceErrorsErrorFieldPathBuilder struct

+ func NewServiceErrorsErrorFieldPathBuilder() ServiceErrorsErrorFieldPathBuilder

+ func (ServiceErrorsErrorFieldPathBuilder) Message() ServiceErrors_ErrorPathSelectorMessage

+ func (ServiceErrorsErrorFieldPathBuilder) Service() ServiceErrors_ErrorPathSelectorService

+ type ServiceErrorsError_FieldPath interface

+ ClearValue func(item *ServiceErrors_Error)

+ Get func(source *ServiceErrors_Error) []interface{}

+ GetSingle func(source *ServiceErrors_Error) (interface{}, bool)

+ Selector func() ServiceErrorsError_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) ServiceErrorsError_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) ServiceErrorsError_FieldPathArrayOfValues

+ WithIValue func(value interface{}) ServiceErrorsError_FieldPathValue

+ func BuildServiceErrorsError_FieldPath(fp gotenobject.RawFieldPath) (ServiceErrorsError_FieldPath, error)

+ func MustParseServiceErrorsError_FieldPath(rawField string) ServiceErrorsError_FieldPath

+ func ParseServiceErrorsError_FieldPath(rawField string) (ServiceErrorsError_FieldPath, error)

+ type ServiceErrorsError_FieldPathArrayItemValue interface

+ ContainsValue func(*ServiceErrors_Error) bool

+ func MustParseServiceErrorsError_FieldPathArrayItemValue(pathStr, valueStr string) ServiceErrorsError_FieldPathArrayItemValue

+ func ParseServiceErrorsError_FieldPathArrayItemValue(pathStr, valueStr string) (ServiceErrorsError_FieldPathArrayItemValue, error)

+ type ServiceErrorsError_FieldPathArrayOfValues interface

+ func MustParseServiceErrorsError_FieldPathArrayOfValues(pathStr, valuesStr string) ServiceErrorsError_FieldPathArrayOfValues

+ func ParseServiceErrorsError_FieldPathArrayOfValues(pathStr, valuesStr string) (ServiceErrorsError_FieldPathArrayOfValues, error)

+ type ServiceErrorsError_FieldPathSelector int32

+ const ServiceErrorsError_FieldPathSelectorMessage

+ const ServiceErrorsError_FieldPathSelectorService

+ func (s ServiceErrorsError_FieldPathSelector) String() string

+ type ServiceErrorsError_FieldPathValue interface

+ CompareWith func(*ServiceErrors_Error) (cmp int, comparable bool)

+ SetTo func(target **ServiceErrors_Error)

+ func MustParseServiceErrorsError_FieldPathValue(pathStr, valueStr string) ServiceErrorsError_FieldPathValue

+ func ParseServiceErrorsError_FieldPathValue(pathStr, valueStr string) (ServiceErrorsError_FieldPathValue, error)

+ type ServiceErrorsError_FieldTerminalPath struct

+ func (fp *ServiceErrorsError_FieldTerminalPath) ClearValue(item *ServiceErrors_Error)

+ func (fp *ServiceErrorsError_FieldTerminalPath) ClearValueRaw(item proto.Message)

+ func (fp *ServiceErrorsError_FieldTerminalPath) Get(source *ServiceErrors_Error) (values []interface{})

+ func (fp *ServiceErrorsError_FieldTerminalPath) GetDefault() interface{}

+ func (fp *ServiceErrorsError_FieldTerminalPath) GetRaw(source proto.Message) []interface{}

+ func (fp *ServiceErrorsError_FieldTerminalPath) GetSingle(source *ServiceErrors_Error) (interface{}, bool)

+ func (fp *ServiceErrorsError_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fp *ServiceErrorsError_FieldTerminalPath) IsLeaf() bool

+ func (fp *ServiceErrorsError_FieldTerminalPath) JSONString() string

+ func (fp *ServiceErrorsError_FieldTerminalPath) Selector() ServiceErrorsError_FieldPathSelector

+ func (fp *ServiceErrorsError_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

+ func (fp *ServiceErrorsError_FieldTerminalPath) String() string

+ func (fp *ServiceErrorsError_FieldTerminalPath) WithIArrayItemValue(value interface{}) ServiceErrorsError_FieldPathArrayItemValue

+ func (fp *ServiceErrorsError_FieldTerminalPath) WithIArrayOfValues(values interface{}) ServiceErrorsError_FieldPathArrayOfValues

+ func (fp *ServiceErrorsError_FieldTerminalPath) WithIValue(value interface{}) ServiceErrorsError_FieldPathValue

+ func (fp *ServiceErrorsError_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fp *ServiceErrorsError_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fp *ServiceErrorsError_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type ServiceErrorsError_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *ServiceErrorsError_FieldTerminalPathArrayItemValue) ContainsValue(source *ServiceErrors_Error) bool

+ func (fpaiv *ServiceErrorsError_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

+ func (fpaiv *ServiceErrorsError_FieldTerminalPathArrayItemValue) GetSingle(source *ServiceErrors_Error) (interface{}, bool)

+ func (fpaiv *ServiceErrorsError_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool)

+ type ServiceErrorsError_FieldTerminalPathArrayOfValues struct

+ func (fpaov *ServiceErrorsError_FieldTerminalPathArrayOfValues) AsMessageArrayOfValues() ([]string, bool)

+ func (fpaov *ServiceErrorsError_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*meta_service.Reference, bool)

+ func (fpaov *ServiceErrorsError_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{})

+ type ServiceErrorsError_FieldTerminalPathValue struct

+ func (fpv *ServiceErrorsError_FieldTerminalPathValue) AsMessageValue() (string, bool)

+ func (fpv *ServiceErrorsError_FieldTerminalPathValue) AsServiceValue() (*meta_service.Reference, bool)

+ func (fpv *ServiceErrorsError_FieldTerminalPathValue) CompareWith(source *ServiceErrors_Error) (int, bool)

+ func (fpv *ServiceErrorsError_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpv *ServiceErrorsError_FieldTerminalPathValue) GetRawValue() interface{}

+ func (fpv *ServiceErrorsError_FieldTerminalPathValue) SetTo(target **ServiceErrors_Error)

+ func (fpv *ServiceErrorsError_FieldTerminalPathValue) SetToRaw(target proto.Message)

+ type ServiceErrorsFieldPathBuilder struct

+ func NewServiceErrorsFieldPathBuilder() ServiceErrorsFieldPathBuilder

+ func (ServiceErrorsFieldPathBuilder) Errors() ServiceErrorsPathSelectorErrors

+ type ServiceErrorsPathSelectorErrors struct

+ func (ServiceErrorsPathSelectorErrors) FieldPath() *ServiceErrors_FieldTerminalPath

+ func (ServiceErrorsPathSelectorErrors) Message() ServiceErrorsPathSelectorErrorsMessage

+ func (ServiceErrorsPathSelectorErrors) Service() ServiceErrorsPathSelectorErrorsService

+ func (ServiceErrorsPathSelectorErrors) WithSubPath(subPath ServiceErrorsError_FieldPath) *ServiceErrors_FieldSubPath

+ func (s ServiceErrorsPathSelectorErrors) WithArrayOfValues(values [][]*ServiceErrors_Error) *ServiceErrors_FieldTerminalPathArrayOfValues

+ func (s ServiceErrorsPathSelectorErrors) WithItemValue(value *ServiceErrors_Error) *ServiceErrors_FieldTerminalPathArrayItemValue

+ func (s ServiceErrorsPathSelectorErrors) WithSubArrayItemValue(subPathArrayItemValue ServiceErrorsError_FieldPathArrayItemValue) *ServiceErrors_FieldSubPathArrayItemValue

+ func (s ServiceErrorsPathSelectorErrors) WithSubArrayOfValues(subPathArrayOfValues ServiceErrorsError_FieldPathArrayOfValues) *ServiceErrors_FieldSubPathArrayOfValues

+ func (s ServiceErrorsPathSelectorErrors) WithSubValue(subPathValue ServiceErrorsError_FieldPathValue) *ServiceErrors_FieldSubPathValue

+ func (s ServiceErrorsPathSelectorErrors) WithValue(value []*ServiceErrors_Error) *ServiceErrors_FieldTerminalPathValue

+ type ServiceErrorsPathSelectorErrorsMessage struct

+ func (ServiceErrorsPathSelectorErrorsMessage) FieldPath() *ServiceErrors_FieldSubPath

+ func (s ServiceErrorsPathSelectorErrorsMessage) WithArrayOfValues(values []string) *ServiceErrors_FieldSubPathArrayOfValues

+ func (s ServiceErrorsPathSelectorErrorsMessage) WithValue(value string) *ServiceErrors_FieldSubPathValue

+ type ServiceErrorsPathSelectorErrorsService struct

+ func (ServiceErrorsPathSelectorErrorsService) FieldPath() *ServiceErrors_FieldSubPath

+ func (s ServiceErrorsPathSelectorErrorsService) WithArrayOfValues(values []*meta_service.Reference) *ServiceErrors_FieldSubPathArrayOfValues

+ func (s ServiceErrorsPathSelectorErrorsService) WithValue(value *meta_service.Reference) *ServiceErrors_FieldSubPathValue

+ type ServiceErrors_Error struct

+ Message string

+ Service *meta_service.Reference

+ func (*ServiceErrors_Error) Descriptor() ([]byte, []int)

+ func (*ServiceErrors_Error) GotenMessage()

+ func (*ServiceErrors_Error) ProtoMessage()

+ func (m *ServiceErrors_Error) GetMessage() string

+ func (m *ServiceErrors_Error) GetService() *meta_service.Reference

+ func (m *ServiceErrors_Error) Marshal() ([]byte, error)

+ func (m *ServiceErrors_Error) MarshalJSON() ([]byte, error)

+ func (m *ServiceErrors_Error) ProtoReflect() preflect.Message

+ func (m *ServiceErrors_Error) Reset()

+ func (m *ServiceErrors_Error) SetMessage(fv string)

+ func (m *ServiceErrors_Error) SetService(fv *meta_service.Reference)

+ func (m *ServiceErrors_Error) String() string

+ func (m *ServiceErrors_Error) Unmarshal(b []byte) error

+ func (m *ServiceErrors_Error) UnmarshalJSON(data []byte) error

+ func (o *ServiceErrors_Error) Clone() *ServiceErrors_Error

+ func (o *ServiceErrors_Error) CloneRaw() gotenobject.GotenObjectExt

+ func (o *ServiceErrors_Error) GotenObjectExt()

+ func (o *ServiceErrors_Error) MakeDiffFieldMask(other *ServiceErrors_Error) *ServiceErrors_Error_FieldMask

+ func (o *ServiceErrors_Error) MakeFullFieldMask() *ServiceErrors_Error_FieldMask

+ func (o *ServiceErrors_Error) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

+ func (o *ServiceErrors_Error) MakeRawFullFieldMask() gotenobject.FieldMask

+ func (o *ServiceErrors_Error) Merge(source *ServiceErrors_Error)

+ func (o *ServiceErrors_Error) MergeRaw(source gotenobject.GotenObjectExt)

+ func (obj *ServiceErrors_Error) GotenValidate() error

+ type ServiceErrors_ErrorPathSelectorMessage struct

+ func (ServiceErrors_ErrorPathSelectorMessage) FieldPath() *ServiceErrorsError_FieldTerminalPath

+ func (s ServiceErrors_ErrorPathSelectorMessage) WithArrayOfValues(values []string) *ServiceErrorsError_FieldTerminalPathArrayOfValues

+ func (s ServiceErrors_ErrorPathSelectorMessage) WithValue(value string) *ServiceErrorsError_FieldTerminalPathValue

+ type ServiceErrors_ErrorPathSelectorService struct

+ func (ServiceErrors_ErrorPathSelectorService) FieldPath() *ServiceErrorsError_FieldTerminalPath

+ func (s ServiceErrors_ErrorPathSelectorService) WithArrayOfValues(values []*meta_service.Reference) *ServiceErrorsError_FieldTerminalPathArrayOfValues

+ func (s ServiceErrors_ErrorPathSelectorService) WithValue(value *meta_service.Reference) *ServiceErrorsError_FieldTerminalPathValue

+ type ServiceErrors_Error_FieldMask struct

+ Paths []ServiceErrorsError_FieldPath

+ func FullServiceErrors_Error_FieldMask() *ServiceErrors_Error_FieldMask

+ func (fieldMask *ServiceErrors_Error_FieldMask) AppendPath(path ServiceErrorsError_FieldPath)

+ func (fieldMask *ServiceErrors_Error_FieldMask) AppendRawPath(path gotenobject.FieldPath)

+ func (fieldMask *ServiceErrors_Error_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

+ func (fieldMask *ServiceErrors_Error_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

+ func (fieldMask *ServiceErrors_Error_FieldMask) FilterInputFields() *ServiceErrors_Error_FieldMask

+ func (fieldMask *ServiceErrors_Error_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

+ func (fieldMask *ServiceErrors_Error_FieldMask) GetPaths() []ServiceErrorsError_FieldPath

+ func (fieldMask *ServiceErrors_Error_FieldMask) GetRawPaths() []gotenobject.FieldPath

+ func (fieldMask *ServiceErrors_Error_FieldMask) IsFull() bool

+ func (fieldMask *ServiceErrors_Error_FieldMask) PathsCount() int

+ func (fieldMask *ServiceErrors_Error_FieldMask) Project(source *ServiceErrors_Error) *ServiceErrors_Error

+ func (fieldMask *ServiceErrors_Error_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

+ func (fieldMask *ServiceErrors_Error_FieldMask) ProtoMessage()

+ func (fieldMask *ServiceErrors_Error_FieldMask) ProtoReflect() preflect.Message

+ func (fieldMask *ServiceErrors_Error_FieldMask) Reset()

+ func (fieldMask *ServiceErrors_Error_FieldMask) Set(target, source *ServiceErrors_Error)

+ func (fieldMask *ServiceErrors_Error_FieldMask) SetFromCliFlag(raw string) error

+ func (fieldMask *ServiceErrors_Error_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt)

+ func (fieldMask *ServiceErrors_Error_FieldMask) Size() int

+ func (fieldMask *ServiceErrors_Error_FieldMask) String() string

+ func (fieldMask *ServiceErrors_Error_FieldMask) Subtract(other *ServiceErrors_Error_FieldMask) *ServiceErrors_Error_FieldMask

+ func (fieldMask *ServiceErrors_Error_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

+ func (fieldMask *ServiceErrors_Error_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

+ func (fieldMask *ServiceErrors_Error_FieldMask) Unmarshal(data []byte) error

+ func (fieldMask *ServiceErrors_Error_FieldMask) UnmarshalJSON(data []byte) error

+ func (fieldMask ServiceErrors_Error_FieldMask) Marshal() ([]byte, error)

+ func (fieldMask ServiceErrors_Error_FieldMask) MarshalJSON() ([]byte, error)

+ type ServiceErrors_FieldMask struct

+ Paths []ServiceErrors_FieldPath

+ func FullServiceErrors_FieldMask() *ServiceErrors_FieldMask

+ func (fieldMask *ServiceErrors_FieldMask) AppendPath(path ServiceErrors_FieldPath)

+ func (fieldMask *ServiceErrors_FieldMask) AppendRawPath(path gotenobject.FieldPath)

+ func (fieldMask *ServiceErrors_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

+ func (fieldMask *ServiceErrors_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

+ func (fieldMask *ServiceErrors_FieldMask) FilterInputFields() *ServiceErrors_FieldMask

+ func (fieldMask *ServiceErrors_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

+ func (fieldMask *ServiceErrors_FieldMask) GetPaths() []ServiceErrors_FieldPath

+ func (fieldMask *ServiceErrors_FieldMask) GetRawPaths() []gotenobject.FieldPath

+ func (fieldMask *ServiceErrors_FieldMask) IsFull() bool

+ func (fieldMask *ServiceErrors_FieldMask) PathsCount() int

+ func (fieldMask *ServiceErrors_FieldMask) Project(source *ServiceErrors) *ServiceErrors

+ func (fieldMask *ServiceErrors_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

+ func (fieldMask *ServiceErrors_FieldMask) ProtoMessage()

+ func (fieldMask *ServiceErrors_FieldMask) ProtoReflect() preflect.Message

+ func (fieldMask *ServiceErrors_FieldMask) Reset()

+ func (fieldMask *ServiceErrors_FieldMask) Set(target, source *ServiceErrors)

+ func (fieldMask *ServiceErrors_FieldMask) SetFromCliFlag(raw string) error

+ func (fieldMask *ServiceErrors_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt)

+ func (fieldMask *ServiceErrors_FieldMask) Size() int

+ func (fieldMask *ServiceErrors_FieldMask) String() string

+ func (fieldMask *ServiceErrors_FieldMask) Subtract(other *ServiceErrors_FieldMask) *ServiceErrors_FieldMask

+ func (fieldMask *ServiceErrors_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

+ func (fieldMask *ServiceErrors_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

+ func (fieldMask *ServiceErrors_FieldMask) Unmarshal(data []byte) error

+ func (fieldMask *ServiceErrors_FieldMask) UnmarshalJSON(data []byte) error

+ func (fieldMask ServiceErrors_FieldMask) Marshal() ([]byte, error)

+ func (fieldMask ServiceErrors_FieldMask) MarshalJSON() ([]byte, error)

+ type ServiceErrors_FieldPath interface

+ ClearValue func(item *ServiceErrors)

+ Get func(source *ServiceErrors) []interface{}

+ GetSingle func(source *ServiceErrors) (interface{}, bool)

+ Selector func() ServiceErrors_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) ServiceErrors_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) ServiceErrors_FieldPathArrayOfValues

+ WithIValue func(value interface{}) ServiceErrors_FieldPathValue

+ func BuildServiceErrors_FieldPath(fp gotenobject.RawFieldPath) (ServiceErrors_FieldPath, error)

+ func MustParseServiceErrors_FieldPath(rawField string) ServiceErrors_FieldPath

+ func ParseServiceErrors_FieldPath(rawField string) (ServiceErrors_FieldPath, error)

+ type ServiceErrors_FieldPathArrayItemValue interface

+ ContainsValue func(*ServiceErrors) bool

+ func MustParseServiceErrors_FieldPathArrayItemValue(pathStr, valueStr string) ServiceErrors_FieldPathArrayItemValue

+ func ParseServiceErrors_FieldPathArrayItemValue(pathStr, valueStr string) (ServiceErrors_FieldPathArrayItemValue, error)

+ type ServiceErrors_FieldPathArrayOfValues interface

+ func MustParseServiceErrors_FieldPathArrayOfValues(pathStr, valuesStr string) ServiceErrors_FieldPathArrayOfValues

+ func ParseServiceErrors_FieldPathArrayOfValues(pathStr, valuesStr string) (ServiceErrors_FieldPathArrayOfValues, error)

+ type ServiceErrors_FieldPathSelector int32

+ const ServiceErrors_FieldPathSelectorErrors

+ func (s ServiceErrors_FieldPathSelector) String() string

+ type ServiceErrors_FieldPathValue interface

+ CompareWith func(*ServiceErrors) (cmp int, comparable bool)

+ SetTo func(target **ServiceErrors)

+ func MustParseServiceErrors_FieldPathValue(pathStr, valueStr string) ServiceErrors_FieldPathValue

+ func ParseServiceErrors_FieldPathValue(pathStr, valueStr string) (ServiceErrors_FieldPathValue, error)

+ type ServiceErrors_FieldSubPath struct

+ func (fps *ServiceErrors_FieldSubPath) AsErrorsSubPath() (ServiceErrorsError_FieldPath, bool)

+ func (fps *ServiceErrors_FieldSubPath) ClearValue(item *ServiceErrors)

+ func (fps *ServiceErrors_FieldSubPath) ClearValueRaw(item proto.Message)

+ func (fps *ServiceErrors_FieldSubPath) Get(source *ServiceErrors) (values []interface{})

+ func (fps *ServiceErrors_FieldSubPath) GetDefault() interface{}

+ func (fps *ServiceErrors_FieldSubPath) GetRaw(source proto.Message) []interface{}

+ func (fps *ServiceErrors_FieldSubPath) GetSingle(source *ServiceErrors) (interface{}, bool)

+ func (fps *ServiceErrors_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fps *ServiceErrors_FieldSubPath) IsLeaf() bool

+ func (fps *ServiceErrors_FieldSubPath) JSONString() string

+ func (fps *ServiceErrors_FieldSubPath) Selector() ServiceErrors_FieldPathSelector

+ func (fps *ServiceErrors_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

+ func (fps *ServiceErrors_FieldSubPath) String() string

+ func (fps *ServiceErrors_FieldSubPath) WithIArrayItemValue(value interface{}) ServiceErrors_FieldPathArrayItemValue

+ func (fps *ServiceErrors_FieldSubPath) WithIArrayOfValues(values interface{}) ServiceErrors_FieldPathArrayOfValues

+ func (fps *ServiceErrors_FieldSubPath) WithIValue(value interface{}) ServiceErrors_FieldPathValue

+ func (fps *ServiceErrors_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fps *ServiceErrors_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fps *ServiceErrors_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type ServiceErrors_FieldSubPathArrayItemValue struct

+ func (fpaivs *ServiceErrors_FieldSubPathArrayItemValue) AsErrorsPathItemValue() (ServiceErrorsError_FieldPathArrayItemValue, bool)

+ func (fpaivs *ServiceErrors_FieldSubPathArrayItemValue) ContainsValue(source *ServiceErrors) bool

+ func (fpaivs *ServiceErrors_FieldSubPathArrayItemValue) GetRawItemValue() interface{}

+ type ServiceErrors_FieldSubPathArrayOfValues struct

+ func (fpsaov *ServiceErrors_FieldSubPathArrayOfValues) AsErrorsPathArrayOfValues() (ServiceErrorsError_FieldPathArrayOfValues, bool)

+ func (fpsaov *ServiceErrors_FieldSubPathArrayOfValues) GetRawValues() []interface{}

+ type ServiceErrors_FieldSubPathValue struct

+ func (fpvs *ServiceErrors_FieldSubPathValue) AsErrorsPathValue() (ServiceErrorsError_FieldPathValue, bool)

+ func (fpvs *ServiceErrors_FieldSubPathValue) CompareWith(source *ServiceErrors) (int, bool)

+ func (fpvs *ServiceErrors_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpvs *ServiceErrors_FieldSubPathValue) GetRawValue() interface{}

+ func (fpvs *ServiceErrors_FieldSubPathValue) SetTo(target **ServiceErrors)

+ func (fpvs *ServiceErrors_FieldSubPathValue) SetToRaw(target proto.Message)

+ type ServiceErrors_FieldTerminalPath struct

+ func (fp *ServiceErrors_FieldTerminalPath) ClearValue(item *ServiceErrors)

+ func (fp *ServiceErrors_FieldTerminalPath) ClearValueRaw(item proto.Message)

+ func (fp *ServiceErrors_FieldTerminalPath) Get(source *ServiceErrors) (values []interface{})

+ func (fp *ServiceErrors_FieldTerminalPath) GetDefault() interface{}

+ func (fp *ServiceErrors_FieldTerminalPath) GetRaw(source proto.Message) []interface{}

+ func (fp *ServiceErrors_FieldTerminalPath) GetSingle(source *ServiceErrors) (interface{}, bool)

+ func (fp *ServiceErrors_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fp *ServiceErrors_FieldTerminalPath) IsLeaf() bool

+ func (fp *ServiceErrors_FieldTerminalPath) JSONString() string

+ func (fp *ServiceErrors_FieldTerminalPath) Selector() ServiceErrors_FieldPathSelector

+ func (fp *ServiceErrors_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

+ func (fp *ServiceErrors_FieldTerminalPath) String() string

+ func (fp *ServiceErrors_FieldTerminalPath) WithIArrayItemValue(value interface{}) ServiceErrors_FieldPathArrayItemValue

+ func (fp *ServiceErrors_FieldTerminalPath) WithIArrayOfValues(values interface{}) ServiceErrors_FieldPathArrayOfValues

+ func (fp *ServiceErrors_FieldTerminalPath) WithIValue(value interface{}) ServiceErrors_FieldPathValue

+ func (fp *ServiceErrors_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fp *ServiceErrors_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fp *ServiceErrors_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type ServiceErrors_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) AsErrorsItemValue() (*ServiceErrors_Error, bool)

+ func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) ContainsValue(source *ServiceErrors) bool

+ func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

+ func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) GetSingle(source *ServiceErrors) (interface{}, bool)

+ func (fpaiv *ServiceErrors_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool)

+ type ServiceErrors_FieldTerminalPathArrayOfValues struct

+ func (fpaov *ServiceErrors_FieldTerminalPathArrayOfValues) AsErrorsArrayOfValues() ([][]*ServiceErrors_Error, bool)

+ func (fpaov *ServiceErrors_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{})

+ type ServiceErrors_FieldTerminalPathValue struct

+ func (fpv *ServiceErrors_FieldTerminalPathValue) AsErrorsValue() ([]*ServiceErrors_Error, bool)

+ func (fpv *ServiceErrors_FieldTerminalPathValue) CompareWith(source *ServiceErrors) (int, bool)

+ func (fpv *ServiceErrors_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpv *ServiceErrors_FieldTerminalPathValue) GetRawValue() interface{}

+ func (fpv *ServiceErrors_FieldTerminalPathValue) SetTo(target **ServiceErrors)

+ func (fpv *ServiceErrors_FieldTerminalPathValue) SetToRaw(target proto.Message)

Sep 9, 2022

Changes in this version

type Actor_FieldTerminalPath

+ func (fp *Actor_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

type Invitation_FieldPathMap

+ func (fpm *Invitation_FieldPathMap) SplitIntoTerminalIPaths() []gotenobject.FieldPath

type Invitation_FieldSubPath

+ func (fps *Invitation_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

type Invitation_FieldTerminalPath

+ func (fp *Invitation_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

type PCR_FieldTerminalPath

+ func (fp *PCR_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

Jun 6, 2022

Changes in this version

type Invitation

+ Extras map[string]string

+ func (m *Invitation) GetExtras() map[string]string

+ func (m *Invitation) SetExtras(fv map[string]string)

type InvitationFieldPathBuilder

+ func (InvitationFieldPathBuilder) Extras() InvitationPathSelectorExtras

+ type InvitationMapPathSelectorExtras struct

+ func (s InvitationMapPathSelectorExtras) FieldPath() *Invitation_FieldPathMap

+ func (s InvitationMapPathSelectorExtras) WithArrayOfValues(values []string) *Invitation_FieldPathMapArrayOfValues

+ func (s InvitationMapPathSelectorExtras) WithValue(value string) *Invitation_FieldPathMapValue

+ type InvitationPathSelectorExtras struct

+ func (InvitationPathSelectorExtras) FieldPath() *Invitation_FieldTerminalPath

+ func (InvitationPathSelectorExtras) WithKey(key string) InvitationMapPathSelectorExtras

+ func (s InvitationPathSelectorExtras) WithArrayOfValues(values []map[string]string) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorExtras) WithValue(value map[string]string) *Invitation_FieldTerminalPathValue

+ type Invitation_FieldPathMap struct

+ func (fpm *Invitation_FieldPathMap) ClearValue(item *Invitation)

+ func (fpm *Invitation_FieldPathMap) ClearValueRaw(item proto.Message)

+ func (fpm *Invitation_FieldPathMap) Get(source *Invitation) (values []interface{})

+ func (fpm *Invitation_FieldPathMap) GetDefault() interface{}

+ func (fpm *Invitation_FieldPathMap) GetRaw(source proto.Message) []interface{}

+ func (fpm *Invitation_FieldPathMap) GetSingle(source *Invitation) (interface{}, bool)

+ func (fpm *Invitation_FieldPathMap) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fpm *Invitation_FieldPathMap) IsLeaf() bool

+ func (fpm *Invitation_FieldPathMap) JSONString() string

+ func (fpm *Invitation_FieldPathMap) Key() string

+ func (fpm *Invitation_FieldPathMap) Selector() Invitation_FieldPathSelector

+ func (fpm *Invitation_FieldPathMap) String() string

+ func (fpm *Invitation_FieldPathMap) WithIArrayItemValue(value interface{}) Invitation_FieldPathArrayItemValue

+ func (fpm *Invitation_FieldPathMap) WithIArrayOfValues(values interface{}) Invitation_FieldPathArrayOfValues

+ func (fpm *Invitation_FieldPathMap) WithIValue(value interface{}) Invitation_FieldPathValue

+ func (fpm *Invitation_FieldPathMap) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fpm *Invitation_FieldPathMap) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fpm *Invitation_FieldPathMap) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type Invitation_FieldPathMapArrayOfValues struct

+ func (fpmaov *Invitation_FieldPathMapArrayOfValues) AsExtrasArrayOfElementValues() ([]string, bool)

+ func (fpmaov *Invitation_FieldPathMapArrayOfValues) GetRawValues() (values []interface{})

+ type Invitation_FieldPathMapValue struct

+ func (fpmv *Invitation_FieldPathMapValue) AsExtrasElementValue() (string, bool)

+ func (fpmv *Invitation_FieldPathMapValue) CompareWith(source *Invitation) (int, bool)

+ func (fpmv *Invitation_FieldPathMapValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpmv *Invitation_FieldPathMapValue) GetRawValue() interface{}

+ func (fpmv *Invitation_FieldPathMapValue) SetTo(target **Invitation)

+ func (fpmv *Invitation_FieldPathMapValue) SetToRaw(target proto.Message)

type Invitation_FieldPathSelector

+ const Invitation_FieldPathSelectorExtras

type Invitation_FieldTerminalPathArrayOfValues

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsExtrasArrayOfValues() ([]map[string]string, bool)

type Invitation_FieldTerminalPathValue

+ func (fpv *Invitation_FieldTerminalPathValue) AsExtrasValue() (map[string]string, bool)

May 9, 2022

Changes in this version

type Invitation

+ LanguageCode string

+ func (m *Invitation) GetLanguageCode() string

+ func (m *Invitation) SetLanguageCode(fv string)

type InvitationFieldPathBuilder

+ func (InvitationFieldPathBuilder) LanguageCode() InvitationPathSelectorLanguageCode

+ type InvitationPathSelectorLanguageCode struct

+ func (InvitationPathSelectorLanguageCode) FieldPath() *Invitation_FieldTerminalPath

+ func (s InvitationPathSelectorLanguageCode) WithArrayOfValues(values []string) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorLanguageCode) WithValue(value string) *Invitation_FieldTerminalPathValue

type Invitation_FieldPathSelector

+ const Invitation_FieldPathSelectorLanguageCode

type Invitation_FieldTerminalPathArrayOfValues

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsLanguageCodeArrayOfValues() ([]string, bool)

type Invitation_FieldTerminalPathValue

+ func (fpv *Invitation_FieldTerminalPathValue) AsLanguageCodeValue() (string, bool)

Feb 17, 2022

Changes in this version

+ var DigestAlg_name = map[int32]string

+ var DigestAlg_value = map[string]int32

+ var Invitation_State_name = map[int32]string

+ var Invitation_State_value = map[string]int32

+ var TpmVersion_name = map[int32]string

+ var TpmVersion_value = map[string]int32

+ type Actor struct

+ ServiceAccount *service_account.Reference

+ User *user.Reference

+ func (*Actor) Descriptor() ([]byte, []int)

+ func (*Actor) GotenMessage()

+ func (*Actor) ProtoMessage()

+ func (m *Actor) GetServiceAccount() *service_account.Reference

+ func (m *Actor) GetUser() *user.Reference

+ func (m *Actor) Marshal() ([]byte, error)

+ func (m *Actor) MarshalJSON() ([]byte, error)

+ func (m *Actor) ProtoReflect() preflect.Message

+ func (m *Actor) Reset()

+ func (m *Actor) SetServiceAccount(fv *service_account.Reference)

+ func (m *Actor) SetUser(fv *user.Reference)

+ func (m *Actor) String() string

+ func (m *Actor) Unmarshal(b []byte) error

+ func (m *Actor) UnmarshalJSON(data []byte) error

+ func (o *Actor) Clone() *Actor

+ func (o *Actor) CloneRaw() gotenobject.GotenObjectExt

+ func (o *Actor) GotenObjectExt()

+ func (o *Actor) MakeDiffFieldMask(other *Actor) *Actor_FieldMask

+ func (o *Actor) MakeFullFieldMask() *Actor_FieldMask

+ func (o *Actor) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

+ func (o *Actor) MakeRawFullFieldMask() gotenobject.FieldMask

+ func (o *Actor) Merge(source *Actor)

+ func (o *Actor) MergeRaw(source gotenobject.GotenObjectExt)

+ func (obj *Actor) GotenValidate() error

+ type ActorFieldPathBuilder struct

+ func NewActorFieldPathBuilder() ActorFieldPathBuilder

+ func (ActorFieldPathBuilder) ServiceAccount() ActorPathSelectorServiceAccount

+ func (ActorFieldPathBuilder) User() ActorPathSelectorUser

+ type ActorPathSelectorServiceAccount struct

+ func (ActorPathSelectorServiceAccount) FieldPath() *Actor_FieldTerminalPath

+ func (s ActorPathSelectorServiceAccount) WithArrayOfValues(values []*service_account.Reference) *Actor_FieldTerminalPathArrayOfValues

+ func (s ActorPathSelectorServiceAccount) WithValue(value *service_account.Reference) *Actor_FieldTerminalPathValue

+ type ActorPathSelectorUser struct

+ func (ActorPathSelectorUser) FieldPath() *Actor_FieldTerminalPath

+ func (s ActorPathSelectorUser) WithArrayOfValues(values []*user.Reference) *Actor_FieldTerminalPathArrayOfValues

+ func (s ActorPathSelectorUser) WithValue(value *user.Reference) *Actor_FieldTerminalPathValue

+ type Actor_FieldMask struct

+ Paths []Actor_FieldPath

+ func FullActor_FieldMask() *Actor_FieldMask

+ func (fieldMask *Actor_FieldMask) AppendPath(path Actor_FieldPath)

+ func (fieldMask *Actor_FieldMask) AppendRawPath(path gotenobject.FieldPath)

+ func (fieldMask *Actor_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

+ func (fieldMask *Actor_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

+ func (fieldMask *Actor_FieldMask) FilterInputFields() *Actor_FieldMask

+ func (fieldMask *Actor_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

+ func (fieldMask *Actor_FieldMask) GetPaths() []Actor_FieldPath

+ func (fieldMask *Actor_FieldMask) GetRawPaths() []gotenobject.FieldPath

+ func (fieldMask *Actor_FieldMask) IsFull() bool

+ func (fieldMask *Actor_FieldMask) PathsCount() int

+ func (fieldMask *Actor_FieldMask) Project(source *Actor) *Actor

+ func (fieldMask *Actor_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

+ func (fieldMask *Actor_FieldMask) ProtoMessage()

+ func (fieldMask *Actor_FieldMask) ProtoReflect() preflect.Message

+ func (fieldMask *Actor_FieldMask) Reset()

+ func (fieldMask *Actor_FieldMask) Set(target, source *Actor)

+ func (fieldMask *Actor_FieldMask) SetFromCliFlag(raw string) error

+ func (fieldMask *Actor_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt)

+ func (fieldMask *Actor_FieldMask) Size() int

+ func (fieldMask *Actor_FieldMask) String() string

+ func (fieldMask *Actor_FieldMask) Subtract(other *Actor_FieldMask) *Actor_FieldMask

+ func (fieldMask *Actor_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

+ func (fieldMask *Actor_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

+ func (fieldMask *Actor_FieldMask) Unmarshal(data []byte) error

+ func (fieldMask *Actor_FieldMask) UnmarshalJSON(data []byte) error

+ func (fieldMask Actor_FieldMask) Marshal() ([]byte, error)

+ func (fieldMask Actor_FieldMask) MarshalJSON() ([]byte, error)

+ type Actor_FieldPath interface

+ ClearValue func(item *Actor)

+ Get func(source *Actor) []interface{}

+ GetSingle func(source *Actor) (interface{}, bool)

+ Selector func() Actor_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) Actor_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) Actor_FieldPathArrayOfValues

+ WithIValue func(value interface{}) Actor_FieldPathValue

+ func BuildActor_FieldPath(fp gotenobject.RawFieldPath) (Actor_FieldPath, error)

+ func MustParseActor_FieldPath(rawField string) Actor_FieldPath

+ func ParseActor_FieldPath(rawField string) (Actor_FieldPath, error)

+ type Actor_FieldPathArrayItemValue interface

+ ContainsValue func(*Actor) bool

+ func MustParseActor_FieldPathArrayItemValue(pathStr, valueStr string) Actor_FieldPathArrayItemValue

+ func ParseActor_FieldPathArrayItemValue(pathStr, valueStr string) (Actor_FieldPathArrayItemValue, error)

+ type Actor_FieldPathArrayOfValues interface

+ func MustParseActor_FieldPathArrayOfValues(pathStr, valuesStr string) Actor_FieldPathArrayOfValues

+ func ParseActor_FieldPathArrayOfValues(pathStr, valuesStr string) (Actor_FieldPathArrayOfValues, error)

+ type Actor_FieldPathSelector int32

+ const Actor_FieldPathSelectorServiceAccount

+ const Actor_FieldPathSelectorUser

+ func (s Actor_FieldPathSelector) String() string

+ type Actor_FieldPathValue interface

+ CompareWith func(*Actor) (cmp int, comparable bool)

+ SetTo func(target **Actor)

+ func MustParseActor_FieldPathValue(pathStr, valueStr string) Actor_FieldPathValue

+ func ParseActor_FieldPathValue(pathStr, valueStr string) (Actor_FieldPathValue, error)

+ type Actor_FieldTerminalPath struct

+ func (fp *Actor_FieldTerminalPath) ClearValue(item *Actor)

+ func (fp *Actor_FieldTerminalPath) ClearValueRaw(item proto.Message)

+ func (fp *Actor_FieldTerminalPath) Get(source *Actor) (values []interface{})

+ func (fp *Actor_FieldTerminalPath) GetDefault() interface{}

+ func (fp *Actor_FieldTerminalPath) GetRaw(source proto.Message) []interface{}

+ func (fp *Actor_FieldTerminalPath) GetSingle(source *Actor) (interface{}, bool)

+ func (fp *Actor_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fp *Actor_FieldTerminalPath) IsLeaf() bool

+ func (fp *Actor_FieldTerminalPath) JSONString() string

+ func (fp *Actor_FieldTerminalPath) Selector() Actor_FieldPathSelector

+ func (fp *Actor_FieldTerminalPath) String() string

+ func (fp *Actor_FieldTerminalPath) WithIArrayItemValue(value interface{}) Actor_FieldPathArrayItemValue

+ func (fp *Actor_FieldTerminalPath) WithIArrayOfValues(values interface{}) Actor_FieldPathArrayOfValues

+ func (fp *Actor_FieldTerminalPath) WithIValue(value interface{}) Actor_FieldPathValue

+ func (fp *Actor_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fp *Actor_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fp *Actor_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type Actor_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *Actor_FieldTerminalPathArrayItemValue) ContainsValue(source *Actor) bool

+ func (fpaiv *Actor_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

+ func (fpaiv *Actor_FieldTerminalPathArrayItemValue) GetSingle(source *Actor) (interface{}, bool)

+ func (fpaiv *Actor_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool)

+ type Actor_FieldTerminalPathArrayOfValues struct

+ func (fpaov *Actor_FieldTerminalPathArrayOfValues) AsServiceAccountArrayOfValues() ([]*service_account.Reference, bool)

+ func (fpaov *Actor_FieldTerminalPathArrayOfValues) AsUserArrayOfValues() ([]*user.Reference, bool)

+ func (fpaov *Actor_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{})

+ type Actor_FieldTerminalPathValue struct

+ func (fpv *Actor_FieldTerminalPathValue) AsServiceAccountValue() (*service_account.Reference, bool)

+ func (fpv *Actor_FieldTerminalPathValue) AsUserValue() (*user.Reference, bool)

+ func (fpv *Actor_FieldTerminalPathValue) CompareWith(source *Actor) (int, bool)

+ func (fpv *Actor_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpv *Actor_FieldTerminalPathValue) GetRawValue() interface{}

+ func (fpv *Actor_FieldTerminalPathValue) SetTo(target **Actor)

+ func (fpv *Actor_FieldTerminalPathValue) SetToRaw(target proto.Message)

+ type DigestAlg int32

+ const DigestAlg_SHA1

+ const DigestAlg_SHA256

+ func (DigestAlg) Descriptor() preflect.EnumDescriptor

+ func (DigestAlg) EnumDescriptor() ([]byte, []int)

+ func (DigestAlg) Type() preflect.EnumType

+ func (x DigestAlg) Enum() *DigestAlg

+ func (x DigestAlg) Number() preflect.EnumNumber

+ func (x DigestAlg) String() string

+ type Invitation struct

+ ExpirationDate *timestamp.Timestamp

+ InviteeEmail string

+ InviterActor *Actor

+ InviterEmail string

+ InviterFullName string

+ Roles []*role.Reference

+ State Invitation_State

+ func (*Invitation) Descriptor() ([]byte, []int)

+ func (*Invitation) GotenMessage()

+ func (*Invitation) ProtoMessage()

+ func (m *Invitation) GetExpirationDate() *timestamp.Timestamp

+ func (m *Invitation) GetInviteeEmail() string

+ func (m *Invitation) GetInviterActor() *Actor

+ func (m *Invitation) GetInviterEmail() string

+ func (m *Invitation) GetInviterFullName() string

+ func (m *Invitation) GetRoles() []*role.Reference

+ func (m *Invitation) GetState() Invitation_State

+ func (m *Invitation) Marshal() ([]byte, error)

+ func (m *Invitation) MarshalJSON() ([]byte, error)

+ func (m *Invitation) ProtoReflect() preflect.Message

+ func (m *Invitation) Reset()

+ func (m *Invitation) SetExpirationDate(fv *timestamp.Timestamp)

+ func (m *Invitation) SetInviteeEmail(fv string)

+ func (m *Invitation) SetInviterActor(fv *Actor)

+ func (m *Invitation) SetInviterEmail(fv string)

+ func (m *Invitation) SetInviterFullName(fv string)

+ func (m *Invitation) SetRoles(fv []*role.Reference)

+ func (m *Invitation) SetState(fv Invitation_State)

+ func (m *Invitation) String() string

+ func (m *Invitation) Unmarshal(b []byte) error

+ func (m *Invitation) UnmarshalJSON(data []byte) error

+ func (o *Invitation) Clone() *Invitation

+ func (o *Invitation) CloneRaw() gotenobject.GotenObjectExt

+ func (o *Invitation) GotenObjectExt()

+ func (o *Invitation) MakeDiffFieldMask(other *Invitation) *Invitation_FieldMask

+ func (o *Invitation) MakeFullFieldMask() *Invitation_FieldMask

+ func (o *Invitation) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

+ func (o *Invitation) MakeRawFullFieldMask() gotenobject.FieldMask

+ func (o *Invitation) Merge(source *Invitation)

+ func (o *Invitation) MergeRaw(source gotenobject.GotenObjectExt)

+ func (obj *Invitation) GotenValidate() error

+ type InvitationFieldPathBuilder struct

+ func NewInvitationFieldPathBuilder() InvitationFieldPathBuilder

+ func (InvitationFieldPathBuilder) ExpirationDate() InvitationPathSelectorExpirationDate

+ func (InvitationFieldPathBuilder) InviteeEmail() InvitationPathSelectorInviteeEmail

+ func (InvitationFieldPathBuilder) InviterActor() InvitationPathSelectorInviterActor

+ func (InvitationFieldPathBuilder) InviterEmail() InvitationPathSelectorInviterEmail

+ func (InvitationFieldPathBuilder) InviterFullName() InvitationPathSelectorInviterFullName

+ func (InvitationFieldPathBuilder) Roles() InvitationPathSelectorRoles

+ func (InvitationFieldPathBuilder) State() InvitationPathSelectorState

+ type InvitationPathSelectorExpirationDate struct

+ func (InvitationPathSelectorExpirationDate) FieldPath() *Invitation_FieldTerminalPath

+ func (s InvitationPathSelectorExpirationDate) WithArrayOfValues(values []*timestamp.Timestamp) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorExpirationDate) WithValue(value *timestamp.Timestamp) *Invitation_FieldTerminalPathValue

+ type InvitationPathSelectorInviteeEmail struct

+ func (InvitationPathSelectorInviteeEmail) FieldPath() *Invitation_FieldTerminalPath

+ func (s InvitationPathSelectorInviteeEmail) WithArrayOfValues(values []string) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorInviteeEmail) WithValue(value string) *Invitation_FieldTerminalPathValue

+ type InvitationPathSelectorInviterActor struct

+ func (InvitationPathSelectorInviterActor) FieldPath() *Invitation_FieldTerminalPath

+ func (InvitationPathSelectorInviterActor) ServiceAccount() InvitationPathSelectorInviterActorServiceAccount

+ func (InvitationPathSelectorInviterActor) User() InvitationPathSelectorInviterActorUser

+ func (InvitationPathSelectorInviterActor) WithSubPath(subPath Actor_FieldPath) *Invitation_FieldSubPath

+ func (s InvitationPathSelectorInviterActor) WithArrayOfValues(values []*Actor) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorInviterActor) WithSubArrayItemValue(subPathArrayItemValue Actor_FieldPathArrayItemValue) *Invitation_FieldSubPathArrayItemValue

+ func (s InvitationPathSelectorInviterActor) WithSubArrayOfValues(subPathArrayOfValues Actor_FieldPathArrayOfValues) *Invitation_FieldSubPathArrayOfValues

+ func (s InvitationPathSelectorInviterActor) WithSubValue(subPathValue Actor_FieldPathValue) *Invitation_FieldSubPathValue

+ func (s InvitationPathSelectorInviterActor) WithValue(value *Actor) *Invitation_FieldTerminalPathValue

+ type InvitationPathSelectorInviterActorServiceAccount struct

+ func (InvitationPathSelectorInviterActorServiceAccount) FieldPath() *Invitation_FieldSubPath

+ func (s InvitationPathSelectorInviterActorServiceAccount) WithArrayOfValues(values []*service_account.Reference) *Invitation_FieldSubPathArrayOfValues

+ func (s InvitationPathSelectorInviterActorServiceAccount) WithValue(value *service_account.Reference) *Invitation_FieldSubPathValue

+ type InvitationPathSelectorInviterActorUser struct

+ func (InvitationPathSelectorInviterActorUser) FieldPath() *Invitation_FieldSubPath

+ func (s InvitationPathSelectorInviterActorUser) WithArrayOfValues(values []*user.Reference) *Invitation_FieldSubPathArrayOfValues

+ func (s InvitationPathSelectorInviterActorUser) WithValue(value *user.Reference) *Invitation_FieldSubPathValue

+ type InvitationPathSelectorInviterEmail struct

+ func (InvitationPathSelectorInviterEmail) FieldPath() *Invitation_FieldTerminalPath

+ func (s InvitationPathSelectorInviterEmail) WithArrayOfValues(values []string) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorInviterEmail) WithValue(value string) *Invitation_FieldTerminalPathValue

+ type InvitationPathSelectorInviterFullName struct

+ func (InvitationPathSelectorInviterFullName) FieldPath() *Invitation_FieldTerminalPath

+ func (s InvitationPathSelectorInviterFullName) WithArrayOfValues(values []string) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorInviterFullName) WithValue(value string) *Invitation_FieldTerminalPathValue

+ type InvitationPathSelectorRoles struct

+ func (InvitationPathSelectorRoles) FieldPath() *Invitation_FieldTerminalPath

+ func (s InvitationPathSelectorRoles) WithArrayOfValues(values [][]*role.Reference) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorRoles) WithItemValue(value *role.Reference) *Invitation_FieldTerminalPathArrayItemValue

+ func (s InvitationPathSelectorRoles) WithValue(value []*role.Reference) *Invitation_FieldTerminalPathValue

+ type InvitationPathSelectorState struct

+ func (InvitationPathSelectorState) FieldPath() *Invitation_FieldTerminalPath

+ func (s InvitationPathSelectorState) WithArrayOfValues(values []Invitation_State) *Invitation_FieldTerminalPathArrayOfValues

+ func (s InvitationPathSelectorState) WithValue(value Invitation_State) *Invitation_FieldTerminalPathValue

+ type Invitation_FieldMask struct

+ Paths []Invitation_FieldPath

+ func FullInvitation_FieldMask() *Invitation_FieldMask

+ func (fieldMask *Invitation_FieldMask) AppendPath(path Invitation_FieldPath)

+ func (fieldMask *Invitation_FieldMask) AppendRawPath(path gotenobject.FieldPath)

+ func (fieldMask *Invitation_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

+ func (fieldMask *Invitation_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

+ func (fieldMask *Invitation_FieldMask) FilterInputFields() *Invitation_FieldMask

+ func (fieldMask *Invitation_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

+ func (fieldMask *Invitation_FieldMask) GetPaths() []Invitation_FieldPath

+ func (fieldMask *Invitation_FieldMask) GetRawPaths() []gotenobject.FieldPath

+ func (fieldMask *Invitation_FieldMask) IsFull() bool

+ func (fieldMask *Invitation_FieldMask) PathsCount() int

+ func (fieldMask *Invitation_FieldMask) Project(source *Invitation) *Invitation

+ func (fieldMask *Invitation_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

+ func (fieldMask *Invitation_FieldMask) ProtoMessage()

+ func (fieldMask *Invitation_FieldMask) ProtoReflect() preflect.Message

+ func (fieldMask *Invitation_FieldMask) Reset()

+ func (fieldMask *Invitation_FieldMask) Set(target, source *Invitation)

+ func (fieldMask *Invitation_FieldMask) SetFromCliFlag(raw string) error

+ func (fieldMask *Invitation_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt)

+ func (fieldMask *Invitation_FieldMask) Size() int

+ func (fieldMask *Invitation_FieldMask) String() string

+ func (fieldMask *Invitation_FieldMask) Subtract(other *Invitation_FieldMask) *Invitation_FieldMask

+ func (fieldMask *Invitation_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

+ func (fieldMask *Invitation_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

+ func (fieldMask *Invitation_FieldMask) Unmarshal(data []byte) error

+ func (fieldMask *Invitation_FieldMask) UnmarshalJSON(data []byte) error

+ func (fieldMask Invitation_FieldMask) Marshal() ([]byte, error)

+ func (fieldMask Invitation_FieldMask) MarshalJSON() ([]byte, error)

+ type Invitation_FieldPath interface

+ ClearValue func(item *Invitation)

+ Get func(source *Invitation) []interface{}

+ GetSingle func(source *Invitation) (interface{}, bool)

+ Selector func() Invitation_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) Invitation_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) Invitation_FieldPathArrayOfValues

+ WithIValue func(value interface{}) Invitation_FieldPathValue

+ func BuildInvitation_FieldPath(fp gotenobject.RawFieldPath) (Invitation_FieldPath, error)

+ func MustParseInvitation_FieldPath(rawField string) Invitation_FieldPath

+ func ParseInvitation_FieldPath(rawField string) (Invitation_FieldPath, error)

+ type Invitation_FieldPathArrayItemValue interface

+ ContainsValue func(*Invitation) bool

+ func MustParseInvitation_FieldPathArrayItemValue(pathStr, valueStr string) Invitation_FieldPathArrayItemValue

+ func ParseInvitation_FieldPathArrayItemValue(pathStr, valueStr string) (Invitation_FieldPathArrayItemValue, error)

+ type Invitation_FieldPathArrayOfValues interface

+ func MustParseInvitation_FieldPathArrayOfValues(pathStr, valuesStr string) Invitation_FieldPathArrayOfValues

+ func ParseInvitation_FieldPathArrayOfValues(pathStr, valuesStr string) (Invitation_FieldPathArrayOfValues, error)

+ type Invitation_FieldPathSelector int32

+ const Invitation_FieldPathSelectorExpirationDate

+ const Invitation_FieldPathSelectorInviteeEmail

+ const Invitation_FieldPathSelectorInviterActor

+ const Invitation_FieldPathSelectorInviterEmail

+ const Invitation_FieldPathSelectorInviterFullName

+ const Invitation_FieldPathSelectorRoles

+ const Invitation_FieldPathSelectorState

+ func (s Invitation_FieldPathSelector) String() string

+ type Invitation_FieldPathValue interface

+ CompareWith func(*Invitation) (cmp int, comparable bool)

+ SetTo func(target **Invitation)

+ func MustParseInvitation_FieldPathValue(pathStr, valueStr string) Invitation_FieldPathValue

+ func ParseInvitation_FieldPathValue(pathStr, valueStr string) (Invitation_FieldPathValue, error)

+ type Invitation_FieldSubPath struct

+ func (fps *Invitation_FieldSubPath) AsInviterActorSubPath() (Actor_FieldPath, bool)

+ func (fps *Invitation_FieldSubPath) ClearValue(item *Invitation)

+ func (fps *Invitation_FieldSubPath) ClearValueRaw(item proto.Message)

+ func (fps *Invitation_FieldSubPath) Get(source *Invitation) (values []interface{})

+ func (fps *Invitation_FieldSubPath) GetDefault() interface{}

+ func (fps *Invitation_FieldSubPath) GetRaw(source proto.Message) []interface{}

+ func (fps *Invitation_FieldSubPath) GetSingle(source *Invitation) (interface{}, bool)

+ func (fps *Invitation_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fps *Invitation_FieldSubPath) IsLeaf() bool

+ func (fps *Invitation_FieldSubPath) JSONString() string

+ func (fps *Invitation_FieldSubPath) Selector() Invitation_FieldPathSelector

+ func (fps *Invitation_FieldSubPath) String() string

+ func (fps *Invitation_FieldSubPath) WithIArrayItemValue(value interface{}) Invitation_FieldPathArrayItemValue

+ func (fps *Invitation_FieldSubPath) WithIArrayOfValues(values interface{}) Invitation_FieldPathArrayOfValues

+ func (fps *Invitation_FieldSubPath) WithIValue(value interface{}) Invitation_FieldPathValue

+ func (fps *Invitation_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fps *Invitation_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fps *Invitation_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type Invitation_FieldSubPathArrayItemValue struct

+ func (fpaivs *Invitation_FieldSubPathArrayItemValue) AsInviterActorPathItemValue() (Actor_FieldPathArrayItemValue, bool)

+ func (fpaivs *Invitation_FieldSubPathArrayItemValue) ContainsValue(source *Invitation) bool

+ func (fpaivs *Invitation_FieldSubPathArrayItemValue) GetRawItemValue() interface{}

+ type Invitation_FieldSubPathArrayOfValues struct

+ func (fpsaov *Invitation_FieldSubPathArrayOfValues) AsInviterActorPathArrayOfValues() (Actor_FieldPathArrayOfValues, bool)

+ func (fpsaov *Invitation_FieldSubPathArrayOfValues) GetRawValues() []interface{}

+ type Invitation_FieldSubPathValue struct

+ func (fpvs *Invitation_FieldSubPathValue) AsInviterActorPathValue() (Actor_FieldPathValue, bool)

+ func (fpvs *Invitation_FieldSubPathValue) CompareWith(source *Invitation) (int, bool)

+ func (fpvs *Invitation_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpvs *Invitation_FieldSubPathValue) GetRawValue() interface{}

+ func (fpvs *Invitation_FieldSubPathValue) SetTo(target **Invitation)

+ func (fpvs *Invitation_FieldSubPathValue) SetToRaw(target proto.Message)

+ type Invitation_FieldTerminalPath struct

+ func (fp *Invitation_FieldTerminalPath) ClearValue(item *Invitation)

+ func (fp *Invitation_FieldTerminalPath) ClearValueRaw(item proto.Message)

+ func (fp *Invitation_FieldTerminalPath) Get(source *Invitation) (values []interface{})

+ func (fp *Invitation_FieldTerminalPath) GetDefault() interface{}

+ func (fp *Invitation_FieldTerminalPath) GetRaw(source proto.Message) []interface{}

+ func (fp *Invitation_FieldTerminalPath) GetSingle(source *Invitation) (interface{}, bool)

+ func (fp *Invitation_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fp *Invitation_FieldTerminalPath) IsLeaf() bool

+ func (fp *Invitation_FieldTerminalPath) JSONString() string

+ func (fp *Invitation_FieldTerminalPath) Selector() Invitation_FieldPathSelector

+ func (fp *Invitation_FieldTerminalPath) String() string

+ func (fp *Invitation_FieldTerminalPath) WithIArrayItemValue(value interface{}) Invitation_FieldPathArrayItemValue

+ func (fp *Invitation_FieldTerminalPath) WithIArrayOfValues(values interface{}) Invitation_FieldPathArrayOfValues

+ func (fp *Invitation_FieldTerminalPath) WithIValue(value interface{}) Invitation_FieldPathValue

+ func (fp *Invitation_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fp *Invitation_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fp *Invitation_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type Invitation_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *Invitation_FieldTerminalPathArrayItemValue) AsRolesItemValue() (*role.Reference, bool)

+ func (fpaiv *Invitation_FieldTerminalPathArrayItemValue) ContainsValue(source *Invitation) bool

+ func (fpaiv *Invitation_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

+ func (fpaiv *Invitation_FieldTerminalPathArrayItemValue) GetSingle(source *Invitation) (interface{}, bool)

+ func (fpaiv *Invitation_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool)

+ type Invitation_FieldTerminalPathArrayOfValues struct

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsExpirationDateArrayOfValues() ([]*timestamp.Timestamp, bool)

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsInviteeEmailArrayOfValues() ([]string, bool)

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsInviterActorArrayOfValues() ([]*Actor, bool)

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsInviterEmailArrayOfValues() ([]string, bool)

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsInviterFullNameArrayOfValues() ([]string, bool)

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsRolesArrayOfValues() ([][]*role.Reference, bool)

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]Invitation_State, bool)

+ func (fpaov *Invitation_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{})

+ type Invitation_FieldTerminalPathValue struct

+ func (fpv *Invitation_FieldTerminalPathValue) AsExpirationDateValue() (*timestamp.Timestamp, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) AsInviteeEmailValue() (string, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) AsInviterActorValue() (*Actor, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) AsInviterEmailValue() (string, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) AsInviterFullNameValue() (string, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) AsRolesValue() ([]*role.Reference, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) AsStateValue() (Invitation_State, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) CompareWith(source *Invitation) (int, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpv *Invitation_FieldTerminalPathValue) GetRawValue() interface{}

+ func (fpv *Invitation_FieldTerminalPathValue) SetTo(target **Invitation)

+ func (fpv *Invitation_FieldTerminalPathValue) SetToRaw(target proto.Message)

+ type Invitation_State int32

+ const Invitation_ACCEPTED

+ const Invitation_DECLINED

+ const Invitation_EXPIRED

+ const Invitation_PENDING

+ const Invitation_STATE_UNSPECIFIED

+ func (Invitation_State) Descriptor() preflect.EnumDescriptor

+ func (Invitation_State) EnumDescriptor() ([]byte, []int)

+ func (Invitation_State) Type() preflect.EnumType

+ func (x Invitation_State) Enum() *Invitation_State

+ func (x Invitation_State) Number() preflect.EnumNumber

+ func (x Invitation_State) String() string

+ type PCR struct

+ Comment string

+ DigestAlg DigestAlg

+ DigestHex string

+ Index uint32

+ func (*PCR) Descriptor() ([]byte, []int)

+ func (*PCR) GotenMessage()

+ func (*PCR) ProtoMessage()

+ func (m *PCR) GetComment() string

+ func (m *PCR) GetDigestAlg() DigestAlg

+ func (m *PCR) GetDigestHex() string

+ func (m *PCR) GetIndex() uint32

+ func (m *PCR) Marshal() ([]byte, error)

+ func (m *PCR) MarshalJSON() ([]byte, error)

+ func (m *PCR) ProtoReflect() preflect.Message

+ func (m *PCR) Reset()

+ func (m *PCR) SetComment(fv string)

+ func (m *PCR) SetDigestAlg(fv DigestAlg)

+ func (m *PCR) SetDigestHex(fv string)

+ func (m *PCR) SetIndex(fv uint32)

+ func (m *PCR) String() string

+ func (m *PCR) Unmarshal(b []byte) error

+ func (m *PCR) UnmarshalJSON(data []byte) error

+ func (o *PCR) Clone() *PCR

+ func (o *PCR) CloneRaw() gotenobject.GotenObjectExt

+ func (o *PCR) GotenObjectExt()

+ func (o *PCR) MakeDiffFieldMask(other *PCR) *PCR_FieldMask

+ func (o *PCR) MakeFullFieldMask() *PCR_FieldMask

+ func (o *PCR) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

+ func (o *PCR) MakeRawFullFieldMask() gotenobject.FieldMask

+ func (o *PCR) Merge(source *PCR)

+ func (o *PCR) MergeRaw(source gotenobject.GotenObjectExt)

+ func (obj *PCR) GotenValidate() error

+ type PCRFieldPathBuilder struct

+ func NewPCRFieldPathBuilder() PCRFieldPathBuilder

+ func (PCRFieldPathBuilder) Comment() PCRPathSelectorComment

+ func (PCRFieldPathBuilder) DigestAlg() PCRPathSelectorDigestAlg

+ func (PCRFieldPathBuilder) DigestHex() PCRPathSelectorDigestHex

+ func (PCRFieldPathBuilder) Index() PCRPathSelectorIndex

+ type PCRPathSelectorComment struct

+ func (PCRPathSelectorComment) FieldPath() *PCR_FieldTerminalPath

+ func (s PCRPathSelectorComment) WithArrayOfValues(values []string) *PCR_FieldTerminalPathArrayOfValues

+ func (s PCRPathSelectorComment) WithValue(value string) *PCR_FieldTerminalPathValue

+ type PCRPathSelectorDigestAlg struct

+ func (PCRPathSelectorDigestAlg) FieldPath() *PCR_FieldTerminalPath

+ func (s PCRPathSelectorDigestAlg) WithArrayOfValues(values []DigestAlg) *PCR_FieldTerminalPathArrayOfValues

+ func (s PCRPathSelectorDigestAlg) WithValue(value DigestAlg) *PCR_FieldTerminalPathValue

+ type PCRPathSelectorDigestHex struct

+ func (PCRPathSelectorDigestHex) FieldPath() *PCR_FieldTerminalPath

+ func (s PCRPathSelectorDigestHex) WithArrayOfValues(values []string) *PCR_FieldTerminalPathArrayOfValues

+ func (s PCRPathSelectorDigestHex) WithValue(value string) *PCR_FieldTerminalPathValue

+ type PCRPathSelectorIndex struct

+ func (PCRPathSelectorIndex) FieldPath() *PCR_FieldTerminalPath

+ func (s PCRPathSelectorIndex) WithArrayOfValues(values []uint32) *PCR_FieldTerminalPathArrayOfValues

+ func (s PCRPathSelectorIndex) WithValue(value uint32) *PCR_FieldTerminalPathValue

+ type PCR_FieldMask struct

+ Paths []PCR_FieldPath

+ func FullPCR_FieldMask() *PCR_FieldMask

+ func (fieldMask *PCR_FieldMask) AppendPath(path PCR_FieldPath)

+ func (fieldMask *PCR_FieldMask) AppendRawPath(path gotenobject.FieldPath)

+ func (fieldMask *PCR_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

+ func (fieldMask *PCR_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

+ func (fieldMask *PCR_FieldMask) FilterInputFields() *PCR_FieldMask

+ func (fieldMask *PCR_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

+ func (fieldMask *PCR_FieldMask) GetPaths() []PCR_FieldPath

+ func (fieldMask *PCR_FieldMask) GetRawPaths() []gotenobject.FieldPath

+ func (fieldMask *PCR_FieldMask) IsFull() bool

+ func (fieldMask *PCR_FieldMask) PathsCount() int

+ func (fieldMask *PCR_FieldMask) Project(source *PCR) *PCR

+ func (fieldMask *PCR_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

+ func (fieldMask *PCR_FieldMask) ProtoMessage()

+ func (fieldMask *PCR_FieldMask) ProtoReflect() preflect.Message

+ func (fieldMask *PCR_FieldMask) Reset()

+ func (fieldMask *PCR_FieldMask) Set(target, source *PCR)

+ func (fieldMask *PCR_FieldMask) SetFromCliFlag(raw string) error

+ func (fieldMask *PCR_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt)

+ func (fieldMask *PCR_FieldMask) Size() int

+ func (fieldMask *PCR_FieldMask) String() string

+ func (fieldMask *PCR_FieldMask) Subtract(other *PCR_FieldMask) *PCR_FieldMask

+ func (fieldMask *PCR_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

+ func (fieldMask *PCR_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

+ func (fieldMask *PCR_FieldMask) Unmarshal(data []byte) error

+ func (fieldMask *PCR_FieldMask) UnmarshalJSON(data []byte) error

+ func (fieldMask PCR_FieldMask) Marshal() ([]byte, error)

+ func (fieldMask PCR_FieldMask) MarshalJSON() ([]byte, error)

+ type PCR_FieldPath interface

+ ClearValue func(item *PCR)

+ Get func(source *PCR) []interface{}

+ GetSingle func(source *PCR) (interface{}, bool)

+ Selector func() PCR_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) PCR_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) PCR_FieldPathArrayOfValues

+ WithIValue func(value interface{}) PCR_FieldPathValue

+ func BuildPCR_FieldPath(fp gotenobject.RawFieldPath) (PCR_FieldPath, error)

+ func MustParsePCR_FieldPath(rawField string) PCR_FieldPath

+ func ParsePCR_FieldPath(rawField string) (PCR_FieldPath, error)

+ type PCR_FieldPathArrayItemValue interface

+ ContainsValue func(*PCR) bool

+ func MustParsePCR_FieldPathArrayItemValue(pathStr, valueStr string) PCR_FieldPathArrayItemValue

+ func ParsePCR_FieldPathArrayItemValue(pathStr, valueStr string) (PCR_FieldPathArrayItemValue, error)

+ type PCR_FieldPathArrayOfValues interface

+ func MustParsePCR_FieldPathArrayOfValues(pathStr, valuesStr string) PCR_FieldPathArrayOfValues

+ func ParsePCR_FieldPathArrayOfValues(pathStr, valuesStr string) (PCR_FieldPathArrayOfValues, error)

+ type PCR_FieldPathSelector int32

+ const PCR_FieldPathSelectorComment

+ const PCR_FieldPathSelectorDigestAlg

+ const PCR_FieldPathSelectorDigestHex

+ const PCR_FieldPathSelectorIndex

+ func (s PCR_FieldPathSelector) String() string

+ type PCR_FieldPathValue interface

+ CompareWith func(*PCR) (cmp int, comparable bool)

+ SetTo func(target **PCR)

+ func MustParsePCR_FieldPathValue(pathStr, valueStr string) PCR_FieldPathValue

+ func ParsePCR_FieldPathValue(pathStr, valueStr string) (PCR_FieldPathValue, error)

+ type PCR_FieldTerminalPath struct

+ func (fp *PCR_FieldTerminalPath) ClearValue(item *PCR)

+ func (fp *PCR_FieldTerminalPath) ClearValueRaw(item proto.Message)

+ func (fp *PCR_FieldTerminalPath) Get(source *PCR) (values []interface{})

+ func (fp *PCR_FieldTerminalPath) GetDefault() interface{}

+ func (fp *PCR_FieldTerminalPath) GetRaw(source proto.Message) []interface{}

+ func (fp *PCR_FieldTerminalPath) GetSingle(source *PCR) (interface{}, bool)

+ func (fp *PCR_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool)

+ func (fp *PCR_FieldTerminalPath) IsLeaf() bool

+ func (fp *PCR_FieldTerminalPath) JSONString() string

+ func (fp *PCR_FieldTerminalPath) Selector() PCR_FieldPathSelector

+ func (fp *PCR_FieldTerminalPath) String() string

+ func (fp *PCR_FieldTerminalPath) WithIArrayItemValue(value interface{}) PCR_FieldPathArrayItemValue

+ func (fp *PCR_FieldTerminalPath) WithIArrayOfValues(values interface{}) PCR_FieldPathArrayOfValues

+ func (fp *PCR_FieldTerminalPath) WithIValue(value interface{}) PCR_FieldPathValue

+ func (fp *PCR_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue

+ func (fp *PCR_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues

+ func (fp *PCR_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue

+ type PCR_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *PCR_FieldTerminalPathArrayItemValue) ContainsValue(source *PCR) bool

+ func (fpaiv *PCR_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

+ func (fpaiv *PCR_FieldTerminalPathArrayItemValue) GetSingle(source *PCR) (interface{}, bool)

+ func (fpaiv *PCR_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool)

+ type PCR_FieldTerminalPathArrayOfValues struct

+ func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsCommentArrayOfValues() ([]string, bool)

+ func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsDigestAlgArrayOfValues() ([]DigestAlg, bool)

+ func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsDigestHexArrayOfValues() ([]string, bool)

+ func (fpaov *PCR_FieldTerminalPathArrayOfValues) AsIndexArrayOfValues() ([]uint32, bool)

+ func (fpaov *PCR_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{})

+ type PCR_FieldTerminalPathValue struct

+ func (fpv *PCR_FieldTerminalPathValue) AsCommentValue() (string, bool)

+ func (fpv *PCR_FieldTerminalPathValue) AsDigestAlgValue() (DigestAlg, bool)

+ func (fpv *PCR_FieldTerminalPathValue) AsDigestHexValue() (string, bool)

+ func (fpv *PCR_FieldTerminalPathValue) AsIndexValue() (uint32, bool)

+ func (fpv *PCR_FieldTerminalPathValue) CompareWith(source *PCR) (int, bool)

+ func (fpv *PCR_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool)

+ func (fpv *PCR_FieldTerminalPathValue) GetRawValue() interface{}

+ func (fpv *PCR_FieldTerminalPathValue) SetTo(target **PCR)

+ func (fpv *PCR_FieldTerminalPathValue) SetToRaw(target proto.Message)

+ type TpmVersion int32

+ const TpmVersion_TPMV12

+ const TpmVersion_TPMV20

+ const TpmVersion_TPMVAGNOSTIC

+ func (TpmVersion) Descriptor() preflect.EnumDescriptor

+ func (TpmVersion) EnumDescriptor() ([]byte, []int)

+ func (TpmVersion) Type() preflect.EnumType

+ func (x TpmVersion) Enum() *TpmVersion

+ func (x TpmVersion) Number() preflect.EnumNumber

+ func (x TpmVersion) String() string