alerting_policy

Mar 29, 2024

Changes in this version

type AlertingPolicy

+ func (r *AlertingPolicy) EnsureMetadata() *meta.Meta

type AlertingPolicyPathSelectorMetadata

+ func (AlertingPolicyPathSelectorMetadata) Services() AlertingPolicyPathSelectorMetadataServices

+ type AlertingPolicyPathSelectorMetadataServices struct

+ func (AlertingPolicyPathSelectorMetadataServices) AllowedServices() AlertingPolicyPathSelectorMetadataServicesAllowedServices

+ func (AlertingPolicyPathSelectorMetadataServices) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorMetadataServices) OwningService() AlertingPolicyPathSelectorMetadataServicesOwningService

+ func (s AlertingPolicyPathSelectorMetadataServices) WithArrayOfValues(values []*meta.ServicesInfo) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataServices) WithValue(value *meta.ServicesInfo) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataServicesAllowedServices struct

+ func (AlertingPolicyPathSelectorMetadataServicesAllowedServices) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataServicesAllowedServices) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataServicesAllowedServices) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorMetadataServicesAllowedServices) WithValue(value []string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataServicesOwningService struct

+ func (AlertingPolicyPathSelectorMetadataServicesOwningService) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataServicesOwningService) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataServicesOwningService) WithValue(value string) *AlertingPolicy_FieldSubPathValue

type Descriptor

+ func (d *Descriptor) CanBeParentless() bool

+ func (d *Descriptor) GetParentResDescriptors() []gotenresource.Descriptor

+ func (d *Descriptor) SupportsMetadata() bool

type ParentName

+ func (name *ParentName) ConvertToNative(typeDesc reflect.Type) (interface{}, error)

+ func (name *ParentName) ConvertToType(typeVal ref.Type) ref.Val

+ func (name *ParentName) Equal(other ref.Val) ref.Val

+ func (name *ParentName) HasTrait(trait int) bool

+ func (name *ParentName) Match(pattern ref.Val) ref.Val

+ func (name *ParentName) Receive(function string, overload string, args []ref.Val) ref.Val

+ func (name *ParentName) Type() ref.Type

+ func (name *ParentName) TypeName() string

+ func (name *ParentName) Value() interface{}

Feb 22, 2023

Changes in this version

+ var AlertingPolicy_Spec_Notification_ListType_name = map[int32]string

+ var AlertingPolicy_Spec_Notification_ListType_value = map[string]int32

type AlertingPolicy

+ State *AlertingPolicy_State

+ func (m *AlertingPolicy) GetState() *AlertingPolicy_State

+ func (m *AlertingPolicy) SetState(fv *AlertingPolicy_State)

type AlertingPolicyFieldPathBuilder

+ func (AlertingPolicyFieldPathBuilder) State() AlertingPolicyPathSelectorState

type AlertingPolicyPathSelectorSpecNotification

+ func (AlertingPolicyPathSelectorSpecNotification) Channels() AlertingPolicyPathSelectorSpecNotificationChannels

+ func (AlertingPolicyPathSelectorSpecNotification) Enabled() AlertingPolicyPathSelectorSpecNotificationEnabled

+ func (AlertingPolicyPathSelectorSpecNotification) ListType() AlertingPolicyPathSelectorSpecNotificationListType

+ type AlertingPolicyPathSelectorSpecNotificationChannels struct

+ func (AlertingPolicyPathSelectorSpecNotificationChannels) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecNotificationChannels) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationChannels) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorSpecNotificationChannels) WithValue(value []string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotificationEnabled struct

+ func (AlertingPolicyPathSelectorSpecNotificationEnabled) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecNotificationEnabled) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationEnabled) WithValue(value bool) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotificationListType struct

+ func (AlertingPolicyPathSelectorSpecNotificationListType) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecNotificationListType) WithArrayOfValues(values []AlertingPolicy_Spec_Notification_ListType) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationListType) WithValue(value AlertingPolicy_Spec_Notification_ListType) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorState struct

+ func (AlertingPolicyPathSelectorState) ActiveAlertsCount() AlertingPolicyPathSelectorStateActiveAlertsCount

+ func (AlertingPolicyPathSelectorState) FieldPath() *AlertingPolicy_FieldTerminalPath

+ func (AlertingPolicyPathSelectorState) WithSubPath(subPath AlertingPolicyState_FieldPath) *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorState) WithArrayOfValues(values []*AlertingPolicy_State) *AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicyPathSelectorState) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicyState_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorState) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicyState_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorState) WithSubValue(subPathValue AlertingPolicyState_FieldPathValue) *AlertingPolicy_FieldSubPathValue

+ func (s AlertingPolicyPathSelectorState) WithValue(value *AlertingPolicy_State) *AlertingPolicy_FieldTerminalPathValue

+ type AlertingPolicyPathSelectorStateActiveAlertsCount struct

+ func (AlertingPolicyPathSelectorStateActiveAlertsCount) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorStateActiveAlertsCount) WithArrayOfValues(values []int64) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorStateActiveAlertsCount) WithValue(value int64) *AlertingPolicy_FieldSubPathValue

type AlertingPolicySpecNotificationFieldPathBuilder

+ func (AlertingPolicySpecNotificationFieldPathBuilder) Channels() AlertingPolicy_Spec_NotificationPathSelectorChannels

+ func (AlertingPolicySpecNotificationFieldPathBuilder) Enabled() AlertingPolicy_Spec_NotificationPathSelectorEnabled

+ func (AlertingPolicySpecNotificationFieldPathBuilder) ListType() AlertingPolicy_Spec_NotificationPathSelectorListType

type AlertingPolicySpecNotification_FieldPathSelector

+ const AlertingPolicySpecNotification_FieldPathSelectorChannels

+ const AlertingPolicySpecNotification_FieldPathSelectorEnabled

+ const AlertingPolicySpecNotification_FieldPathSelectorListType

type AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue

+ func (fpaiv *AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue) AsChannelsItemValue() (string, bool)

type AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues

+ func (fpaov *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues) AsChannelsArrayOfValues() ([][]string, bool)

+ func (fpaov *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues) AsEnabledArrayOfValues() ([]bool, bool)

+ func (fpaov *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues) AsListTypeArrayOfValues() ([]AlertingPolicy_Spec_Notification_ListType, bool)

type AlertingPolicySpecNotification_FieldTerminalPathValue

+ func (fpv *AlertingPolicySpecNotification_FieldTerminalPathValue) AsChannelsValue() ([]string, bool)

+ func (fpv *AlertingPolicySpecNotification_FieldTerminalPathValue) AsEnabledValue() (bool, bool)

+ func (fpv *AlertingPolicySpecNotification_FieldTerminalPathValue) AsListTypeValue() (AlertingPolicy_Spec_Notification_ListType, bool)

+ type AlertingPolicyStateFieldPathBuilder struct

+ func NewAlertingPolicyStateFieldPathBuilder() AlertingPolicyStateFieldPathBuilder

+ func (AlertingPolicyStateFieldPathBuilder) ActiveAlertsCount() AlertingPolicy_StatePathSelectorActiveAlertsCount

+ type AlertingPolicyState_FieldPath interface

+ ClearValue func(item *AlertingPolicy_State)

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

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

+ Selector func() AlertingPolicyState_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) AlertingPolicyState_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) AlertingPolicyState_FieldPathArrayOfValues

+ WithIValue func(value interface{}) AlertingPolicyState_FieldPathValue

+ func BuildAlertingPolicyState_FieldPath(fp gotenobject.RawFieldPath) (AlertingPolicyState_FieldPath, error)

+ func MustParseAlertingPolicyState_FieldPath(rawField string) AlertingPolicyState_FieldPath

+ func ParseAlertingPolicyState_FieldPath(rawField string) (AlertingPolicyState_FieldPath, error)

+ type AlertingPolicyState_FieldPathArrayItemValue interface

+ ContainsValue func(*AlertingPolicy_State) bool

+ func MustParseAlertingPolicyState_FieldPathArrayItemValue(pathStr, valueStr string) AlertingPolicyState_FieldPathArrayItemValue

+ func ParseAlertingPolicyState_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingPolicyState_FieldPathArrayItemValue, error)

+ type AlertingPolicyState_FieldPathArrayOfValues interface

+ func MustParseAlertingPolicyState_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingPolicyState_FieldPathArrayOfValues

+ func ParseAlertingPolicyState_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingPolicyState_FieldPathArrayOfValues, error)

+ type AlertingPolicyState_FieldPathSelector int32

+ const AlertingPolicyState_FieldPathSelectorActiveAlertsCount

+ func (s AlertingPolicyState_FieldPathSelector) String() string

+ type AlertingPolicyState_FieldPathValue interface

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

+ SetTo func(target **AlertingPolicy_State)

+ func MustParseAlertingPolicyState_FieldPathValue(pathStr, valueStr string) AlertingPolicyState_FieldPathValue

+ func ParseAlertingPolicyState_FieldPathValue(pathStr, valueStr string) (AlertingPolicyState_FieldPathValue, error)

+ type AlertingPolicyState_FieldTerminalPath struct

+ func (fp *AlertingPolicyState_FieldTerminalPath) ClearValue(item *AlertingPolicy_State)

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

+ func (fp *AlertingPolicyState_FieldTerminalPath) Get(source *AlertingPolicy_State) (values []interface{})

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

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

+ func (fp *AlertingPolicyState_FieldTerminalPath) GetSingle(source *AlertingPolicy_State) (interface{}, bool)

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

+ func (fp *AlertingPolicyState_FieldTerminalPath) IsLeaf() bool

+ func (fp *AlertingPolicyState_FieldTerminalPath) JSONString() string

+ func (fp *AlertingPolicyState_FieldTerminalPath) Selector() AlertingPolicyState_FieldPathSelector

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

+ func (fp *AlertingPolicyState_FieldTerminalPath) String() string

+ func (fp *AlertingPolicyState_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingPolicyState_FieldPathArrayItemValue

+ func (fp *AlertingPolicyState_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingPolicyState_FieldPathArrayOfValues

+ func (fp *AlertingPolicyState_FieldTerminalPath) WithIValue(value interface{}) AlertingPolicyState_FieldPathValue

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

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

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

+ type AlertingPolicyState_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *AlertingPolicyState_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingPolicy_State) bool

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

+ func (fpaiv *AlertingPolicyState_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingPolicy_State) (interface{}, bool)

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

+ type AlertingPolicyState_FieldTerminalPathArrayOfValues struct

+ func (fpaov *AlertingPolicyState_FieldTerminalPathArrayOfValues) AsActiveAlertsCountArrayOfValues() ([]int64, bool)

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

+ type AlertingPolicyState_FieldTerminalPathValue struct

+ func (fpv *AlertingPolicyState_FieldTerminalPathValue) AsActiveAlertsCountValue() (int64, bool)

+ func (fpv *AlertingPolicyState_FieldTerminalPathValue) CompareWith(source *AlertingPolicy_State) (int, bool)

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

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

+ func (fpv *AlertingPolicyState_FieldTerminalPathValue) SetTo(target **AlertingPolicy_State)

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

type AlertingPolicy_FieldPathSelector

+ const AlertingPolicy_FieldPathSelectorState

type AlertingPolicy_FieldSubPath

+ func (fps *AlertingPolicy_FieldSubPath) AsStateSubPath() (AlertingPolicyState_FieldPath, bool)

type AlertingPolicy_FieldSubPathArrayItemValue

+ func (fpaivs *AlertingPolicy_FieldSubPathArrayItemValue) AsStatePathItemValue() (AlertingPolicyState_FieldPathArrayItemValue, bool)

type AlertingPolicy_FieldSubPathArrayOfValues

+ func (fpsaov *AlertingPolicy_FieldSubPathArrayOfValues) AsStatePathArrayOfValues() (AlertingPolicyState_FieldPathArrayOfValues, bool)

type AlertingPolicy_FieldSubPathValue

+ func (fpvs *AlertingPolicy_FieldSubPathValue) AsStatePathValue() (AlertingPolicyState_FieldPathValue, bool)

type AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (fpaov *AlertingPolicy_FieldTerminalPathArrayOfValues) AsStateArrayOfValues() ([]*AlertingPolicy_State, bool)

type AlertingPolicy_FieldTerminalPathValue

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) AsStateValue() (*AlertingPolicy_State, bool)

type AlertingPolicy_SpecPathSelectorNotification

+ func (AlertingPolicy_SpecPathSelectorNotification) Channels() AlertingPolicy_SpecPathSelectorNotificationChannels

+ func (AlertingPolicy_SpecPathSelectorNotification) Enabled() AlertingPolicy_SpecPathSelectorNotificationEnabled

+ func (AlertingPolicy_SpecPathSelectorNotification) ListType() AlertingPolicy_SpecPathSelectorNotificationListType

+ type AlertingPolicy_SpecPathSelectorNotificationChannels struct

+ func (AlertingPolicy_SpecPathSelectorNotificationChannels) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotificationChannels) WithArrayOfValues(values [][]string) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationChannels) WithItemValue(value string) *AlertingPolicySpec_FieldSubPathArrayItemValue

+ func (s AlertingPolicy_SpecPathSelectorNotificationChannels) WithValue(value []string) *AlertingPolicySpec_FieldSubPathValue

+ type AlertingPolicy_SpecPathSelectorNotificationEnabled struct

+ func (AlertingPolicy_SpecPathSelectorNotificationEnabled) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotificationEnabled) WithArrayOfValues(values []bool) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationEnabled) WithValue(value bool) *AlertingPolicySpec_FieldSubPathValue

+ type AlertingPolicy_SpecPathSelectorNotificationListType struct

+ func (AlertingPolicy_SpecPathSelectorNotificationListType) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotificationListType) WithArrayOfValues(values []AlertingPolicy_Spec_Notification_ListType) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationListType) WithValue(value AlertingPolicy_Spec_Notification_ListType) *AlertingPolicySpec_FieldSubPathValue

type AlertingPolicy_Spec_Notification

+ Channels []string

+ Enabled bool

+ ListType AlertingPolicy_Spec_Notification_ListType

+ func (m *AlertingPolicy_Spec_Notification) GetChannels() []string

+ func (m *AlertingPolicy_Spec_Notification) GetEnabled() bool

+ func (m *AlertingPolicy_Spec_Notification) GetListType() AlertingPolicy_Spec_Notification_ListType

+ func (m *AlertingPolicy_Spec_Notification) SetChannels(fv []string)

+ func (m *AlertingPolicy_Spec_Notification) SetEnabled(fv bool)

+ func (m *AlertingPolicy_Spec_Notification) SetListType(fv AlertingPolicy_Spec_Notification_ListType)

+ type AlertingPolicy_Spec_NotificationPathSelectorChannels struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorChannels) FieldPath() *AlertingPolicySpecNotification_FieldTerminalPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorChannels) WithArrayOfValues(values [][]string) *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorChannels) WithItemValue(value string) *AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue

+ func (s AlertingPolicy_Spec_NotificationPathSelectorChannels) WithValue(value []string) *AlertingPolicySpecNotification_FieldTerminalPathValue

+ type AlertingPolicy_Spec_NotificationPathSelectorEnabled struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorEnabled) FieldPath() *AlertingPolicySpecNotification_FieldTerminalPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorEnabled) WithArrayOfValues(values []bool) *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorEnabled) WithValue(value bool) *AlertingPolicySpecNotification_FieldTerminalPathValue

+ type AlertingPolicy_Spec_NotificationPathSelectorListType struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorListType) FieldPath() *AlertingPolicySpecNotification_FieldTerminalPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorListType) WithArrayOfValues(values []AlertingPolicy_Spec_Notification_ListType) *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorListType) WithValue(value AlertingPolicy_Spec_Notification_ListType) *AlertingPolicySpecNotification_FieldTerminalPathValue

+ type AlertingPolicy_Spec_Notification_ListType int32

+ const AlertingPolicy_Spec_Notification_ALLOW

+ const AlertingPolicy_Spec_Notification_DENY

+ const AlertingPolicy_Spec_Notification_LIST_TYPE_UNSPECIFIED

+ func (AlertingPolicy_Spec_Notification_ListType) Descriptor() preflect.EnumDescriptor

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

+ func (AlertingPolicy_Spec_Notification_ListType) Type() preflect.EnumType

+ func (x AlertingPolicy_Spec_Notification_ListType) Enum() *AlertingPolicy_Spec_Notification_ListType

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

+ func (x AlertingPolicy_Spec_Notification_ListType) String() string

+ type AlertingPolicy_State struct

+ ActiveAlertsCount int64

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

+ func (*AlertingPolicy_State) GotenMessage()

+ func (*AlertingPolicy_State) ProtoMessage()

+ func (m *AlertingPolicy_State) GetActiveAlertsCount() int64

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

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

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

+ func (m *AlertingPolicy_State) Reset()

+ func (m *AlertingPolicy_State) SetActiveAlertsCount(fv int64)

+ func (m *AlertingPolicy_State) String() string

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

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

+ func (o *AlertingPolicy_State) Clone() *AlertingPolicy_State

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

+ func (o *AlertingPolicy_State) GotenObjectExt()

+ func (o *AlertingPolicy_State) MakeDiffFieldMask(other *AlertingPolicy_State) *AlertingPolicy_State_FieldMask

+ func (o *AlertingPolicy_State) MakeFullFieldMask() *AlertingPolicy_State_FieldMask

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

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

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

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

+ func (obj *AlertingPolicy_State) GotenValidate() error

+ type AlertingPolicy_StatePathSelectorActiveAlertsCount struct

+ func (AlertingPolicy_StatePathSelectorActiveAlertsCount) FieldPath() *AlertingPolicyState_FieldTerminalPath

+ func (s AlertingPolicy_StatePathSelectorActiveAlertsCount) WithArrayOfValues(values []int64) *AlertingPolicyState_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_StatePathSelectorActiveAlertsCount) WithValue(value int64) *AlertingPolicyState_FieldTerminalPathValue

+ type AlertingPolicy_State_FieldMask struct

+ Paths []AlertingPolicyState_FieldPath

+ func FullAlertingPolicy_State_FieldMask() *AlertingPolicy_State_FieldMask

+ func (fieldMask *AlertingPolicy_State_FieldMask) AppendPath(path AlertingPolicyState_FieldPath)

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

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

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

+ func (fieldMask *AlertingPolicy_State_FieldMask) FilterInputFields() *AlertingPolicy_State_FieldMask

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

+ func (fieldMask *AlertingPolicy_State_FieldMask) GetPaths() []AlertingPolicyState_FieldPath

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

+ func (fieldMask *AlertingPolicy_State_FieldMask) IsFull() bool

+ func (fieldMask *AlertingPolicy_State_FieldMask) PathsCount() int

+ func (fieldMask *AlertingPolicy_State_FieldMask) Project(source *AlertingPolicy_State) *AlertingPolicy_State

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

+ func (fieldMask *AlertingPolicy_State_FieldMask) ProtoMessage()

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

+ func (fieldMask *AlertingPolicy_State_FieldMask) Reset()

+ func (fieldMask *AlertingPolicy_State_FieldMask) Set(target, source *AlertingPolicy_State)

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

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

+ func (fieldMask *AlertingPolicy_State_FieldMask) Size() int

+ func (fieldMask *AlertingPolicy_State_FieldMask) String() string

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

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

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

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

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

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

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

Jan 29, 2023

Changes in this version

type AlertingPolicyAccess

+ SearchAlertingPolicies func(context.Context, *SearchQuery) (*QueryResultSnapshot, error)

+ type SearchQuery struct

+ Phrase string

+ func (q *SearchQuery) GetPhrase() string

+ func (q *SearchQuery) GetWithPagingInfo() bool

+ func (q *SearchQuery) SetPhrase(phrase string)

+ func (q *SearchQuery) String() string

Jan 18, 2023

Changes in this version

type ListQuery

+ WithPagingInfo bool

+ func (q *ListQuery) GetWithPagingInfo() bool

+ func (q *ListQuery) SetWithPagingInfo(with bool)

type QueryResultSnapshot

+ CurrentOffset int32

+ TotalResultsCount int32

+ func (qr *QueryResultSnapshot) GetPagingInfo() (totalCount, offset int32)

+ func (qr *QueryResultSnapshot) SetPagingInfo(totalCount, offset int32)

Oct 29, 2022

Changes in this version

type Descriptor

+ func (d *Descriptor) NewResourcePager() gotenresource.PagerQuery

type WatchQuery

+ StartingTime *timestamppb.Timestamp

+ func (q *WatchQuery) GetStartingTime() *timestamppb.Timestamp

+ func (q *WatchQuery) SetStartingTime(startingTime *timestamppb.Timestamp)

Sep 9, 2022

Changes in this version

type AlertingPolicyDocumentation_FieldTerminalPath

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

type AlertingPolicyPathSelectorMetadata

+ func (AlertingPolicyPathSelectorMetadata) DeleteTime() AlertingPolicyPathSelectorMetadataDeleteTime

+ func (AlertingPolicyPathSelectorMetadata) Lifecycle() AlertingPolicyPathSelectorMetadataLifecycle

+ type AlertingPolicyPathSelectorMetadataDeleteTime struct

+ func (AlertingPolicyPathSelectorMetadataDeleteTime) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataDeleteTime) WithArrayOfValues(values []*timestamp.Timestamp) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataDeleteTime) WithValue(value *timestamp.Timestamp) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataLifecycle struct

+ func (AlertingPolicyPathSelectorMetadataLifecycle) BlockDeletion() AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion

+ func (AlertingPolicyPathSelectorMetadataLifecycle) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorMetadataLifecycle) State() AlertingPolicyPathSelectorMetadataLifecycleState

+ func (s AlertingPolicyPathSelectorMetadataLifecycle) WithArrayOfValues(values []*ntt_meta.Lifecycle) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataLifecycle) WithValue(value *ntt_meta.Lifecycle) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion struct

+ func (AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataLifecycleBlockDeletion) WithValue(value bool) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataLifecycleState struct

+ func (AlertingPolicyPathSelectorMetadataLifecycleState) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataLifecycleState) WithArrayOfValues(values []ntt_meta.Lifecycle_State) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataLifecycleState) WithValue(value ntt_meta.Lifecycle_State) *AlertingPolicy_FieldSubPathValue

type AlertingPolicyPathSelectorMetadataOwnerReferences

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) Region() AlertingPolicyPathSelectorMetadataOwnerReferencesRegion

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) RequiresOwnerReference() AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) Version() AlertingPolicyPathSelectorMetadataOwnerReferencesVersion

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesRegion struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesRegion) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRegion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRegion) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesRequiresOwnerReference) WithValue(value bool) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesVersion struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesVersion) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesVersion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesVersion) WithValue(value string) *AlertingPolicy_FieldSubPathValue

type AlertingPolicySpecNotificationSlackApp_FieldTerminalPath

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

type AlertingPolicySpecNotificationSlack_FieldSubPath

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

type AlertingPolicySpecNotificationSlack_FieldTerminalPath

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

type AlertingPolicySpecNotification_FieldSubPath

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

type AlertingPolicySpecNotification_FieldTerminalPath

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

type AlertingPolicySpec_FieldSubPath

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

type AlertingPolicySpec_FieldTerminalPath

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

type AlertingPolicy_FieldSubPath

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

type AlertingPolicy_FieldTerminalPath

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

type Name

+ func (name *Name) GetIParentName() gotenresource.Name

+ func (name *Name) GetIUnderlyingParentName() gotenresource.Name

type PagerQuery

+ func (p *PagerQuery) SetCursor(cursor gotenresource.Cursor)

+ func (p *PagerQuery) SetLimit(limit int)

+ func (p *PagerQuery) SetOrderBy(orderBy gotenresource.OrderBy)

+ func (p *PagerQuery) SetPageDirection(direction gotenresource.PageDirection)

+ func (p *PagerQuery) SetPeekForward(peekForward bool)

type ParentName

+ func (name *ParentName) GetIParentName() gotenresource.Name

+ func (name *ParentName) GetIUnderlyingParentName() gotenresource.Name

type ParentReference

+ func (ref *ParentReference) GetIParentName() gotenresource.Name

+ func (ref *ParentReference) GetIUnderlyingParentName() gotenresource.Name

type Reference

+ func (ref *Reference) GetIParentName() gotenresource.Name

+ func (ref *Reference) GetIUnderlyingParentName() gotenresource.Name

Aug 23, 2022

Changes in this version

type ParentReference

+ func (name *ParentReference) ConvertToNative(typeDesc reflect.Type) (interface{}, error)

+ func (name *ParentReference) ConvertToType(typeVal ref.Type) ref.Val

+ func (name *ParentReference) Equal(other ref.Val) ref.Val

+ func (name *ParentReference) HasTrait(trait int) bool

+ func (name *ParentReference) Match(pattern ref.Val) ref.Val

+ func (name *ParentReference) Receive(function string, overload string, args []ref.Val) ref.Val

+ func (name *ParentReference) Type() ref.Type

+ func (name *ParentReference) TypeName() string

+ func (name *ParentReference) Value() interface{}

Jul 17, 2022

Changes in this version

type AlertingPolicyChange

+ func (c *AlertingPolicyChange) GetRawResource() gotenresource.Resource

May 9, 2022

Changes in this version

type WatchQuery

+ func (q *WatchQuery) String() string

Feb 25, 2022

Changes in this version

type Descriptor

+ func (d *Descriptor) NewResourceFieldMask() gotenobject.FieldMask

+ func (d *Descriptor) NewResourceFilter() gotenresource.Filter

+ func (d *Descriptor) NewResourceOrderBy() gotenresource.OrderBy

Feb 17, 2022

Changes in this version

+ const NamePattern_Project_Region

+ var AlertingPolicy_Spec_ConditionsCombiner_name = map[int32]string

+ var AlertingPolicy_Spec_ConditionsCombiner_value = map[string]int32

+ func AsAnyCastAccess(access AlertingPolicyAccess) gotenresource.Access

+ type AlertingPolicy struct

+ Description string

+ DisplayName string

+ Documentation *AlertingPolicy_Documentation

+ Metadata *ntt_meta.Meta

+ Name *Name

+ Spec *AlertingPolicy_Spec

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

+ func (*AlertingPolicy) GotenMessage()

+ func (*AlertingPolicy) ProtoMessage()

+ func (m *AlertingPolicy) GetDescription() string

+ func (m *AlertingPolicy) GetDisplayName() string

+ func (m *AlertingPolicy) GetDocumentation() *AlertingPolicy_Documentation

+ func (m *AlertingPolicy) GetMetadata() *ntt_meta.Meta

+ func (m *AlertingPolicy) GetName() *Name

+ func (m *AlertingPolicy) GetSpec() *AlertingPolicy_Spec

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

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

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

+ func (m *AlertingPolicy) Reset()

+ func (m *AlertingPolicy) SetDescription(fv string)

+ func (m *AlertingPolicy) SetDisplayName(fv string)

+ func (m *AlertingPolicy) SetDocumentation(fv *AlertingPolicy_Documentation)

+ func (m *AlertingPolicy) SetMetadata(fv *ntt_meta.Meta)

+ func (m *AlertingPolicy) SetName(fv *Name)

+ func (m *AlertingPolicy) SetSpec(fv *AlertingPolicy_Spec)

+ func (m *AlertingPolicy) String() string

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

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

+ func (o *AlertingPolicy) Clone() *AlertingPolicy

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

+ func (o *AlertingPolicy) GotenObjectExt()

+ func (o *AlertingPolicy) MakeDiffFieldMask(other *AlertingPolicy) *AlertingPolicy_FieldMask

+ func (o *AlertingPolicy) MakeFullFieldMask() *AlertingPolicy_FieldMask

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

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

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

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

+ func (obj *AlertingPolicy) GotenValidate() error

+ func (r *AlertingPolicy) GetRawName() gotenresource.Name

+ func (r *AlertingPolicy) GetResourceDescriptor() gotenresource.Descriptor

+ func (r *AlertingPolicy) MaybePopulateDefaults() error

+ type AlertingPolicyAccess interface

+ BatchGetAlertingPolicies func(context.Context, []*Reference, ...gotenresource.BatchGetOption) error

+ DeleteAlertingPolicy func(context.Context, *Reference, ...gotenresource.DeleteOption) error

+ GetAlertingPolicy func(context.Context, *GetQuery) (*AlertingPolicy, error)

+ QueryAlertingPolicies func(context.Context, *ListQuery) (*QueryResultSnapshot, error)

+ SaveAlertingPolicy func(context.Context, *AlertingPolicy, ...gotenresource.SaveOption) error

+ WatchAlertingPolicies func(context.Context, *WatchQuery, func(*QueryResultChange) error) error

+ WatchAlertingPolicy func(context.Context, *GetQuery, func(*AlertingPolicyChange) error) error

+ type AlertingPolicyChange struct

+ ChangeType isAlertingPolicyChange_ChangeType

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

+ func (*AlertingPolicyChange) GotenMessage()

+ func (*AlertingPolicyChange) ProtoMessage()

+ func (c *AlertingPolicyChange) GetAlertingPolicy() *AlertingPolicy

+ func (c *AlertingPolicyChange) GetAlertingPolicyName() *Name

+ func (c *AlertingPolicyChange) GetCurrentViewIndex() int32

+ func (c *AlertingPolicyChange) GetPreviousViewIndex() int32

+ func (c *AlertingPolicyChange) GetRawName() gotenresource.Name

+ func (c *AlertingPolicyChange) GetResource() gotenresource.Resource

+ func (c *AlertingPolicyChange) IsAdd() bool

+ func (c *AlertingPolicyChange) IsCurrent() bool

+ func (c *AlertingPolicyChange) IsDelete() bool

+ func (c *AlertingPolicyChange) IsModify() bool

+ func (c *AlertingPolicyChange) SetAddedRaw(snapshot gotenresource.Resource, idx int)

+ func (c *AlertingPolicyChange) SetCurrentRaw(snapshot gotenresource.Resource)

+ func (c *AlertingPolicyChange) SetDeletedRaw(name gotenresource.Name, idx int)

+ func (c *AlertingPolicyChange) SetModifiedRaw(name gotenresource.Name, snapshot gotenresource.Resource, prevIdx int, ...)

+ func (m *AlertingPolicyChange) GetAdded() *AlertingPolicyChange_Added

+ func (m *AlertingPolicyChange) GetChangeType() isAlertingPolicyChange_ChangeType

+ func (m *AlertingPolicyChange) GetCurrent() *AlertingPolicyChange_Current

+ func (m *AlertingPolicyChange) GetModified() *AlertingPolicyChange_Modified

+ func (m *AlertingPolicyChange) GetRemoved() *AlertingPolicyChange_Removed

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

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

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

+ func (m *AlertingPolicyChange) Reset()

+ func (m *AlertingPolicyChange) SetAdded(fv *AlertingPolicyChange_Added)

+ func (m *AlertingPolicyChange) SetChangeType(ofv isAlertingPolicyChange_ChangeType)

+ func (m *AlertingPolicyChange) SetCurrent(fv *AlertingPolicyChange_Current)

+ func (m *AlertingPolicyChange) SetModified(fv *AlertingPolicyChange_Modified)

+ func (m *AlertingPolicyChange) SetRemoved(fv *AlertingPolicyChange_Removed)

+ func (m *AlertingPolicyChange) String() string

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

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

+ func (obj *AlertingPolicyChange) GotenValidate() error

+ type AlertingPolicyChangeList []*AlertingPolicyChange

+ func (l AlertingPolicyChangeList) Append(item gotenresource.ResourceChange) gotenresource.ResourceChangeList

+ func (l AlertingPolicyChangeList) AppendList(list gotenresource.ResourceChangeList) gotenresource.ResourceChangeList

+ func (l AlertingPolicyChangeList) At(idx int) gotenresource.ResourceChange

+ func (l AlertingPolicyChangeList) Length() int

+ func (l AlertingPolicyChangeList) Set(idx int, change gotenresource.ResourceChange)

+ func (l AlertingPolicyChangeList) Slice(first, second int) gotenresource.ResourceChangeList

+ type AlertingPolicyChangeMap map[Name]*AlertingPolicyChange

+ func (m AlertingPolicyChangeMap) Delete(name gotenresource.Name)

+ func (m AlertingPolicyChangeMap) ForEach(cb func(gotenresource.Name, gotenresource.ResourceChange) bool)

+ func (m AlertingPolicyChangeMap) Get(name gotenresource.Name) gotenresource.ResourceChange

+ func (m AlertingPolicyChangeMap) Length() int

+ func (m AlertingPolicyChangeMap) Set(change gotenresource.ResourceChange)

+ type AlertingPolicyChange_Added struct

+ AlertingPolicy *AlertingPolicy

+ ViewIndex int32

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

+ func (*AlertingPolicyChange_Added) GotenMessage()

+ func (*AlertingPolicyChange_Added) ProtoMessage()

+ func (m *AlertingPolicyChange_Added) GetAlertingPolicy() *AlertingPolicy

+ func (m *AlertingPolicyChange_Added) GetViewIndex() int32

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

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

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

+ func (m *AlertingPolicyChange_Added) Reset()

+ func (m *AlertingPolicyChange_Added) SetAlertingPolicy(fv *AlertingPolicy)

+ func (m *AlertingPolicyChange_Added) SetViewIndex(fv int32)

+ func (m *AlertingPolicyChange_Added) String() string

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

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

+ func (obj *AlertingPolicyChange_Added) GotenValidate() error

+ type AlertingPolicyChange_Added_ struct

+ Added *AlertingPolicyChange_Added

+ type AlertingPolicyChange_Current struct

+ AlertingPolicy *AlertingPolicy

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

+ func (*AlertingPolicyChange_Current) GotenMessage()

+ func (*AlertingPolicyChange_Current) ProtoMessage()

+ func (m *AlertingPolicyChange_Current) GetAlertingPolicy() *AlertingPolicy

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

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

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

+ func (m *AlertingPolicyChange_Current) Reset()

+ func (m *AlertingPolicyChange_Current) SetAlertingPolicy(fv *AlertingPolicy)

+ func (m *AlertingPolicyChange_Current) String() string

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

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

+ func (obj *AlertingPolicyChange_Current) GotenValidate() error

+ type AlertingPolicyChange_Current_ struct

+ Current *AlertingPolicyChange_Current

+ type AlertingPolicyChange_Modified struct

+ AlertingPolicy *AlertingPolicy

+ FieldMask *AlertingPolicy_FieldMask

+ Name *Name

+ PreviousViewIndex int32

+ ViewIndex int32

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

+ func (*AlertingPolicyChange_Modified) GotenMessage()

+ func (*AlertingPolicyChange_Modified) ProtoMessage()

+ func (m *AlertingPolicyChange_Modified) GetAlertingPolicy() *AlertingPolicy

+ func (m *AlertingPolicyChange_Modified) GetFieldMask() *AlertingPolicy_FieldMask

+ func (m *AlertingPolicyChange_Modified) GetName() *Name

+ func (m *AlertingPolicyChange_Modified) GetPreviousViewIndex() int32

+ func (m *AlertingPolicyChange_Modified) GetViewIndex() int32

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

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

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

+ func (m *AlertingPolicyChange_Modified) Reset()

+ func (m *AlertingPolicyChange_Modified) SetAlertingPolicy(fv *AlertingPolicy)

+ func (m *AlertingPolicyChange_Modified) SetFieldMask(fv *AlertingPolicy_FieldMask)

+ func (m *AlertingPolicyChange_Modified) SetName(fv *Name)

+ func (m *AlertingPolicyChange_Modified) SetPreviousViewIndex(fv int32)

+ func (m *AlertingPolicyChange_Modified) SetViewIndex(fv int32)

+ func (m *AlertingPolicyChange_Modified) String() string

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

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

+ func (obj *AlertingPolicyChange_Modified) GotenValidate() error

+ type AlertingPolicyChange_Modified_ struct

+ Modified *AlertingPolicyChange_Modified

+ type AlertingPolicyChange_Removed struct

+ Name *Name

+ ViewIndex int32

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

+ func (*AlertingPolicyChange_Removed) GotenMessage()

+ func (*AlertingPolicyChange_Removed) ProtoMessage()

+ func (m *AlertingPolicyChange_Removed) GetName() *Name

+ func (m *AlertingPolicyChange_Removed) GetViewIndex() int32

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

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

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

+ func (m *AlertingPolicyChange_Removed) Reset()

+ func (m *AlertingPolicyChange_Removed) SetName(fv *Name)

+ func (m *AlertingPolicyChange_Removed) SetViewIndex(fv int32)

+ func (m *AlertingPolicyChange_Removed) String() string

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

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

+ func (obj *AlertingPolicyChange_Removed) GotenValidate() error

+ type AlertingPolicyChange_Removed_ struct

+ Removed *AlertingPolicyChange_Removed

+ type AlertingPolicyDocumentationFieldPathBuilder struct

+ func NewAlertingPolicyDocumentationFieldPathBuilder() AlertingPolicyDocumentationFieldPathBuilder

+ func (AlertingPolicyDocumentationFieldPathBuilder) Content() AlertingPolicy_DocumentationPathSelectorContent

+ func (AlertingPolicyDocumentationFieldPathBuilder) MimeType() AlertingPolicy_DocumentationPathSelectorMimeType

+ type AlertingPolicyDocumentation_FieldPath interface

+ ClearValue func(item *AlertingPolicy_Documentation)

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

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

+ Selector func() AlertingPolicyDocumentation_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) AlertingPolicyDocumentation_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) AlertingPolicyDocumentation_FieldPathArrayOfValues

+ WithIValue func(value interface{}) AlertingPolicyDocumentation_FieldPathValue

+ func BuildAlertingPolicyDocumentation_FieldPath(fp gotenobject.RawFieldPath) (AlertingPolicyDocumentation_FieldPath, error)

+ func MustParseAlertingPolicyDocumentation_FieldPath(rawField string) AlertingPolicyDocumentation_FieldPath

+ func ParseAlertingPolicyDocumentation_FieldPath(rawField string) (AlertingPolicyDocumentation_FieldPath, error)

+ type AlertingPolicyDocumentation_FieldPathArrayItemValue interface

+ ContainsValue func(*AlertingPolicy_Documentation) bool

+ func MustParseAlertingPolicyDocumentation_FieldPathArrayItemValue(pathStr, valueStr string) AlertingPolicyDocumentation_FieldPathArrayItemValue

+ func ParseAlertingPolicyDocumentation_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingPolicyDocumentation_FieldPathArrayItemValue, error)

+ type AlertingPolicyDocumentation_FieldPathArrayOfValues interface

+ func MustParseAlertingPolicyDocumentation_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingPolicyDocumentation_FieldPathArrayOfValues

+ func ParseAlertingPolicyDocumentation_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingPolicyDocumentation_FieldPathArrayOfValues, error)

+ type AlertingPolicyDocumentation_FieldPathSelector int32

+ const AlertingPolicyDocumentation_FieldPathSelectorContent

+ const AlertingPolicyDocumentation_FieldPathSelectorMimeType

+ func (s AlertingPolicyDocumentation_FieldPathSelector) String() string

+ type AlertingPolicyDocumentation_FieldPathValue interface

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

+ SetTo func(target **AlertingPolicy_Documentation)

+ func MustParseAlertingPolicyDocumentation_FieldPathValue(pathStr, valueStr string) AlertingPolicyDocumentation_FieldPathValue

+ func ParseAlertingPolicyDocumentation_FieldPathValue(pathStr, valueStr string) (AlertingPolicyDocumentation_FieldPathValue, error)

+ type AlertingPolicyDocumentation_FieldTerminalPath struct

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) ClearValue(item *AlertingPolicy_Documentation)

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

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) Get(source *AlertingPolicy_Documentation) (values []interface{})

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

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

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) GetSingle(source *AlertingPolicy_Documentation) (interface{}, bool)

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

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) IsLeaf() bool

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) JSONString() string

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) Selector() AlertingPolicyDocumentation_FieldPathSelector

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) String() string

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingPolicyDocumentation_FieldPathArrayItemValue

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingPolicyDocumentation_FieldPathArrayOfValues

+ func (fp *AlertingPolicyDocumentation_FieldTerminalPath) WithIValue(value interface{}) AlertingPolicyDocumentation_FieldPathValue

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

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

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

+ type AlertingPolicyDocumentation_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *AlertingPolicyDocumentation_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingPolicy_Documentation) bool

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

+ func (fpaiv *AlertingPolicyDocumentation_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingPolicy_Documentation) (interface{}, bool)

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

+ type AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues struct

+ func (fpaov *AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues) AsContentArrayOfValues() ([]string, bool)

+ func (fpaov *AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues) AsMimeTypeArrayOfValues() ([]string, bool)

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

+ type AlertingPolicyDocumentation_FieldTerminalPathValue struct

+ func (fpv *AlertingPolicyDocumentation_FieldTerminalPathValue) AsContentValue() (string, bool)

+ func (fpv *AlertingPolicyDocumentation_FieldTerminalPathValue) AsMimeTypeValue() (string, bool)

+ func (fpv *AlertingPolicyDocumentation_FieldTerminalPathValue) CompareWith(source *AlertingPolicy_Documentation) (int, bool)

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

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

+ func (fpv *AlertingPolicyDocumentation_FieldTerminalPathValue) SetTo(target **AlertingPolicy_Documentation)

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

+ type AlertingPolicyFieldPathBuilder struct

+ func NewAlertingPolicyFieldPathBuilder() AlertingPolicyFieldPathBuilder

+ func (AlertingPolicyFieldPathBuilder) Description() AlertingPolicyPathSelectorDescription

+ func (AlertingPolicyFieldPathBuilder) DisplayName() AlertingPolicyPathSelectorDisplayName

+ func (AlertingPolicyFieldPathBuilder) Documentation() AlertingPolicyPathSelectorDocumentation

+ func (AlertingPolicyFieldPathBuilder) Metadata() AlertingPolicyPathSelectorMetadata

+ func (AlertingPolicyFieldPathBuilder) Name() AlertingPolicyPathSelectorName

+ func (AlertingPolicyFieldPathBuilder) Spec() AlertingPolicyPathSelectorSpec

+ type AlertingPolicyList []*AlertingPolicy

+ func (l AlertingPolicyList) Append(item gotenresource.Resource) gotenresource.ResourceList

+ func (l AlertingPolicyList) AppendList(list gotenresource.ResourceList) gotenresource.ResourceList

+ func (l AlertingPolicyList) At(idx int) gotenresource.Resource

+ func (l AlertingPolicyList) Length() int

+ func (l AlertingPolicyList) Set(idx int, res gotenresource.Resource)

+ func (l AlertingPolicyList) Slice(first, second int) gotenresource.ResourceList

+ type AlertingPolicyMap map[Name]*AlertingPolicy

+ func (m AlertingPolicyMap) Delete(name gotenresource.Name)

+ func (m AlertingPolicyMap) ForEach(cb func(gotenresource.Name, gotenresource.Resource) bool)

+ func (m AlertingPolicyMap) Get(name gotenresource.Name) gotenresource.Resource

+ func (m AlertingPolicyMap) Length() int

+ func (m AlertingPolicyMap) Set(res gotenresource.Resource)

+ type AlertingPolicyMapPathSelectorMetadataAnnotations struct

+ func (s AlertingPolicyMapPathSelectorMetadataAnnotations) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyMapPathSelectorMetadataAnnotations) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyMapPathSelectorMetadataAnnotations) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyMapPathSelectorMetadataLabels struct

+ func (s AlertingPolicyMapPathSelectorMetadataLabels) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyMapPathSelectorMetadataLabels) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyMapPathSelectorMetadataLabels) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyMapPathSelectorMetadataShards struct

+ func (s AlertingPolicyMapPathSelectorMetadataShards) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyMapPathSelectorMetadataShards) WithArrayOfValues(values []int64) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyMapPathSelectorMetadataShards) WithValue(value int64) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyNameList []*Name

+ func (l AlertingPolicyNameList) Append(name gotenresource.Name) gotenresource.NameList

+ func (l AlertingPolicyNameList) AppendList(list gotenresource.NameList) gotenresource.NameList

+ func (l AlertingPolicyNameList) At(idx int) gotenresource.Name

+ func (l AlertingPolicyNameList) Length() int

+ func (l AlertingPolicyNameList) Set(idx int, name gotenresource.Name)

+ func (l AlertingPolicyNameList) Slice(first, second int) gotenresource.NameList

+ type AlertingPolicyParentNameList []*ParentName

+ func (l AlertingPolicyParentNameList) Append(name gotenresource.Name) gotenresource.ParentNameList

+ func (l AlertingPolicyParentNameList) AppendList(list gotenresource.ParentNameList) gotenresource.ParentNameList

+ func (l AlertingPolicyParentNameList) At(idx int) gotenresource.Name

+ func (l AlertingPolicyParentNameList) Length() int

+ func (l AlertingPolicyParentNameList) Set(idx int, name gotenresource.Name)

+ func (l AlertingPolicyParentNameList) Slice(first, second int) gotenresource.ParentNameList

+ type AlertingPolicyParentReferenceList []*ParentReference

+ func (l AlertingPolicyParentReferenceList) Append(ref gotenresource.Reference) gotenresource.ParentReferenceList

+ func (l AlertingPolicyParentReferenceList) AppendList(list gotenresource.ParentReferenceList) gotenresource.ParentReferenceList

+ func (l AlertingPolicyParentReferenceList) At(idx int) gotenresource.Reference

+ func (l AlertingPolicyParentReferenceList) Length() int

+ func (l AlertingPolicyParentReferenceList) Set(idx int, ref gotenresource.Reference)

+ func (l AlertingPolicyParentReferenceList) Slice(first, second int) gotenresource.ParentReferenceList

+ type AlertingPolicyPathSelectorDescription struct

+ func (AlertingPolicyPathSelectorDescription) FieldPath() *AlertingPolicy_FieldTerminalPath

+ func (s AlertingPolicyPathSelectorDescription) WithArrayOfValues(values []string) *AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicyPathSelectorDescription) WithValue(value string) *AlertingPolicy_FieldTerminalPathValue

+ type AlertingPolicyPathSelectorDisplayName struct

+ func (AlertingPolicyPathSelectorDisplayName) FieldPath() *AlertingPolicy_FieldTerminalPath

+ func (s AlertingPolicyPathSelectorDisplayName) WithArrayOfValues(values []string) *AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicyPathSelectorDisplayName) WithValue(value string) *AlertingPolicy_FieldTerminalPathValue

+ type AlertingPolicyPathSelectorDocumentation struct

+ func (AlertingPolicyPathSelectorDocumentation) Content() AlertingPolicyPathSelectorDocumentationContent

+ func (AlertingPolicyPathSelectorDocumentation) FieldPath() *AlertingPolicy_FieldTerminalPath

+ func (AlertingPolicyPathSelectorDocumentation) MimeType() AlertingPolicyPathSelectorDocumentationMimeType

+ func (AlertingPolicyPathSelectorDocumentation) WithSubPath(subPath AlertingPolicyDocumentation_FieldPath) *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorDocumentation) WithArrayOfValues(values []*AlertingPolicy_Documentation) *AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicyPathSelectorDocumentation) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicyDocumentation_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorDocumentation) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicyDocumentation_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorDocumentation) WithSubValue(subPathValue AlertingPolicyDocumentation_FieldPathValue) *AlertingPolicy_FieldSubPathValue

+ func (s AlertingPolicyPathSelectorDocumentation) WithValue(value *AlertingPolicy_Documentation) *AlertingPolicy_FieldTerminalPathValue

+ type AlertingPolicyPathSelectorDocumentationContent struct

+ func (AlertingPolicyPathSelectorDocumentationContent) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorDocumentationContent) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorDocumentationContent) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorDocumentationMimeType struct

+ func (AlertingPolicyPathSelectorDocumentationMimeType) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorDocumentationMimeType) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorDocumentationMimeType) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadata struct

+ func (AlertingPolicyPathSelectorMetadata) Annotations() AlertingPolicyPathSelectorMetadataAnnotations

+ func (AlertingPolicyPathSelectorMetadata) CreateTime() AlertingPolicyPathSelectorMetadataCreateTime

+ func (AlertingPolicyPathSelectorMetadata) FieldPath() *AlertingPolicy_FieldTerminalPath

+ func (AlertingPolicyPathSelectorMetadata) Generation() AlertingPolicyPathSelectorMetadataGeneration

+ func (AlertingPolicyPathSelectorMetadata) Labels() AlertingPolicyPathSelectorMetadataLabels

+ func (AlertingPolicyPathSelectorMetadata) OwnerReferences() AlertingPolicyPathSelectorMetadataOwnerReferences

+ func (AlertingPolicyPathSelectorMetadata) ResourceVersion() AlertingPolicyPathSelectorMetadataResourceVersion

+ func (AlertingPolicyPathSelectorMetadata) Shards() AlertingPolicyPathSelectorMetadataShards

+ func (AlertingPolicyPathSelectorMetadata) Syncing() AlertingPolicyPathSelectorMetadataSyncing

+ func (AlertingPolicyPathSelectorMetadata) Tags() AlertingPolicyPathSelectorMetadataTags

+ func (AlertingPolicyPathSelectorMetadata) UpdateTime() AlertingPolicyPathSelectorMetadataUpdateTime

+ func (AlertingPolicyPathSelectorMetadata) Uuid() AlertingPolicyPathSelectorMetadataUuid

+ func (AlertingPolicyPathSelectorMetadata) WithSubPath(subPath ntt_meta.Meta_FieldPath) *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadata) WithArrayOfValues(values []*ntt_meta.Meta) *AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadata) WithSubArrayItemValue(subPathArrayItemValue ntt_meta.Meta_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorMetadata) WithSubArrayOfValues(subPathArrayOfValues ntt_meta.Meta_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadata) WithSubValue(subPathValue ntt_meta.Meta_FieldPathValue) *AlertingPolicy_FieldSubPathValue

+ func (s AlertingPolicyPathSelectorMetadata) WithValue(value *ntt_meta.Meta) *AlertingPolicy_FieldTerminalPathValue

+ type AlertingPolicyPathSelectorMetadataAnnotations struct

+ func (AlertingPolicyPathSelectorMetadataAnnotations) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorMetadataAnnotations) WithKey(key string) AlertingPolicyMapPathSelectorMetadataAnnotations

+ func (s AlertingPolicyPathSelectorMetadataAnnotations) WithArrayOfValues(values []map[string]string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataAnnotations) WithValue(value map[string]string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataCreateTime struct

+ func (AlertingPolicyPathSelectorMetadataCreateTime) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataCreateTime) WithArrayOfValues(values []*timestamp.Timestamp) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataCreateTime) WithValue(value *timestamp.Timestamp) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataGeneration struct

+ func (AlertingPolicyPathSelectorMetadataGeneration) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataGeneration) WithArrayOfValues(values []int64) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataGeneration) WithValue(value int64) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataLabels struct

+ func (AlertingPolicyPathSelectorMetadataLabels) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorMetadataLabels) WithKey(key string) AlertingPolicyMapPathSelectorMetadataLabels

+ func (s AlertingPolicyPathSelectorMetadataLabels) WithArrayOfValues(values []map[string]string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataLabels) WithValue(value map[string]string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferences struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) ApiVersion() AlertingPolicyPathSelectorMetadataOwnerReferencesApiVersion

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) BlockOwnerDeletion() AlertingPolicyPathSelectorMetadataOwnerReferencesBlockOwnerDeletion

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) Controller() AlertingPolicyPathSelectorMetadataOwnerReferencesController

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) Kind() AlertingPolicyPathSelectorMetadataOwnerReferencesKind

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) Name() AlertingPolicyPathSelectorMetadataOwnerReferencesName

+ func (AlertingPolicyPathSelectorMetadataOwnerReferences) Uid() AlertingPolicyPathSelectorMetadataOwnerReferencesUid

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferences) WithArrayOfValues(values [][]*ntt_meta.OwnerReference) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferences) WithItemValue(value *ntt_meta.OwnerReference) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferences) WithValue(value []*ntt_meta.OwnerReference) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesApiVersion struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesApiVersion) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesApiVersion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesApiVersion) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesBlockOwnerDeletion struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesBlockOwnerDeletion) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesBlockOwnerDeletion) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesBlockOwnerDeletion) WithValue(value bool) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesController struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesController) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesController) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesController) WithValue(value bool) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesKind struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesKind) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesKind) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesKind) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesName struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesName) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesName) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesName) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataOwnerReferencesUid struct

+ func (AlertingPolicyPathSelectorMetadataOwnerReferencesUid) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesUid) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataOwnerReferencesUid) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataResourceVersion struct

+ func (AlertingPolicyPathSelectorMetadataResourceVersion) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataResourceVersion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataResourceVersion) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataShards struct

+ func (AlertingPolicyPathSelectorMetadataShards) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorMetadataShards) WithKey(key string) AlertingPolicyMapPathSelectorMetadataShards

+ func (s AlertingPolicyPathSelectorMetadataShards) WithArrayOfValues(values []map[string]int64) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataShards) WithValue(value map[string]int64) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataSyncing struct

+ func (AlertingPolicyPathSelectorMetadataSyncing) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorMetadataSyncing) OwningRegion() AlertingPolicyPathSelectorMetadataSyncingOwningRegion

+ func (AlertingPolicyPathSelectorMetadataSyncing) Regions() AlertingPolicyPathSelectorMetadataSyncingRegions

+ func (s AlertingPolicyPathSelectorMetadataSyncing) WithArrayOfValues(values []*syncing_meta.SyncingMeta) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataSyncing) WithValue(value *syncing_meta.SyncingMeta) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataSyncingOwningRegion struct

+ func (AlertingPolicyPathSelectorMetadataSyncingOwningRegion) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataSyncingOwningRegion) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataSyncingOwningRegion) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataSyncingRegions struct

+ func (AlertingPolicyPathSelectorMetadataSyncingRegions) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataSyncingRegions) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataSyncingRegions) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorMetadataSyncingRegions) WithValue(value []string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataTags struct

+ func (AlertingPolicyPathSelectorMetadataTags) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataTags) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataTags) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorMetadataTags) WithValue(value []string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataUpdateTime struct

+ func (AlertingPolicyPathSelectorMetadataUpdateTime) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataUpdateTime) WithArrayOfValues(values []*timestamp.Timestamp) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataUpdateTime) WithValue(value *timestamp.Timestamp) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorMetadataUuid struct

+ func (AlertingPolicyPathSelectorMetadataUuid) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorMetadataUuid) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorMetadataUuid) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorName struct

+ func (AlertingPolicyPathSelectorName) FieldPath() *AlertingPolicy_FieldTerminalPath

+ func (s AlertingPolicyPathSelectorName) WithArrayOfValues(values []*Name) *AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicyPathSelectorName) WithValue(value *Name) *AlertingPolicy_FieldTerminalPathValue

+ type AlertingPolicyPathSelectorSpec struct

+ func (AlertingPolicyPathSelectorSpec) ConditionCombiner() AlertingPolicyPathSelectorSpecConditionCombiner

+ func (AlertingPolicyPathSelectorSpec) Enabled() AlertingPolicyPathSelectorSpecEnabled

+ func (AlertingPolicyPathSelectorSpec) FieldPath() *AlertingPolicy_FieldTerminalPath

+ func (AlertingPolicyPathSelectorSpec) Notification() AlertingPolicyPathSelectorSpecNotification

+ func (AlertingPolicyPathSelectorSpec) WithSubPath(subPath AlertingPolicySpec_FieldPath) *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpec) WithArrayOfValues(values []*AlertingPolicy_Spec) *AlertingPolicy_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpec) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicySpec_FieldPathArrayItemValue) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorSpec) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicySpec_FieldPathArrayOfValues) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpec) WithSubValue(subPathValue AlertingPolicySpec_FieldPathValue) *AlertingPolicy_FieldSubPathValue

+ func (s AlertingPolicyPathSelectorSpec) WithValue(value *AlertingPolicy_Spec) *AlertingPolicy_FieldTerminalPathValue

+ type AlertingPolicyPathSelectorSpecConditionCombiner struct

+ func (AlertingPolicyPathSelectorSpecConditionCombiner) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecConditionCombiner) WithArrayOfValues(values []AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecConditionCombiner) WithValue(value AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecEnabled struct

+ func (AlertingPolicyPathSelectorSpecEnabled) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecEnabled) WithArrayOfValues(values []bool) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecEnabled) WithValue(value bool) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotification struct

+ func (AlertingPolicyPathSelectorSpecNotification) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorSpecNotification) Slack() AlertingPolicyPathSelectorSpecNotificationSlack

+ func (s AlertingPolicyPathSelectorSpecNotification) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotification) WithValue(value *AlertingPolicy_Spec_Notification) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotificationSlack struct

+ func (AlertingPolicyPathSelectorSpecNotificationSlack) App() AlertingPolicyPathSelectorSpecNotificationSlackApp

+ func (AlertingPolicyPathSelectorSpecNotificationSlack) FieldPath() *AlertingPolicy_FieldSubPath

+ func (AlertingPolicyPathSelectorSpecNotificationSlack) IncomingWebhook() AlertingPolicyPathSelectorSpecNotificationSlackIncomingWebhook

+ func (s AlertingPolicyPathSelectorSpecNotificationSlack) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification_Slack) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationSlack) WithValue(value *AlertingPolicy_Spec_Notification_Slack) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotificationSlackApp struct

+ func (AlertingPolicyPathSelectorSpecNotificationSlackApp) AuthToken() AlertingPolicyPathSelectorSpecNotificationSlackAppAuthToken

+ func (AlertingPolicyPathSelectorSpecNotificationSlackApp) Channel() AlertingPolicyPathSelectorSpecNotificationSlackAppChannel

+ func (AlertingPolicyPathSelectorSpecNotificationSlackApp) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackApp) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackApp) WithValue(value *AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotificationSlackAppAuthToken struct

+ func (AlertingPolicyPathSelectorSpecNotificationSlackAppAuthToken) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackAppAuthToken) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackAppAuthToken) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotificationSlackAppChannel struct

+ func (AlertingPolicyPathSelectorSpecNotificationSlackAppChannel) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackAppChannel) WithArrayOfValues(values [][]string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackAppChannel) WithItemValue(value string) *AlertingPolicy_FieldSubPathArrayItemValue

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackAppChannel) WithValue(value []string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyPathSelectorSpecNotificationSlackIncomingWebhook struct

+ func (AlertingPolicyPathSelectorSpecNotificationSlackIncomingWebhook) FieldPath() *AlertingPolicy_FieldSubPath

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackIncomingWebhook) WithArrayOfValues(values []string) *AlertingPolicy_FieldSubPathArrayOfValues

+ func (s AlertingPolicyPathSelectorSpecNotificationSlackIncomingWebhook) WithValue(value string) *AlertingPolicy_FieldSubPathValue

+ type AlertingPolicyReferenceList []*Reference

+ func (l AlertingPolicyReferenceList) Append(ref gotenresource.Reference) gotenresource.ReferenceList

+ func (l AlertingPolicyReferenceList) AppendList(list gotenresource.ReferenceList) gotenresource.ReferenceList

+ func (l AlertingPolicyReferenceList) At(idx int) gotenresource.Reference

+ func (l AlertingPolicyReferenceList) Length() int

+ func (l AlertingPolicyReferenceList) Set(idx int, ref gotenresource.Reference)

+ func (l AlertingPolicyReferenceList) Slice(first, second int) gotenresource.ReferenceList

+ type AlertingPolicySpecFieldPathBuilder struct

+ func NewAlertingPolicySpecFieldPathBuilder() AlertingPolicySpecFieldPathBuilder

+ func (AlertingPolicySpecFieldPathBuilder) ConditionCombiner() AlertingPolicy_SpecPathSelectorConditionCombiner

+ func (AlertingPolicySpecFieldPathBuilder) Enabled() AlertingPolicy_SpecPathSelectorEnabled

+ func (AlertingPolicySpecFieldPathBuilder) Notification() AlertingPolicy_SpecPathSelectorNotification

+ type AlertingPolicySpecNotificationFieldPathBuilder struct

+ func NewAlertingPolicySpecNotificationFieldPathBuilder() AlertingPolicySpecNotificationFieldPathBuilder

+ func (AlertingPolicySpecNotificationFieldPathBuilder) Slack() AlertingPolicy_Spec_NotificationPathSelectorSlack

+ type AlertingPolicySpecNotificationSlackAppFieldPathBuilder struct

+ func NewAlertingPolicySpecNotificationSlackAppFieldPathBuilder() AlertingPolicySpecNotificationSlackAppFieldPathBuilder

+ func (AlertingPolicySpecNotificationSlackAppFieldPathBuilder) AuthToken() AlertingPolicy_Spec_Notification_Slack_AppPathSelectorAuthToken

+ func (AlertingPolicySpecNotificationSlackAppFieldPathBuilder) Channel() AlertingPolicy_Spec_Notification_Slack_AppPathSelectorChannel

+ type AlertingPolicySpecNotificationSlackApp_FieldPath interface

+ ClearValue func(item *AlertingPolicy_Spec_Notification_Slack_App)

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

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

+ Selector func() AlertingPolicySpecNotificationSlackApp_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) AlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) AlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues

+ WithIValue func(value interface{}) AlertingPolicySpecNotificationSlackApp_FieldPathValue

+ func BuildAlertingPolicySpecNotificationSlackApp_FieldPath(fp gotenobject.RawFieldPath) (AlertingPolicySpecNotificationSlackApp_FieldPath, error)

+ func MustParseAlertingPolicySpecNotificationSlackApp_FieldPath(rawField string) AlertingPolicySpecNotificationSlackApp_FieldPath

+ func ParseAlertingPolicySpecNotificationSlackApp_FieldPath(rawField string) (AlertingPolicySpecNotificationSlackApp_FieldPath, error)

+ type AlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue interface

+ ContainsValue func(*AlertingPolicy_Spec_Notification_Slack_App) bool

+ func MustParseAlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue(pathStr, valueStr string) AlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue

+ func ParseAlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue, error)

+ type AlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues interface

+ func MustParseAlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues

+ func ParseAlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues, error)

+ type AlertingPolicySpecNotificationSlackApp_FieldPathSelector int32

+ const AlertingPolicySpecNotificationSlackApp_FieldPathSelectorAuthToken

+ const AlertingPolicySpecNotificationSlackApp_FieldPathSelectorChannel

+ func (s AlertingPolicySpecNotificationSlackApp_FieldPathSelector) String() string

+ type AlertingPolicySpecNotificationSlackApp_FieldPathValue interface

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

+ SetTo func(target **AlertingPolicy_Spec_Notification_Slack_App)

+ func MustParseAlertingPolicySpecNotificationSlackApp_FieldPathValue(pathStr, valueStr string) AlertingPolicySpecNotificationSlackApp_FieldPathValue

+ func ParseAlertingPolicySpecNotificationSlackApp_FieldPathValue(pathStr, valueStr string) (AlertingPolicySpecNotificationSlackApp_FieldPathValue, error)

+ type AlertingPolicySpecNotificationSlackApp_FieldTerminalPath struct

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) ClearValue(item *AlertingPolicy_Spec_Notification_Slack_App)

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

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) Get(source *AlertingPolicy_Spec_Notification_Slack_App) (values []interface{})

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

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

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) GetSingle(source *AlertingPolicy_Spec_Notification_Slack_App) (interface{}, bool)

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

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) IsLeaf() bool

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) JSONString() string

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) Selector() AlertingPolicySpecNotificationSlackApp_FieldPathSelector

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) String() string

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues

+ func (fp *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath) WithIValue(value interface{}) AlertingPolicySpecNotificationSlackApp_FieldPathValue

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

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

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

+ type AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayItemValue) AsChannelItemValue() (string, bool)

+ func (fpaiv *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingPolicy_Spec_Notification_Slack_App) bool

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

+ func (fpaiv *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingPolicy_Spec_Notification_Slack_App) (interface{}, bool)

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

+ type AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayOfValues struct

+ func (fpaov *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayOfValues) AsAuthTokenArrayOfValues() ([]string, bool)

+ func (fpaov *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayOfValues) AsChannelArrayOfValues() ([][]string, bool)

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

+ type AlertingPolicySpecNotificationSlackApp_FieldTerminalPathValue struct

+ func (fpv *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathValue) AsAuthTokenValue() (string, bool)

+ func (fpv *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathValue) AsChannelValue() ([]string, bool)

+ func (fpv *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathValue) CompareWith(source *AlertingPolicy_Spec_Notification_Slack_App) (int, bool)

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

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

+ func (fpv *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathValue) SetTo(target **AlertingPolicy_Spec_Notification_Slack_App)

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

+ type AlertingPolicySpecNotificationSlackFieldPathBuilder struct

+ func NewAlertingPolicySpecNotificationSlackFieldPathBuilder() AlertingPolicySpecNotificationSlackFieldPathBuilder

+ func (AlertingPolicySpecNotificationSlackFieldPathBuilder) App() AlertingPolicy_Spec_Notification_SlackPathSelectorApp

+ func (AlertingPolicySpecNotificationSlackFieldPathBuilder) IncomingWebhook() AlertingPolicy_Spec_Notification_SlackPathSelectorIncomingWebhook

+ type AlertingPolicySpecNotificationSlack_FieldPath interface

+ ClearValue func(item *AlertingPolicy_Spec_Notification_Slack)

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

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

+ Selector func() AlertingPolicySpecNotificationSlack_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) AlertingPolicySpecNotificationSlack_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) AlertingPolicySpecNotificationSlack_FieldPathArrayOfValues

+ WithIValue func(value interface{}) AlertingPolicySpecNotificationSlack_FieldPathValue

+ func BuildAlertingPolicySpecNotificationSlack_FieldPath(fp gotenobject.RawFieldPath) (AlertingPolicySpecNotificationSlack_FieldPath, error)

+ func MustParseAlertingPolicySpecNotificationSlack_FieldPath(rawField string) AlertingPolicySpecNotificationSlack_FieldPath

+ func ParseAlertingPolicySpecNotificationSlack_FieldPath(rawField string) (AlertingPolicySpecNotificationSlack_FieldPath, error)

+ type AlertingPolicySpecNotificationSlack_FieldPathArrayItemValue interface

+ ContainsValue func(*AlertingPolicy_Spec_Notification_Slack) bool

+ func MustParseAlertingPolicySpecNotificationSlack_FieldPathArrayItemValue(pathStr, valueStr string) AlertingPolicySpecNotificationSlack_FieldPathArrayItemValue

+ func ParseAlertingPolicySpecNotificationSlack_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingPolicySpecNotificationSlack_FieldPathArrayItemValue, error)

+ type AlertingPolicySpecNotificationSlack_FieldPathArrayOfValues interface

+ func MustParseAlertingPolicySpecNotificationSlack_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingPolicySpecNotificationSlack_FieldPathArrayOfValues

+ func ParseAlertingPolicySpecNotificationSlack_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingPolicySpecNotificationSlack_FieldPathArrayOfValues, error)

+ type AlertingPolicySpecNotificationSlack_FieldPathSelector int32

+ const AlertingPolicySpecNotificationSlack_FieldPathSelectorApp

+ const AlertingPolicySpecNotificationSlack_FieldPathSelectorIncomingWebhook

+ func (s AlertingPolicySpecNotificationSlack_FieldPathSelector) String() string

+ type AlertingPolicySpecNotificationSlack_FieldPathValue interface

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

+ SetTo func(target **AlertingPolicy_Spec_Notification_Slack)

+ func MustParseAlertingPolicySpecNotificationSlack_FieldPathValue(pathStr, valueStr string) AlertingPolicySpecNotificationSlack_FieldPathValue

+ func ParseAlertingPolicySpecNotificationSlack_FieldPathValue(pathStr, valueStr string) (AlertingPolicySpecNotificationSlack_FieldPathValue, error)

+ type AlertingPolicySpecNotificationSlack_FieldSubPath struct

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) AsAppSubPath() (AlertingPolicySpecNotificationSlackApp_FieldPath, bool)

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) ClearValue(item *AlertingPolicy_Spec_Notification_Slack)

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

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) Get(source *AlertingPolicy_Spec_Notification_Slack) (values []interface{})

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

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

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) GetSingle(source *AlertingPolicy_Spec_Notification_Slack) (interface{}, bool)

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

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) IsLeaf() bool

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) JSONString() string

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) Selector() AlertingPolicySpecNotificationSlack_FieldPathSelector

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) String() string

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingPolicySpecNotificationSlack_FieldPathArrayItemValue

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingPolicySpecNotificationSlack_FieldPathArrayOfValues

+ func (fps *AlertingPolicySpecNotificationSlack_FieldSubPath) WithIValue(value interface{}) AlertingPolicySpecNotificationSlack_FieldPathValue

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

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

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

+ type AlertingPolicySpecNotificationSlack_FieldSubPathArrayItemValue struct

+ func (fpaivs *AlertingPolicySpecNotificationSlack_FieldSubPathArrayItemValue) AsAppPathItemValue() (AlertingPolicySpecNotificationSlackApp_FieldPathArrayItemValue, bool)

+ func (fpaivs *AlertingPolicySpecNotificationSlack_FieldSubPathArrayItemValue) ContainsValue(source *AlertingPolicy_Spec_Notification_Slack) bool

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

+ type AlertingPolicySpecNotificationSlack_FieldSubPathArrayOfValues struct

+ func (fpsaov *AlertingPolicySpecNotificationSlack_FieldSubPathArrayOfValues) AsAppPathArrayOfValues() (AlertingPolicySpecNotificationSlackApp_FieldPathArrayOfValues, bool)

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

+ type AlertingPolicySpecNotificationSlack_FieldSubPathValue struct

+ func (fpvs *AlertingPolicySpecNotificationSlack_FieldSubPathValue) AsAppPathValue() (AlertingPolicySpecNotificationSlackApp_FieldPathValue, bool)

+ func (fpvs *AlertingPolicySpecNotificationSlack_FieldSubPathValue) CompareWith(source *AlertingPolicy_Spec_Notification_Slack) (int, bool)

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

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

+ func (fpvs *AlertingPolicySpecNotificationSlack_FieldSubPathValue) SetTo(target **AlertingPolicy_Spec_Notification_Slack)

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

+ type AlertingPolicySpecNotificationSlack_FieldTerminalPath struct

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) ClearValue(item *AlertingPolicy_Spec_Notification_Slack)

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

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) Get(source *AlertingPolicy_Spec_Notification_Slack) (values []interface{})

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

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

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) GetSingle(source *AlertingPolicy_Spec_Notification_Slack) (interface{}, bool)

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

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) IsLeaf() bool

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) JSONString() string

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) Selector() AlertingPolicySpecNotificationSlack_FieldPathSelector

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) String() string

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingPolicySpecNotificationSlack_FieldPathArrayItemValue

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingPolicySpecNotificationSlack_FieldPathArrayOfValues

+ func (fp *AlertingPolicySpecNotificationSlack_FieldTerminalPath) WithIValue(value interface{}) AlertingPolicySpecNotificationSlack_FieldPathValue

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

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

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

+ type AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingPolicy_Spec_Notification_Slack) bool

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

+ func (fpaiv *AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingPolicy_Spec_Notification_Slack) (interface{}, bool)

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

+ type AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayOfValues struct

+ func (fpaov *AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayOfValues) AsAppArrayOfValues() ([]*AlertingPolicy_Spec_Notification_Slack_App, bool)

+ func (fpaov *AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayOfValues) AsIncomingWebhookArrayOfValues() ([]string, bool)

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

+ type AlertingPolicySpecNotificationSlack_FieldTerminalPathValue struct

+ func (fpv *AlertingPolicySpecNotificationSlack_FieldTerminalPathValue) AsAppValue() (*AlertingPolicy_Spec_Notification_Slack_App, bool)

+ func (fpv *AlertingPolicySpecNotificationSlack_FieldTerminalPathValue) AsIncomingWebhookValue() (string, bool)

+ func (fpv *AlertingPolicySpecNotificationSlack_FieldTerminalPathValue) CompareWith(source *AlertingPolicy_Spec_Notification_Slack) (int, bool)

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

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

+ func (fpv *AlertingPolicySpecNotificationSlack_FieldTerminalPathValue) SetTo(target **AlertingPolicy_Spec_Notification_Slack)

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

+ type AlertingPolicySpecNotification_FieldPath interface

+ ClearValue func(item *AlertingPolicy_Spec_Notification)

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

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

+ Selector func() AlertingPolicySpecNotification_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) AlertingPolicySpecNotification_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) AlertingPolicySpecNotification_FieldPathArrayOfValues

+ WithIValue func(value interface{}) AlertingPolicySpecNotification_FieldPathValue

+ func BuildAlertingPolicySpecNotification_FieldPath(fp gotenobject.RawFieldPath) (AlertingPolicySpecNotification_FieldPath, error)

+ func MustParseAlertingPolicySpecNotification_FieldPath(rawField string) AlertingPolicySpecNotification_FieldPath

+ func ParseAlertingPolicySpecNotification_FieldPath(rawField string) (AlertingPolicySpecNotification_FieldPath, error)

+ type AlertingPolicySpecNotification_FieldPathArrayItemValue interface

+ ContainsValue func(*AlertingPolicy_Spec_Notification) bool

+ func MustParseAlertingPolicySpecNotification_FieldPathArrayItemValue(pathStr, valueStr string) AlertingPolicySpecNotification_FieldPathArrayItemValue

+ func ParseAlertingPolicySpecNotification_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingPolicySpecNotification_FieldPathArrayItemValue, error)

+ type AlertingPolicySpecNotification_FieldPathArrayOfValues interface

+ func MustParseAlertingPolicySpecNotification_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingPolicySpecNotification_FieldPathArrayOfValues

+ func ParseAlertingPolicySpecNotification_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingPolicySpecNotification_FieldPathArrayOfValues, error)

+ type AlertingPolicySpecNotification_FieldPathSelector int32

+ const AlertingPolicySpecNotification_FieldPathSelectorSlack

+ func (s AlertingPolicySpecNotification_FieldPathSelector) String() string

+ type AlertingPolicySpecNotification_FieldPathValue interface

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

+ SetTo func(target **AlertingPolicy_Spec_Notification)

+ func MustParseAlertingPolicySpecNotification_FieldPathValue(pathStr, valueStr string) AlertingPolicySpecNotification_FieldPathValue

+ func ParseAlertingPolicySpecNotification_FieldPathValue(pathStr, valueStr string) (AlertingPolicySpecNotification_FieldPathValue, error)

+ type AlertingPolicySpecNotification_FieldSubPath struct

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) AsSlackSubPath() (AlertingPolicySpecNotificationSlack_FieldPath, bool)

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) ClearValue(item *AlertingPolicy_Spec_Notification)

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

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) Get(source *AlertingPolicy_Spec_Notification) (values []interface{})

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

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

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) GetSingle(source *AlertingPolicy_Spec_Notification) (interface{}, bool)

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

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) IsLeaf() bool

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) JSONString() string

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) Selector() AlertingPolicySpecNotification_FieldPathSelector

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) String() string

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingPolicySpecNotification_FieldPathArrayItemValue

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingPolicySpecNotification_FieldPathArrayOfValues

+ func (fps *AlertingPolicySpecNotification_FieldSubPath) WithIValue(value interface{}) AlertingPolicySpecNotification_FieldPathValue

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

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

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

+ type AlertingPolicySpecNotification_FieldSubPathArrayItemValue struct

+ func (fpaivs *AlertingPolicySpecNotification_FieldSubPathArrayItemValue) AsSlackPathItemValue() (AlertingPolicySpecNotificationSlack_FieldPathArrayItemValue, bool)

+ func (fpaivs *AlertingPolicySpecNotification_FieldSubPathArrayItemValue) ContainsValue(source *AlertingPolicy_Spec_Notification) bool

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

+ type AlertingPolicySpecNotification_FieldSubPathArrayOfValues struct

+ func (fpsaov *AlertingPolicySpecNotification_FieldSubPathArrayOfValues) AsSlackPathArrayOfValues() (AlertingPolicySpecNotificationSlack_FieldPathArrayOfValues, bool)

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

+ type AlertingPolicySpecNotification_FieldSubPathValue struct

+ func (fpvs *AlertingPolicySpecNotification_FieldSubPathValue) AsSlackPathValue() (AlertingPolicySpecNotificationSlack_FieldPathValue, bool)

+ func (fpvs *AlertingPolicySpecNotification_FieldSubPathValue) CompareWith(source *AlertingPolicy_Spec_Notification) (int, bool)

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

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

+ func (fpvs *AlertingPolicySpecNotification_FieldSubPathValue) SetTo(target **AlertingPolicy_Spec_Notification)

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

+ type AlertingPolicySpecNotification_FieldTerminalPath struct

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) ClearValue(item *AlertingPolicy_Spec_Notification)

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

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) Get(source *AlertingPolicy_Spec_Notification) (values []interface{})

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

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

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) GetSingle(source *AlertingPolicy_Spec_Notification) (interface{}, bool)

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

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) IsLeaf() bool

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) JSONString() string

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) Selector() AlertingPolicySpecNotification_FieldPathSelector

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) String() string

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingPolicySpecNotification_FieldPathArrayItemValue

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingPolicySpecNotification_FieldPathArrayOfValues

+ func (fp *AlertingPolicySpecNotification_FieldTerminalPath) WithIValue(value interface{}) AlertingPolicySpecNotification_FieldPathValue

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

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

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

+ type AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingPolicy_Spec_Notification) bool

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

+ func (fpaiv *AlertingPolicySpecNotification_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingPolicy_Spec_Notification) (interface{}, bool)

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

+ type AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues struct

+ func (fpaov *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues) AsSlackArrayOfValues() ([]*AlertingPolicy_Spec_Notification_Slack, bool)

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

+ type AlertingPolicySpecNotification_FieldTerminalPathValue struct

+ func (fpv *AlertingPolicySpecNotification_FieldTerminalPathValue) AsSlackValue() (*AlertingPolicy_Spec_Notification_Slack, bool)

+ func (fpv *AlertingPolicySpecNotification_FieldTerminalPathValue) CompareWith(source *AlertingPolicy_Spec_Notification) (int, bool)

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

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

+ func (fpv *AlertingPolicySpecNotification_FieldTerminalPathValue) SetTo(target **AlertingPolicy_Spec_Notification)

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

+ type AlertingPolicySpec_FieldPath interface

+ ClearValue func(item *AlertingPolicy_Spec)

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

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

+ Selector func() AlertingPolicySpec_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) AlertingPolicySpec_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) AlertingPolicySpec_FieldPathArrayOfValues

+ WithIValue func(value interface{}) AlertingPolicySpec_FieldPathValue

+ func BuildAlertingPolicySpec_FieldPath(fp gotenobject.RawFieldPath) (AlertingPolicySpec_FieldPath, error)

+ func MustParseAlertingPolicySpec_FieldPath(rawField string) AlertingPolicySpec_FieldPath

+ func ParseAlertingPolicySpec_FieldPath(rawField string) (AlertingPolicySpec_FieldPath, error)

+ type AlertingPolicySpec_FieldPathArrayItemValue interface

+ ContainsValue func(*AlertingPolicy_Spec) bool

+ func MustParseAlertingPolicySpec_FieldPathArrayItemValue(pathStr, valueStr string) AlertingPolicySpec_FieldPathArrayItemValue

+ func ParseAlertingPolicySpec_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingPolicySpec_FieldPathArrayItemValue, error)

+ type AlertingPolicySpec_FieldPathArrayOfValues interface

+ func MustParseAlertingPolicySpec_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingPolicySpec_FieldPathArrayOfValues

+ func ParseAlertingPolicySpec_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingPolicySpec_FieldPathArrayOfValues, error)

+ type AlertingPolicySpec_FieldPathSelector int32

+ const AlertingPolicySpec_FieldPathSelectorConditionCombiner

+ const AlertingPolicySpec_FieldPathSelectorEnabled

+ const AlertingPolicySpec_FieldPathSelectorNotification

+ func (s AlertingPolicySpec_FieldPathSelector) String() string

+ type AlertingPolicySpec_FieldPathValue interface

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

+ SetTo func(target **AlertingPolicy_Spec)

+ func MustParseAlertingPolicySpec_FieldPathValue(pathStr, valueStr string) AlertingPolicySpec_FieldPathValue

+ func ParseAlertingPolicySpec_FieldPathValue(pathStr, valueStr string) (AlertingPolicySpec_FieldPathValue, error)

+ type AlertingPolicySpec_FieldSubPath struct

+ func (fps *AlertingPolicySpec_FieldSubPath) AsNotificationSubPath() (AlertingPolicySpecNotification_FieldPath, bool)

+ func (fps *AlertingPolicySpec_FieldSubPath) ClearValue(item *AlertingPolicy_Spec)

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

+ func (fps *AlertingPolicySpec_FieldSubPath) Get(source *AlertingPolicy_Spec) (values []interface{})

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

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

+ func (fps *AlertingPolicySpec_FieldSubPath) GetSingle(source *AlertingPolicy_Spec) (interface{}, bool)

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

+ func (fps *AlertingPolicySpec_FieldSubPath) IsLeaf() bool

+ func (fps *AlertingPolicySpec_FieldSubPath) JSONString() string

+ func (fps *AlertingPolicySpec_FieldSubPath) Selector() AlertingPolicySpec_FieldPathSelector

+ func (fps *AlertingPolicySpec_FieldSubPath) String() string

+ func (fps *AlertingPolicySpec_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingPolicySpec_FieldPathArrayItemValue

+ func (fps *AlertingPolicySpec_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingPolicySpec_FieldPathArrayOfValues

+ func (fps *AlertingPolicySpec_FieldSubPath) WithIValue(value interface{}) AlertingPolicySpec_FieldPathValue

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

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

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

+ type AlertingPolicySpec_FieldSubPathArrayItemValue struct

+ func (fpaivs *AlertingPolicySpec_FieldSubPathArrayItemValue) AsNotificationPathItemValue() (AlertingPolicySpecNotification_FieldPathArrayItemValue, bool)

+ func (fpaivs *AlertingPolicySpec_FieldSubPathArrayItemValue) ContainsValue(source *AlertingPolicy_Spec) bool

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

+ type AlertingPolicySpec_FieldSubPathArrayOfValues struct

+ func (fpsaov *AlertingPolicySpec_FieldSubPathArrayOfValues) AsNotificationPathArrayOfValues() (AlertingPolicySpecNotification_FieldPathArrayOfValues, bool)

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

+ type AlertingPolicySpec_FieldSubPathValue struct

+ func (fpvs *AlertingPolicySpec_FieldSubPathValue) AsNotificationPathValue() (AlertingPolicySpecNotification_FieldPathValue, bool)

+ func (fpvs *AlertingPolicySpec_FieldSubPathValue) CompareWith(source *AlertingPolicy_Spec) (int, bool)

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

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

+ func (fpvs *AlertingPolicySpec_FieldSubPathValue) SetTo(target **AlertingPolicy_Spec)

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

+ type AlertingPolicySpec_FieldTerminalPath struct

+ func (fp *AlertingPolicySpec_FieldTerminalPath) ClearValue(item *AlertingPolicy_Spec)

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

+ func (fp *AlertingPolicySpec_FieldTerminalPath) Get(source *AlertingPolicy_Spec) (values []interface{})

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

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

+ func (fp *AlertingPolicySpec_FieldTerminalPath) GetSingle(source *AlertingPolicy_Spec) (interface{}, bool)

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

+ func (fp *AlertingPolicySpec_FieldTerminalPath) IsLeaf() bool

+ func (fp *AlertingPolicySpec_FieldTerminalPath) JSONString() string

+ func (fp *AlertingPolicySpec_FieldTerminalPath) Selector() AlertingPolicySpec_FieldPathSelector

+ func (fp *AlertingPolicySpec_FieldTerminalPath) String() string

+ func (fp *AlertingPolicySpec_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingPolicySpec_FieldPathArrayItemValue

+ func (fp *AlertingPolicySpec_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingPolicySpec_FieldPathArrayOfValues

+ func (fp *AlertingPolicySpec_FieldTerminalPath) WithIValue(value interface{}) AlertingPolicySpec_FieldPathValue

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

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

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

+ type AlertingPolicySpec_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *AlertingPolicySpec_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingPolicy_Spec) bool

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

+ func (fpaiv *AlertingPolicySpec_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingPolicy_Spec) (interface{}, bool)

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

+ type AlertingPolicySpec_FieldTerminalPathArrayOfValues struct

+ func (fpaov *AlertingPolicySpec_FieldTerminalPathArrayOfValues) AsConditionCombinerArrayOfValues() ([]AlertingPolicy_Spec_ConditionsCombiner, bool)

+ func (fpaov *AlertingPolicySpec_FieldTerminalPathArrayOfValues) AsEnabledArrayOfValues() ([]bool, bool)

+ func (fpaov *AlertingPolicySpec_FieldTerminalPathArrayOfValues) AsNotificationArrayOfValues() ([]*AlertingPolicy_Spec_Notification, bool)

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

+ type AlertingPolicySpec_FieldTerminalPathValue struct

+ func (fpv *AlertingPolicySpec_FieldTerminalPathValue) AsConditionCombinerValue() (AlertingPolicy_Spec_ConditionsCombiner, bool)

+ func (fpv *AlertingPolicySpec_FieldTerminalPathValue) AsEnabledValue() (bool, bool)

+ func (fpv *AlertingPolicySpec_FieldTerminalPathValue) AsNotificationValue() (*AlertingPolicy_Spec_Notification, bool)

+ func (fpv *AlertingPolicySpec_FieldTerminalPathValue) CompareWith(source *AlertingPolicy_Spec) (int, bool)

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

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

+ func (fpv *AlertingPolicySpec_FieldTerminalPathValue) SetTo(target **AlertingPolicy_Spec)

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

+ type AlertingPolicy_Documentation struct

+ Content string

+ MimeType string

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

+ func (*AlertingPolicy_Documentation) GotenMessage()

+ func (*AlertingPolicy_Documentation) ProtoMessage()

+ func (m *AlertingPolicy_Documentation) GetContent() string

+ func (m *AlertingPolicy_Documentation) GetMimeType() string

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

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

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

+ func (m *AlertingPolicy_Documentation) Reset()

+ func (m *AlertingPolicy_Documentation) SetContent(fv string)

+ func (m *AlertingPolicy_Documentation) SetMimeType(fv string)

+ func (m *AlertingPolicy_Documentation) String() string

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

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

+ func (o *AlertingPolicy_Documentation) Clone() *AlertingPolicy_Documentation

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

+ func (o *AlertingPolicy_Documentation) GotenObjectExt()

+ func (o *AlertingPolicy_Documentation) MakeDiffFieldMask(other *AlertingPolicy_Documentation) *AlertingPolicy_Documentation_FieldMask

+ func (o *AlertingPolicy_Documentation) MakeFullFieldMask() *AlertingPolicy_Documentation_FieldMask

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

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

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

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

+ func (obj *AlertingPolicy_Documentation) GotenValidate() error

+ type AlertingPolicy_DocumentationPathSelectorContent struct

+ func (AlertingPolicy_DocumentationPathSelectorContent) FieldPath() *AlertingPolicyDocumentation_FieldTerminalPath

+ func (s AlertingPolicy_DocumentationPathSelectorContent) WithArrayOfValues(values []string) *AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_DocumentationPathSelectorContent) WithValue(value string) *AlertingPolicyDocumentation_FieldTerminalPathValue

+ type AlertingPolicy_DocumentationPathSelectorMimeType struct

+ func (AlertingPolicy_DocumentationPathSelectorMimeType) FieldPath() *AlertingPolicyDocumentation_FieldTerminalPath

+ func (s AlertingPolicy_DocumentationPathSelectorMimeType) WithArrayOfValues(values []string) *AlertingPolicyDocumentation_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_DocumentationPathSelectorMimeType) WithValue(value string) *AlertingPolicyDocumentation_FieldTerminalPathValue

+ type AlertingPolicy_Documentation_FieldMask struct

+ Paths []AlertingPolicyDocumentation_FieldPath

+ func FullAlertingPolicy_Documentation_FieldMask() *AlertingPolicy_Documentation_FieldMask

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) AppendPath(path AlertingPolicyDocumentation_FieldPath)

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

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

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

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) FilterInputFields() *AlertingPolicy_Documentation_FieldMask

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

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) GetPaths() []AlertingPolicyDocumentation_FieldPath

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

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) IsFull() bool

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) PathsCount() int

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) Project(source *AlertingPolicy_Documentation) *AlertingPolicy_Documentation

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

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) ProtoMessage()

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

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) Reset()

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) Set(target, source *AlertingPolicy_Documentation)

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

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

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) Size() int

+ func (fieldMask *AlertingPolicy_Documentation_FieldMask) String() string

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

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

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

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

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

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

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

+ type AlertingPolicy_FieldMask struct

+ Paths []AlertingPolicy_FieldPath

+ func FullAlertingPolicy_FieldMask() *AlertingPolicy_FieldMask

+ func ResourceViewFieldMask(viewName view.View, extraMask *AlertingPolicy_FieldMask) *AlertingPolicy_FieldMask

+ func (fieldMask *AlertingPolicy_FieldMask) AppendPath(path AlertingPolicy_FieldPath)

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

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

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

+ func (fieldMask *AlertingPolicy_FieldMask) FilterInputFields() *AlertingPolicy_FieldMask

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

+ func (fieldMask *AlertingPolicy_FieldMask) GetPaths() []AlertingPolicy_FieldPath

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

+ func (fieldMask *AlertingPolicy_FieldMask) IsFull() bool

+ func (fieldMask *AlertingPolicy_FieldMask) PathsCount() int

+ func (fieldMask *AlertingPolicy_FieldMask) Project(source *AlertingPolicy) *AlertingPolicy

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

+ func (fieldMask *AlertingPolicy_FieldMask) ProtoMessage()

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

+ func (fieldMask *AlertingPolicy_FieldMask) Reset()

+ func (fieldMask *AlertingPolicy_FieldMask) Set(target, source *AlertingPolicy)

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

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

+ func (fieldMask *AlertingPolicy_FieldMask) Size() int

+ func (fieldMask *AlertingPolicy_FieldMask) String() string

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

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

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

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

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

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

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

+ type AlertingPolicy_FieldPath interface

+ ClearValue func(item *AlertingPolicy)

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

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

+ Selector func() AlertingPolicy_FieldPathSelector

+ WithIArrayItemValue func(value interface{}) AlertingPolicy_FieldPathArrayItemValue

+ WithIArrayOfValues func(values interface{}) AlertingPolicy_FieldPathArrayOfValues

+ WithIValue func(value interface{}) AlertingPolicy_FieldPathValue

+ func BuildAlertingPolicy_FieldPath(fp gotenobject.RawFieldPath) (AlertingPolicy_FieldPath, error)

+ func MustParseAlertingPolicy_FieldPath(rawField string) AlertingPolicy_FieldPath

+ func ParseAlertingPolicy_FieldPath(rawField string) (AlertingPolicy_FieldPath, error)

+ type AlertingPolicy_FieldPathArrayItemValue interface

+ ContainsValue func(*AlertingPolicy) bool

+ func MustParseAlertingPolicy_FieldPathArrayItemValue(pathStr, valueStr string) AlertingPolicy_FieldPathArrayItemValue

+ func ParseAlertingPolicy_FieldPathArrayItemValue(pathStr, valueStr string) (AlertingPolicy_FieldPathArrayItemValue, error)

+ type AlertingPolicy_FieldPathArrayOfValues interface

+ func MustParseAlertingPolicy_FieldPathArrayOfValues(pathStr, valuesStr string) AlertingPolicy_FieldPathArrayOfValues

+ func ParseAlertingPolicy_FieldPathArrayOfValues(pathStr, valuesStr string) (AlertingPolicy_FieldPathArrayOfValues, error)

+ type AlertingPolicy_FieldPathSelector int32

+ const AlertingPolicy_FieldPathSelectorDescription

+ const AlertingPolicy_FieldPathSelectorDisplayName

+ const AlertingPolicy_FieldPathSelectorDocumentation

+ const AlertingPolicy_FieldPathSelectorMetadata

+ const AlertingPolicy_FieldPathSelectorName

+ const AlertingPolicy_FieldPathSelectorSpec

+ func (s AlertingPolicy_FieldPathSelector) String() string

+ type AlertingPolicy_FieldPathValue interface

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

+ SetTo func(target **AlertingPolicy)

+ func MustParseAlertingPolicy_FieldPathValue(pathStr, valueStr string) AlertingPolicy_FieldPathValue

+ func ParseAlertingPolicy_FieldPathValue(pathStr, valueStr string) (AlertingPolicy_FieldPathValue, error)

+ type AlertingPolicy_FieldSubPath struct

+ func (fps *AlertingPolicy_FieldSubPath) AsDocumentationSubPath() (AlertingPolicyDocumentation_FieldPath, bool)

+ func (fps *AlertingPolicy_FieldSubPath) AsMetadataSubPath() (ntt_meta.Meta_FieldPath, bool)

+ func (fps *AlertingPolicy_FieldSubPath) AsSpecSubPath() (AlertingPolicySpec_FieldPath, bool)

+ func (fps *AlertingPolicy_FieldSubPath) ClearValue(item *AlertingPolicy)

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

+ func (fps *AlertingPolicy_FieldSubPath) Get(source *AlertingPolicy) (values []interface{})

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

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

+ func (fps *AlertingPolicy_FieldSubPath) GetSingle(source *AlertingPolicy) (interface{}, bool)

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

+ func (fps *AlertingPolicy_FieldSubPath) IsLeaf() bool

+ func (fps *AlertingPolicy_FieldSubPath) JSONString() string

+ func (fps *AlertingPolicy_FieldSubPath) Selector() AlertingPolicy_FieldPathSelector

+ func (fps *AlertingPolicy_FieldSubPath) String() string

+ func (fps *AlertingPolicy_FieldSubPath) WithIArrayItemValue(value interface{}) AlertingPolicy_FieldPathArrayItemValue

+ func (fps *AlertingPolicy_FieldSubPath) WithIArrayOfValues(values interface{}) AlertingPolicy_FieldPathArrayOfValues

+ func (fps *AlertingPolicy_FieldSubPath) WithIValue(value interface{}) AlertingPolicy_FieldPathValue

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

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

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

+ type AlertingPolicy_FieldSubPathArrayItemValue struct

+ func (fpaivs *AlertingPolicy_FieldSubPathArrayItemValue) AsDocumentationPathItemValue() (AlertingPolicyDocumentation_FieldPathArrayItemValue, bool)

+ func (fpaivs *AlertingPolicy_FieldSubPathArrayItemValue) AsMetadataPathItemValue() (ntt_meta.Meta_FieldPathArrayItemValue, bool)

+ func (fpaivs *AlertingPolicy_FieldSubPathArrayItemValue) AsSpecPathItemValue() (AlertingPolicySpec_FieldPathArrayItemValue, bool)

+ func (fpaivs *AlertingPolicy_FieldSubPathArrayItemValue) ContainsValue(source *AlertingPolicy) bool

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

+ type AlertingPolicy_FieldSubPathArrayOfValues struct

+ func (fpsaov *AlertingPolicy_FieldSubPathArrayOfValues) AsDocumentationPathArrayOfValues() (AlertingPolicyDocumentation_FieldPathArrayOfValues, bool)

+ func (fpsaov *AlertingPolicy_FieldSubPathArrayOfValues) AsMetadataPathArrayOfValues() (ntt_meta.Meta_FieldPathArrayOfValues, bool)

+ func (fpsaov *AlertingPolicy_FieldSubPathArrayOfValues) AsSpecPathArrayOfValues() (AlertingPolicySpec_FieldPathArrayOfValues, bool)

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

+ type AlertingPolicy_FieldSubPathValue struct

+ func (fpvs *AlertingPolicy_FieldSubPathValue) AsDocumentationPathValue() (AlertingPolicyDocumentation_FieldPathValue, bool)

+ func (fpvs *AlertingPolicy_FieldSubPathValue) AsMetadataPathValue() (ntt_meta.Meta_FieldPathValue, bool)

+ func (fpvs *AlertingPolicy_FieldSubPathValue) AsSpecPathValue() (AlertingPolicySpec_FieldPathValue, bool)

+ func (fpvs *AlertingPolicy_FieldSubPathValue) CompareWith(source *AlertingPolicy) (int, bool)

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

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

+ func (fpvs *AlertingPolicy_FieldSubPathValue) SetTo(target **AlertingPolicy)

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

+ type AlertingPolicy_FieldTerminalPath struct

+ func (fp *AlertingPolicy_FieldTerminalPath) ClearValue(item *AlertingPolicy)

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

+ func (fp *AlertingPolicy_FieldTerminalPath) Get(source *AlertingPolicy) (values []interface{})

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

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

+ func (fp *AlertingPolicy_FieldTerminalPath) GetSingle(source *AlertingPolicy) (interface{}, bool)

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

+ func (fp *AlertingPolicy_FieldTerminalPath) IsLeaf() bool

+ func (fp *AlertingPolicy_FieldTerminalPath) JSONString() string

+ func (fp *AlertingPolicy_FieldTerminalPath) Selector() AlertingPolicy_FieldPathSelector

+ func (fp *AlertingPolicy_FieldTerminalPath) String() string

+ func (fp *AlertingPolicy_FieldTerminalPath) WithIArrayItemValue(value interface{}) AlertingPolicy_FieldPathArrayItemValue

+ func (fp *AlertingPolicy_FieldTerminalPath) WithIArrayOfValues(values interface{}) AlertingPolicy_FieldPathArrayOfValues

+ func (fp *AlertingPolicy_FieldTerminalPath) WithIValue(value interface{}) AlertingPolicy_FieldPathValue

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

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

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

+ type AlertingPolicy_FieldTerminalPathArrayItemValue struct

+ func (fpaiv *AlertingPolicy_FieldTerminalPathArrayItemValue) ContainsValue(source *AlertingPolicy) bool

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

+ func (fpaiv *AlertingPolicy_FieldTerminalPathArrayItemValue) GetSingle(source *AlertingPolicy) (interface{}, bool)

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

+ type AlertingPolicy_FieldTerminalPathArrayOfValues struct

+ func (fpaov *AlertingPolicy_FieldTerminalPathArrayOfValues) AsDescriptionArrayOfValues() ([]string, bool)

+ func (fpaov *AlertingPolicy_FieldTerminalPathArrayOfValues) AsDisplayNameArrayOfValues() ([]string, bool)

+ func (fpaov *AlertingPolicy_FieldTerminalPathArrayOfValues) AsDocumentationArrayOfValues() ([]*AlertingPolicy_Documentation, bool)

+ func (fpaov *AlertingPolicy_FieldTerminalPathArrayOfValues) AsMetadataArrayOfValues() ([]*ntt_meta.Meta, bool)

+ func (fpaov *AlertingPolicy_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool)

+ func (fpaov *AlertingPolicy_FieldTerminalPathArrayOfValues) AsSpecArrayOfValues() ([]*AlertingPolicy_Spec, bool)

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

+ type AlertingPolicy_FieldTerminalPathValue struct

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) AsDescriptionValue() (string, bool)

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) AsDisplayNameValue() (string, bool)

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) AsDocumentationValue() (*AlertingPolicy_Documentation, bool)

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) AsMetadataValue() (*ntt_meta.Meta, bool)

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) AsNameValue() (*Name, bool)

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) AsSpecValue() (*AlertingPolicy_Spec, bool)

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) CompareWith(source *AlertingPolicy) (int, bool)

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

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

+ func (fpv *AlertingPolicy_FieldTerminalPathValue) SetTo(target **AlertingPolicy)

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

+ type AlertingPolicy_Spec struct

+ ConditionCombiner AlertingPolicy_Spec_ConditionsCombiner

+ Enabled bool

+ Notification *AlertingPolicy_Spec_Notification

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

+ func (*AlertingPolicy_Spec) GotenMessage()

+ func (*AlertingPolicy_Spec) ProtoMessage()

+ func (m *AlertingPolicy_Spec) GetConditionCombiner() AlertingPolicy_Spec_ConditionsCombiner

+ func (m *AlertingPolicy_Spec) GetEnabled() bool

+ func (m *AlertingPolicy_Spec) GetNotification() *AlertingPolicy_Spec_Notification

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

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

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

+ func (m *AlertingPolicy_Spec) Reset()

+ func (m *AlertingPolicy_Spec) SetConditionCombiner(fv AlertingPolicy_Spec_ConditionsCombiner)

+ func (m *AlertingPolicy_Spec) SetEnabled(fv bool)

+ func (m *AlertingPolicy_Spec) SetNotification(fv *AlertingPolicy_Spec_Notification)

+ func (m *AlertingPolicy_Spec) String() string

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

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

+ func (o *AlertingPolicy_Spec) Clone() *AlertingPolicy_Spec

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

+ func (o *AlertingPolicy_Spec) GotenObjectExt()

+ func (o *AlertingPolicy_Spec) MakeDiffFieldMask(other *AlertingPolicy_Spec) *AlertingPolicy_Spec_FieldMask

+ func (o *AlertingPolicy_Spec) MakeFullFieldMask() *AlertingPolicy_Spec_FieldMask

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

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

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

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

+ func (obj *AlertingPolicy_Spec) GotenValidate() error

+ type AlertingPolicy_SpecPathSelectorConditionCombiner struct

+ func (AlertingPolicy_SpecPathSelectorConditionCombiner) FieldPath() *AlertingPolicySpec_FieldTerminalPath

+ func (s AlertingPolicy_SpecPathSelectorConditionCombiner) WithArrayOfValues(values []AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicySpec_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorConditionCombiner) WithValue(value AlertingPolicy_Spec_ConditionsCombiner) *AlertingPolicySpec_FieldTerminalPathValue

+ type AlertingPolicy_SpecPathSelectorEnabled struct

+ func (AlertingPolicy_SpecPathSelectorEnabled) FieldPath() *AlertingPolicySpec_FieldTerminalPath

+ func (s AlertingPolicy_SpecPathSelectorEnabled) WithArrayOfValues(values []bool) *AlertingPolicySpec_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorEnabled) WithValue(value bool) *AlertingPolicySpec_FieldTerminalPathValue

+ type AlertingPolicy_SpecPathSelectorNotification struct

+ func (AlertingPolicy_SpecPathSelectorNotification) FieldPath() *AlertingPolicySpec_FieldTerminalPath

+ func (AlertingPolicy_SpecPathSelectorNotification) Slack() AlertingPolicy_SpecPathSelectorNotificationSlack

+ func (AlertingPolicy_SpecPathSelectorNotification) WithSubPath(subPath AlertingPolicySpecNotification_FieldPath) *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotification) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification) *AlertingPolicySpec_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotification) WithSubArrayItemValue(subPathArrayItemValue AlertingPolicySpecNotification_FieldPathArrayItemValue) *AlertingPolicySpec_FieldSubPathArrayItemValue

+ func (s AlertingPolicy_SpecPathSelectorNotification) WithSubArrayOfValues(subPathArrayOfValues AlertingPolicySpecNotification_FieldPathArrayOfValues) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotification) WithSubValue(subPathValue AlertingPolicySpecNotification_FieldPathValue) *AlertingPolicySpec_FieldSubPathValue

+ func (s AlertingPolicy_SpecPathSelectorNotification) WithValue(value *AlertingPolicy_Spec_Notification) *AlertingPolicySpec_FieldTerminalPathValue

+ type AlertingPolicy_SpecPathSelectorNotificationSlack struct

+ func (AlertingPolicy_SpecPathSelectorNotificationSlack) App() AlertingPolicy_SpecPathSelectorNotificationSlackApp

+ func (AlertingPolicy_SpecPathSelectorNotificationSlack) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (AlertingPolicy_SpecPathSelectorNotificationSlack) IncomingWebhook() AlertingPolicy_SpecPathSelectorNotificationSlackIncomingWebhook

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlack) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification_Slack) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlack) WithValue(value *AlertingPolicy_Spec_Notification_Slack) *AlertingPolicySpec_FieldSubPathValue

+ type AlertingPolicy_SpecPathSelectorNotificationSlackApp struct

+ func (AlertingPolicy_SpecPathSelectorNotificationSlackApp) AuthToken() AlertingPolicy_SpecPathSelectorNotificationSlackAppAuthToken

+ func (AlertingPolicy_SpecPathSelectorNotificationSlackApp) Channel() AlertingPolicy_SpecPathSelectorNotificationSlackAppChannel

+ func (AlertingPolicy_SpecPathSelectorNotificationSlackApp) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackApp) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackApp) WithValue(value *AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicySpec_FieldSubPathValue

+ type AlertingPolicy_SpecPathSelectorNotificationSlackAppAuthToken struct

+ func (AlertingPolicy_SpecPathSelectorNotificationSlackAppAuthToken) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackAppAuthToken) WithArrayOfValues(values []string) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackAppAuthToken) WithValue(value string) *AlertingPolicySpec_FieldSubPathValue

+ type AlertingPolicy_SpecPathSelectorNotificationSlackAppChannel struct

+ func (AlertingPolicy_SpecPathSelectorNotificationSlackAppChannel) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackAppChannel) WithArrayOfValues(values [][]string) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackAppChannel) WithItemValue(value string) *AlertingPolicySpec_FieldSubPathArrayItemValue

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackAppChannel) WithValue(value []string) *AlertingPolicySpec_FieldSubPathValue

+ type AlertingPolicy_SpecPathSelectorNotificationSlackIncomingWebhook struct

+ func (AlertingPolicy_SpecPathSelectorNotificationSlackIncomingWebhook) FieldPath() *AlertingPolicySpec_FieldSubPath

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackIncomingWebhook) WithArrayOfValues(values []string) *AlertingPolicySpec_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_SpecPathSelectorNotificationSlackIncomingWebhook) WithValue(value string) *AlertingPolicySpec_FieldSubPathValue

+ type AlertingPolicy_Spec_ConditionsCombiner int32

+ const AlertingPolicy_Spec_AND

+ const AlertingPolicy_Spec_OR

+ func (AlertingPolicy_Spec_ConditionsCombiner) Descriptor() preflect.EnumDescriptor

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

+ func (AlertingPolicy_Spec_ConditionsCombiner) Type() preflect.EnumType

+ func (x AlertingPolicy_Spec_ConditionsCombiner) Enum() *AlertingPolicy_Spec_ConditionsCombiner

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

+ func (x AlertingPolicy_Spec_ConditionsCombiner) String() string

+ type AlertingPolicy_Spec_FieldMask struct

+ Paths []AlertingPolicySpec_FieldPath

+ func FullAlertingPolicy_Spec_FieldMask() *AlertingPolicy_Spec_FieldMask

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) AppendPath(path AlertingPolicySpec_FieldPath)

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

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

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

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) FilterInputFields() *AlertingPolicy_Spec_FieldMask

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

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) GetPaths() []AlertingPolicySpec_FieldPath

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

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) IsFull() bool

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) PathsCount() int

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) Project(source *AlertingPolicy_Spec) *AlertingPolicy_Spec

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

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) ProtoMessage()

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

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) Reset()

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) Set(target, source *AlertingPolicy_Spec)

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

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

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) Size() int

+ func (fieldMask *AlertingPolicy_Spec_FieldMask) String() string

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

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

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

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

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

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

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

+ type AlertingPolicy_Spec_Notification struct

+ Slack *AlertingPolicy_Spec_Notification_Slack

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

+ func (*AlertingPolicy_Spec_Notification) GotenMessage()

+ func (*AlertingPolicy_Spec_Notification) ProtoMessage()

+ func (m *AlertingPolicy_Spec_Notification) GetSlack() *AlertingPolicy_Spec_Notification_Slack

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

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

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

+ func (m *AlertingPolicy_Spec_Notification) Reset()

+ func (m *AlertingPolicy_Spec_Notification) SetSlack(fv *AlertingPolicy_Spec_Notification_Slack)

+ func (m *AlertingPolicy_Spec_Notification) String() string

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

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

+ func (o *AlertingPolicy_Spec_Notification) Clone() *AlertingPolicy_Spec_Notification

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

+ func (o *AlertingPolicy_Spec_Notification) GotenObjectExt()

+ func (o *AlertingPolicy_Spec_Notification) MakeDiffFieldMask(other *AlertingPolicy_Spec_Notification) *AlertingPolicy_Spec_Notification_FieldMask

+ func (o *AlertingPolicy_Spec_Notification) MakeFullFieldMask() *AlertingPolicy_Spec_Notification_FieldMask

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

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

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

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

+ func (obj *AlertingPolicy_Spec_Notification) GotenValidate() error

+ type AlertingPolicy_Spec_NotificationPathSelectorSlack struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlack) App() AlertingPolicy_Spec_NotificationPathSelectorSlackApp

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlack) FieldPath() *AlertingPolicySpecNotification_FieldTerminalPath

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlack) IncomingWebhook() AlertingPolicy_Spec_NotificationPathSelectorSlackIncomingWebhook

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlack) WithSubPath(subPath AlertingPolicySpecNotificationSlack_FieldPath) *AlertingPolicySpecNotification_FieldSubPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlack) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification_Slack) *AlertingPolicySpecNotification_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlack) WithSubArrayItemValue(...) *AlertingPolicySpecNotification_FieldSubPathArrayItemValue

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlack) WithSubArrayOfValues(...) *AlertingPolicySpecNotification_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlack) WithSubValue(subPathValue AlertingPolicySpecNotificationSlack_FieldPathValue) *AlertingPolicySpecNotification_FieldSubPathValue

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlack) WithValue(value *AlertingPolicy_Spec_Notification_Slack) *AlertingPolicySpecNotification_FieldTerminalPathValue

+ type AlertingPolicy_Spec_NotificationPathSelectorSlackApp struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlackApp) AuthToken() AlertingPolicy_Spec_NotificationPathSelectorSlackAppAuthToken

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlackApp) Channel() AlertingPolicy_Spec_NotificationPathSelectorSlackAppChannel

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlackApp) FieldPath() *AlertingPolicySpecNotification_FieldSubPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackApp) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicySpecNotification_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackApp) WithValue(value *AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicySpecNotification_FieldSubPathValue

+ type AlertingPolicy_Spec_NotificationPathSelectorSlackAppAuthToken struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlackAppAuthToken) FieldPath() *AlertingPolicySpecNotification_FieldSubPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackAppAuthToken) WithArrayOfValues(values []string) *AlertingPolicySpecNotification_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackAppAuthToken) WithValue(value string) *AlertingPolicySpecNotification_FieldSubPathValue

+ type AlertingPolicy_Spec_NotificationPathSelectorSlackAppChannel struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlackAppChannel) FieldPath() *AlertingPolicySpecNotification_FieldSubPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackAppChannel) WithArrayOfValues(values [][]string) *AlertingPolicySpecNotification_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackAppChannel) WithItemValue(value string) *AlertingPolicySpecNotification_FieldSubPathArrayItemValue

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackAppChannel) WithValue(value []string) *AlertingPolicySpecNotification_FieldSubPathValue

+ type AlertingPolicy_Spec_NotificationPathSelectorSlackIncomingWebhook struct

+ func (AlertingPolicy_Spec_NotificationPathSelectorSlackIncomingWebhook) FieldPath() *AlertingPolicySpecNotification_FieldSubPath

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackIncomingWebhook) WithArrayOfValues(values []string) *AlertingPolicySpecNotification_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_NotificationPathSelectorSlackIncomingWebhook) WithValue(value string) *AlertingPolicySpecNotification_FieldSubPathValue

+ type AlertingPolicy_Spec_Notification_FieldMask struct

+ Paths []AlertingPolicySpecNotification_FieldPath

+ func FullAlertingPolicy_Spec_Notification_FieldMask() *AlertingPolicy_Spec_Notification_FieldMask

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) AppendPath(path AlertingPolicySpecNotification_FieldPath)

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

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

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) FilterInputFields() *AlertingPolicy_Spec_Notification_FieldMask

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) GetPaths() []AlertingPolicySpecNotification_FieldPath

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) IsFull() bool

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) PathsCount() int

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) Project(source *AlertingPolicy_Spec_Notification) *AlertingPolicy_Spec_Notification

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) ProtoMessage()

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) Reset()

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) Set(target, source *AlertingPolicy_Spec_Notification)

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

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) Size() int

+ func (fieldMask *AlertingPolicy_Spec_Notification_FieldMask) String() string

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

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

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

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

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

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

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

+ type AlertingPolicy_Spec_Notification_Slack struct

+ App *AlertingPolicy_Spec_Notification_Slack_App

+ IncomingWebhook string

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

+ func (*AlertingPolicy_Spec_Notification_Slack) GotenMessage()

+ func (*AlertingPolicy_Spec_Notification_Slack) ProtoMessage()

+ func (m *AlertingPolicy_Spec_Notification_Slack) GetApp() *AlertingPolicy_Spec_Notification_Slack_App

+ func (m *AlertingPolicy_Spec_Notification_Slack) GetIncomingWebhook() string

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

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

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

+ func (m *AlertingPolicy_Spec_Notification_Slack) Reset()

+ func (m *AlertingPolicy_Spec_Notification_Slack) SetApp(fv *AlertingPolicy_Spec_Notification_Slack_App)

+ func (m *AlertingPolicy_Spec_Notification_Slack) SetIncomingWebhook(fv string)

+ func (m *AlertingPolicy_Spec_Notification_Slack) String() string

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

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

+ func (o *AlertingPolicy_Spec_Notification_Slack) Clone() *AlertingPolicy_Spec_Notification_Slack

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

+ func (o *AlertingPolicy_Spec_Notification_Slack) GotenObjectExt()

+ func (o *AlertingPolicy_Spec_Notification_Slack) MakeDiffFieldMask(other *AlertingPolicy_Spec_Notification_Slack) *AlertingPolicy_Spec_Notification_Slack_FieldMask

+ func (o *AlertingPolicy_Spec_Notification_Slack) MakeFullFieldMask() *AlertingPolicy_Spec_Notification_Slack_FieldMask

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

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

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

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

+ func (obj *AlertingPolicy_Spec_Notification_Slack) GotenValidate() error

+ type AlertingPolicy_Spec_Notification_SlackPathSelectorApp struct

+ func (AlertingPolicy_Spec_Notification_SlackPathSelectorApp) AuthToken() AlertingPolicy_Spec_Notification_SlackPathSelectorAppAuthToken

+ func (AlertingPolicy_Spec_Notification_SlackPathSelectorApp) Channel() AlertingPolicy_Spec_Notification_SlackPathSelectorAppChannel

+ func (AlertingPolicy_Spec_Notification_SlackPathSelectorApp) FieldPath() *AlertingPolicySpecNotificationSlack_FieldTerminalPath

+ func (AlertingPolicy_Spec_Notification_SlackPathSelectorApp) WithSubPath(subPath AlertingPolicySpecNotificationSlackApp_FieldPath) *AlertingPolicySpecNotificationSlack_FieldSubPath

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorApp) WithArrayOfValues(values []*AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorApp) WithSubArrayItemValue(...) *AlertingPolicySpecNotificationSlack_FieldSubPathArrayItemValue

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorApp) WithSubArrayOfValues(...) *AlertingPolicySpecNotificationSlack_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorApp) WithSubValue(subPathValue AlertingPolicySpecNotificationSlackApp_FieldPathValue) *AlertingPolicySpecNotificationSlack_FieldSubPathValue

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorApp) WithValue(value *AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicySpecNotificationSlack_FieldTerminalPathValue

+ type AlertingPolicy_Spec_Notification_SlackPathSelectorAppAuthToken struct

+ func (AlertingPolicy_Spec_Notification_SlackPathSelectorAppAuthToken) FieldPath() *AlertingPolicySpecNotificationSlack_FieldSubPath

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorAppAuthToken) WithArrayOfValues(values []string) *AlertingPolicySpecNotificationSlack_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorAppAuthToken) WithValue(value string) *AlertingPolicySpecNotificationSlack_FieldSubPathValue

+ type AlertingPolicy_Spec_Notification_SlackPathSelectorAppChannel struct

+ func (AlertingPolicy_Spec_Notification_SlackPathSelectorAppChannel) FieldPath() *AlertingPolicySpecNotificationSlack_FieldSubPath

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorAppChannel) WithArrayOfValues(values [][]string) *AlertingPolicySpecNotificationSlack_FieldSubPathArrayOfValues

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorAppChannel) WithItemValue(value string) *AlertingPolicySpecNotificationSlack_FieldSubPathArrayItemValue

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorAppChannel) WithValue(value []string) *AlertingPolicySpecNotificationSlack_FieldSubPathValue

+ type AlertingPolicy_Spec_Notification_SlackPathSelectorIncomingWebhook struct

+ func (AlertingPolicy_Spec_Notification_SlackPathSelectorIncomingWebhook) FieldPath() *AlertingPolicySpecNotificationSlack_FieldTerminalPath

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorIncomingWebhook) WithArrayOfValues(values []string) *AlertingPolicySpecNotificationSlack_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_Notification_SlackPathSelectorIncomingWebhook) WithValue(value string) *AlertingPolicySpecNotificationSlack_FieldTerminalPathValue

+ type AlertingPolicy_Spec_Notification_Slack_App struct

+ AuthToken string

+ Channel []string

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

+ func (*AlertingPolicy_Spec_Notification_Slack_App) GotenMessage()

+ func (*AlertingPolicy_Spec_Notification_Slack_App) ProtoMessage()

+ func (m *AlertingPolicy_Spec_Notification_Slack_App) GetAuthToken() string

+ func (m *AlertingPolicy_Spec_Notification_Slack_App) GetChannel() []string

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

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

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

+ func (m *AlertingPolicy_Spec_Notification_Slack_App) Reset()

+ func (m *AlertingPolicy_Spec_Notification_Slack_App) SetAuthToken(fv string)

+ func (m *AlertingPolicy_Spec_Notification_Slack_App) SetChannel(fv []string)

+ func (m *AlertingPolicy_Spec_Notification_Slack_App) String() string

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

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

+ func (o *AlertingPolicy_Spec_Notification_Slack_App) Clone() *AlertingPolicy_Spec_Notification_Slack_App

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

+ func (o *AlertingPolicy_Spec_Notification_Slack_App) GotenObjectExt()

+ func (o *AlertingPolicy_Spec_Notification_Slack_App) MakeDiffFieldMask(other *AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicy_Spec_Notification_Slack_App_FieldMask

+ func (o *AlertingPolicy_Spec_Notification_Slack_App) MakeFullFieldMask() *AlertingPolicy_Spec_Notification_Slack_App_FieldMask

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

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

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

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

+ func (obj *AlertingPolicy_Spec_Notification_Slack_App) GotenValidate() error

+ type AlertingPolicy_Spec_Notification_Slack_AppPathSelectorAuthToken struct

+ func (AlertingPolicy_Spec_Notification_Slack_AppPathSelectorAuthToken) FieldPath() *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath

+ func (s AlertingPolicy_Spec_Notification_Slack_AppPathSelectorAuthToken) WithArrayOfValues(values []string) *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_Notification_Slack_AppPathSelectorAuthToken) WithValue(value string) *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathValue

+ type AlertingPolicy_Spec_Notification_Slack_AppPathSelectorChannel struct

+ func (AlertingPolicy_Spec_Notification_Slack_AppPathSelectorChannel) FieldPath() *AlertingPolicySpecNotificationSlackApp_FieldTerminalPath

+ func (s AlertingPolicy_Spec_Notification_Slack_AppPathSelectorChannel) WithArrayOfValues(values [][]string) *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayOfValues

+ func (s AlertingPolicy_Spec_Notification_Slack_AppPathSelectorChannel) WithItemValue(value string) *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathArrayItemValue

+ func (s AlertingPolicy_Spec_Notification_Slack_AppPathSelectorChannel) WithValue(value []string) *AlertingPolicySpecNotificationSlackApp_FieldTerminalPathValue

+ type AlertingPolicy_Spec_Notification_Slack_App_FieldMask struct

+ Paths []AlertingPolicySpecNotificationSlackApp_FieldPath

+ func FullAlertingPolicy_Spec_Notification_Slack_App_FieldMask() *AlertingPolicy_Spec_Notification_Slack_App_FieldMask

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) AppendPath(path AlertingPolicySpecNotificationSlackApp_FieldPath)

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

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

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) FilterInputFields() *AlertingPolicy_Spec_Notification_Slack_App_FieldMask

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) GetPaths() []AlertingPolicySpecNotificationSlackApp_FieldPath

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) IsFull() bool

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) PathsCount() int

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) Project(source *AlertingPolicy_Spec_Notification_Slack_App) *AlertingPolicy_Spec_Notification_Slack_App

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) ProtoMessage()

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) Reset()

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) Set(target, source *AlertingPolicy_Spec_Notification_Slack_App)

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

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) Size() int

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_App_FieldMask) String() string

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

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

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

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

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

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

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

+ type AlertingPolicy_Spec_Notification_Slack_FieldMask struct

+ Paths []AlertingPolicySpecNotificationSlack_FieldPath

+ func FullAlertingPolicy_Spec_Notification_Slack_FieldMask() *AlertingPolicy_Spec_Notification_Slack_FieldMask

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) AppendPath(path AlertingPolicySpecNotificationSlack_FieldPath)

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

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

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) FilterInputFields() *AlertingPolicy_Spec_Notification_Slack_FieldMask

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) GetPaths() []AlertingPolicySpecNotificationSlack_FieldPath

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) IsFull() bool

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) PathsCount() int

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) Project(source *AlertingPolicy_Spec_Notification_Slack) *AlertingPolicy_Spec_Notification_Slack

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) ProtoMessage()

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) Reset()

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) Set(target, source *AlertingPolicy_Spec_Notification_Slack)

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

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

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) Size() int

+ func (fieldMask *AlertingPolicy_Spec_Notification_Slack_FieldMask) String() string

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

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

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

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

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

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

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

+ type Descriptor struct

+ func GetDescriptor() *Descriptor

+ func (d *Descriptor) GetNameDescriptor() *gotenresource.NameDescriptor

+ func (d *Descriptor) GetResourceTypeName() *gotenresource.TypeName

+ func (d *Descriptor) NewAlertingPolicy() *AlertingPolicy

+ func (d *Descriptor) NewAlertingPolicyChange() *AlertingPolicyChange

+ func (d *Descriptor) NewAlertingPolicyChangeList(size, reserved int) AlertingPolicyChangeList

+ func (d *Descriptor) NewAlertingPolicyChangeMap(reserved int) AlertingPolicyChangeMap

+ func (d *Descriptor) NewAlertingPolicyCursor() *PagerCursor

+ func (d *Descriptor) NewAlertingPolicyList(size, reserved int) AlertingPolicyList

+ func (d *Descriptor) NewAlertingPolicyMap(reserved int) AlertingPolicyMap

+ func (d *Descriptor) NewAlertingPolicyName() *Name

+ func (d *Descriptor) NewAlertingPolicyNameList(size, reserved int) AlertingPolicyNameList

+ func (d *Descriptor) NewAlertingPolicyParentNameList(size, reserved int) AlertingPolicyParentNameList

+ func (d *Descriptor) NewAlertingPolicyParentReferenceList(size, reserved int) AlertingPolicyParentReferenceList

+ func (d *Descriptor) NewAlertingPolicyQueryResultChange() *QueryResultChange

+ func (d *Descriptor) NewAlertingPolicyQueryResultSnapshot() *QueryResultSnapshot

+ func (d *Descriptor) NewAlertingPolicyReferenceList(size, reserved int) AlertingPolicyReferenceList

+ func (d *Descriptor) NewGetQuery() gotenresource.GetQuery

+ func (d *Descriptor) NewListQuery() gotenresource.ListQuery

+ func (d *Descriptor) NewNameList(size, reserved int) gotenresource.NameList

+ func (d *Descriptor) NewParentNameList(size, reserved int) gotenresource.ParentNameList

+ func (d *Descriptor) NewParentReferenceList(size, reserved int) gotenresource.ParentReferenceList

+ func (d *Descriptor) NewQueryResultChange() gotenresource.QueryResultChange

+ func (d *Descriptor) NewQueryResultSnapshot() gotenresource.QueryResultSnapshot

+ func (d *Descriptor) NewReferenceList(size, reserved int) gotenresource.ReferenceList

+ func (d *Descriptor) NewResource() gotenresource.Resource

+ func (d *Descriptor) NewResourceChange() gotenresource.ResourceChange

+ func (d *Descriptor) NewResourceChangeList(size, reserved int) gotenresource.ResourceChangeList

+ func (d *Descriptor) NewResourceChangeMap(reserved int) gotenresource.ResourceChangeMap

+ func (d *Descriptor) NewResourceCursor() gotenresource.Cursor

+ func (d *Descriptor) NewResourceList(size, reserved int) gotenresource.ResourceList

+ func (d *Descriptor) NewResourceMap(reserved int) gotenresource.ResourceMap

+ func (d *Descriptor) NewResourceName() gotenresource.Name

+ func (d *Descriptor) NewSearchQuery() gotenresource.SearchQuery

+ func (d *Descriptor) NewSearchQueryResultSnapshot() gotenresource.SearchQueryResultSnapshot

+ func (d *Descriptor) NewWatchQuery() gotenresource.WatchQuery

+ func (d *Descriptor) ParseAlertingPolicyName(nameStr string) (*Name, error)

+ func (d *Descriptor) ParseFieldPath(raw string) (gotenobject.FieldPath, error)

+ func (d *Descriptor) ParseResourceName(nameStr string) (gotenresource.Name, error)

+ type Filter struct

+ func (filter *Filter) ConvertToNative(typeDesc reflect.Type) (interface{}, error)

+ func (filter *Filter) ConvertToType(typeVal ref.Type) ref.Val

+ func (filter *Filter) DecodeFirestore(fpbv *firestorepb.Value) error

+ func (filter *Filter) EncodeFirestore() (*firestorepb.Value, error)

+ func (filter *Filter) Equal(other ref.Val) ref.Val

+ func (filter *Filter) Evaluate(res *AlertingPolicy) bool

+ func (filter *Filter) EvaluateRaw(res gotenresource.Resource) bool

+ func (filter *Filter) FilterSlice(in []*AlertingPolicy) (out []*AlertingPolicy)

+ func (filter *Filter) GetCondition() FilterCondition

+ func (filter *Filter) GetRawCondition() gotenresource.FilterCondition

+ func (filter *Filter) HasTrait(trait int) bool

+ func (filter *Filter) Match(pattern ref.Val) ref.Val

+ func (filter *Filter) ParseProtoString(data string) error

+ func (filter *Filter) ProtoString() (string, error)

+ func (filter *Filter) Receive(function string, overload string, args []ref.Val) ref.Val

+ func (filter *Filter) SetFromCliFlag(raw string) error

+ func (filter *Filter) String() string

+ func (filter *Filter) Type() ref.Type

+ func (filter *Filter) TypeName() string

+ func (filter *Filter) Value() interface{}

+ type FilterBuilder struct

+ func NewAndFilterBuilder() *FilterBuilder

+ func NewFilterBuilder() *FilterBuilder

+ func NewOrFilterBuilder() *FilterBuilder

+ func (b *FilterBuilder) Filter() *Filter

+ func (b *FilterBuilder) Where(opts ...gotenfilter.FilterConditionOption) *filterCndBuilder

+ func (b *FilterBuilder) WherePath(fp AlertingPolicy_FieldPath, opts ...gotenfilter.FilterConditionOption) *filterCndBuilderAnyPath

+ func (b *FilterBuilder) With(condOrBuilder FilterBuilderOrCondition, ...) *FilterBuilder

+ type FilterBuilderOrCondition interface

+ type FilterCondition interface

+ And func(...FilterCondition) FilterCondition

+ Evaluate func(res *AlertingPolicy) bool

+ Satisfies func(other FilterCondition) bool

+ SpecifiesFieldPath func(fp AlertingPolicy_FieldPath) bool

+ func AndFilterConditions(conds ...FilterCondition) FilterCondition

+ type FilterConditionCompare struct

+ Operator filterParser.CompareOperator

+ func (cond *FilterConditionCompare) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionCompare) ConditionCompare()

+ func (cond *FilterConditionCompare) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionCompare) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionCompare) GetOperator() filterParser.CompareOperator

+ func (cond *FilterConditionCompare) GetRawFieldPath() gotenobject.FieldPath

+ func (cond *FilterConditionCompare) GetRawFieldPathValue() gotenobject.FieldPathValue

+ func (cond *FilterConditionCompare) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionCompare) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionCompare) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionCompare) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionCompare) String() string

+ type FilterConditionComposite struct

+ Conditions []FilterCondition

+ Operator filterParser.CompositeOperator

+ func (cond *FilterConditionComposite) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionComposite) ConditionComposite()

+ func (cond *FilterConditionComposite) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionComposite) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionComposite) GetOperator() filterParser.CompositeOperator

+ func (cond *FilterConditionComposite) GetSubConditions() []gotenresource.FilterCondition

+ func (cond *FilterConditionComposite) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionComposite) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionComposite) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionComposite) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionComposite) String() string

+ type FilterConditionContains struct

+ FieldPath AlertingPolicy_FieldPath

+ Type gotenresource.ConditionContainsType

+ Value AlertingPolicy_FieldPathArrayItemValue

+ Values []AlertingPolicy_FieldPathArrayItemValue

+ func (cond *FilterConditionContains) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionContains) ConditionContains()

+ func (cond *FilterConditionContains) ConditionContainsType() gotenresource.ConditionContainsType

+ func (cond *FilterConditionContains) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionContains) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionContains) GetFieldPath() AlertingPolicy_FieldPath

+ func (cond *FilterConditionContains) GetRawFieldPath() gotenobject.FieldPath

+ func (cond *FilterConditionContains) GetRawFieldPathItemValue() gotenobject.FieldPathArrayItemValue

+ func (cond *FilterConditionContains) GetRawFieldPathItemValues() (res []gotenobject.FieldPathArrayItemValue)

+ func (cond *FilterConditionContains) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionContains) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionContains) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionContains) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionContains) String() string

+ type FilterConditionIn struct

+ func (cond *FilterConditionIn) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionIn) ConditionIn()

+ func (cond *FilterConditionIn) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionIn) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionIn) GetRawFieldPath() gotenobject.FieldPath

+ func (cond *FilterConditionIn) GetRawFieldPathArrayOfValues() gotenobject.FieldPathArrayOfValues

+ func (cond *FilterConditionIn) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionIn) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionIn) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionIn) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionIn) String() string

+ type FilterConditionIsNaN struct

+ FieldPath AlertingPolicy_FieldPath

+ Not bool

+ func (cond *FilterConditionIsNaN) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionIsNaN) ConditionIsNaN()

+ func (cond *FilterConditionIsNaN) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionIsNaN) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionIsNaN) GetRawFieldPath() gotenobject.FieldPath

+ func (cond *FilterConditionIsNaN) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionIsNaN) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionIsNaN) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionIsNaN) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionIsNaN) String() string

+ type FilterConditionIsNull struct

+ FieldPath AlertingPolicy_FieldPath

+ Not bool

+ func (cond *FilterConditionIsNull) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionIsNull) ConditionIsNull()

+ func (cond *FilterConditionIsNull) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionIsNull) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionIsNull) GetRawFieldPath() gotenobject.FieldPath

+ func (cond *FilterConditionIsNull) NotNull() bool

+ func (cond *FilterConditionIsNull) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionIsNull) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionIsNull) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionIsNull) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionIsNull) String() string

+ type FilterConditionNot struct

+ func (cond *FilterConditionNot) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionNot) ConditionNot()

+ func (cond *FilterConditionNot) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionNot) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionNot) GetSubCondition() gotenresource.FilterCondition

+ func (cond *FilterConditionNot) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionNot) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionNot) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionNot) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionNot) String() string

+ type FilterConditionNotIn struct

+ func (cond *FilterConditionNotIn) And(conds ...FilterCondition) FilterCondition

+ func (cond *FilterConditionNotIn) ConditionNotIn()

+ func (cond *FilterConditionNotIn) Evaluate(res *AlertingPolicy) bool

+ func (cond *FilterConditionNotIn) EvaluateRaw(res gotenresource.Resource) bool

+ func (cond *FilterConditionNotIn) GetRawFieldPath() gotenobject.FieldPath

+ func (cond *FilterConditionNotIn) GetRawFieldPathArrayOfValues() gotenobject.FieldPathArrayOfValues

+ func (cond *FilterConditionNotIn) Satisfies(other FilterCondition) bool

+ func (cond *FilterConditionNotIn) SatisfiesRaw(other gotenresource.FilterCondition) bool

+ func (cond *FilterConditionNotIn) SpecifiesFieldPath(fp AlertingPolicy_FieldPath) bool

+ func (cond *FilterConditionNotIn) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

+ func (cond *FilterConditionNotIn) String() string

+ type GetQuery struct

+ Mask *AlertingPolicy_FieldMask

+ Reference *Reference

+ func (q *GetQuery) GetFieldMask() gotenobject.FieldMask

+ func (q *GetQuery) GetReference() gotenresource.Reference

+ func (q *GetQuery) GetResourceDescriptor() gotenresource.Descriptor

+ func (q *GetQuery) GotenQuery()

+ func (q *GetQuery) SetFieldMask(mask gotenobject.FieldMask)

+ func (q *GetQuery) SetReference(ref gotenresource.Reference)

+ func (q *GetQuery) String() string

+ type ListQuery struct

+ Filter *Filter

+ Mask *AlertingPolicy_FieldMask

+ Pager *PagerQuery

+ func (q *ListQuery) GetFieldMask() gotenobject.FieldMask

+ func (q *ListQuery) GetFilter() gotenresource.Filter

+ func (q *ListQuery) GetPager() gotenresource.PagerQuery

+ func (q *ListQuery) GetResourceDescriptor() gotenresource.Descriptor

+ func (q *ListQuery) GotenQuery()

+ func (q *ListQuery) SetFieldMask(mask gotenobject.FieldMask)

+ func (q *ListQuery) SetFilter(filter gotenresource.Filter)

+ func (q *ListQuery) SetPager(pager gotenresource.PagerQuery)

+ func (q *ListQuery) String() string

+ type Name struct

+ AlertingPolicyId string

+ func MustParseName(name string) *Name

+ func ParseName(name string) (*Name, error)

+ func ParseNameOrId(nameOrId string) (*Name, error)

+ func (name *Name) AsRawReference() gotenresource.Reference

+ func (name *Name) AsReference() *Reference

+ func (name *Name) ConvertToNative(typeDesc reflect.Type) (interface{}, error)

+ func (name *Name) ConvertToType(typeVal ref.Type) ref.Val

+ func (name *Name) Equal(other ref.Val) ref.Val

+ func (name *Name) FullyQualifiedName() (string, error)

+ func (name *Name) GetIdParts() map[string]string

+ func (name *Name) GetPattern() gotenresource.NamePattern

+ func (name *Name) GetProjectName() *project.Name

+ func (name *Name) GetResourceDescriptor() gotenresource.Descriptor

+ func (name *Name) GetSegments() gotenresource.NameSegments

+ func (name *Name) GotenEqual(other interface{}) bool

+ func (name *Name) HasTrait(trait int) bool

+ func (name *Name) IsFullyQualified() bool

+ func (name *Name) IsSpecified() bool

+ func (name *Name) Match(pattern ref.Val) ref.Val

+ func (name *Name) Matches(other interface{}) bool

+ func (name *Name) ParseProtoString(data string) error

+ func (name *Name) ProtoString() (string, error)

+ func (name *Name) Receive(function string, overload string, args []ref.Val) ref.Val

+ func (name *Name) SetFromCliFlag(raw string) error

+ func (name *Name) SetFromSegments(segments gotenresource.NameSegments) error

+ func (name *Name) String() string

+ func (name *Name) Type() ref.Type

+ func (name *Name) TypeName() string

+ func (name *Name) Value() interface{}

+ type NameBuilder struct

+ func NewNameBuilder() *NameBuilder

+ func (b *NameBuilder) Name() *Name

+ func (b *NameBuilder) Parent() *ParentName

+ func (b *NameBuilder) ParentReference() *ParentReference

+ func (b *NameBuilder) Reference() *Reference

+ func (b *NameBuilder) SetId(id string) *NameBuilder

+ func (b *NameBuilder) SetProject(parent *project.Name) *NameBuilder

+ func (b *NameBuilder) SetProjectId(id string) *NameBuilder

+ func (b *NameBuilder) SetRegionId(id string) *NameBuilder

+ type NamePattern struct

+ Pattern gotenresource.NamePattern

+ type OrderBy struct

+ OrderByFields []OrderByField

+ func (orderBy *OrderBy) Compare(left, right *AlertingPolicy) int

+ func (orderBy *OrderBy) CompareRaw(left, right gotenresource.Resource) int

+ func (orderBy *OrderBy) GetFieldMask() *AlertingPolicy_FieldMask

+ func (orderBy *OrderBy) GetOrderByFields() []gotenresource.OrderByField

+ func (orderBy *OrderBy) GetRawFieldMask() gotenobject.FieldMask

+ func (orderBy *OrderBy) InsertSorted(sorted AlertingPolicyList, elem *AlertingPolicy) (AlertingPolicyList, int)

+ func (orderBy *OrderBy) InsertSortedRaw(sorted gotenresource.ResourceList, elem gotenresource.Resource) (gotenresource.ResourceList, int)

+ func (orderBy *OrderBy) ParseProtoString(data string) error

+ func (orderBy *OrderBy) ProtoString() (string, error)

+ func (orderBy *OrderBy) SetFromCliFlag(raw string) error

+ func (orderBy *OrderBy) Sort(results AlertingPolicyList)

+ func (orderBy *OrderBy) SortRaw(results gotenresource.ResourceList)

+ func (orderBy *OrderBy) String() string

+ type OrderByField struct

+ Direction gotenresource.OrderDirection

+ FieldPath AlertingPolicy_FieldPath

+ func (orderByFld *OrderByField) CompareWithDirection(left, right *AlertingPolicy) int

+ func (orderByFld *OrderByField) GetDirection() gotenresource.OrderDirection

+ func (orderByFld *OrderByField) GetFieldPath() gotenobject.FieldPath

+ type PagerCursor struct

+ CursorValue gotenresource.CursorValue

+ Inclusion gotenresource.CursorInclusion

+ PageDirection gotenresource.PageDirection

+ func (cursor *PagerCursor) GetInclusion() gotenresource.CursorInclusion

+ func (cursor *PagerCursor) GetPageDirection() gotenresource.PageDirection

+ func (cursor *PagerCursor) GetValue() gotenresource.CursorValue

+ func (cursor *PagerCursor) IsEmpty() bool

+ func (cursor *PagerCursor) ParseProtoString(data string) (err error)

+ func (cursor *PagerCursor) ProtoString() (string, error)

+ func (cursor *PagerCursor) SetCursorValue(value gotenresource.CursorValue)

+ func (cursor *PagerCursor) SetFromCliFlag(raw string) error

+ func (cursor *PagerCursor) SetInclusion(inclusion gotenresource.CursorInclusion)

+ func (cursor *PagerCursor) SetPageDirection(direction gotenresource.PageDirection)

+ func (cursor *PagerCursor) String() string

+ type PagerQuery struct

+ Cursor *PagerCursor

+ Limit int

+ OrderBy *OrderBy

+ PeekForward bool

+ func MakePagerQuery(orderBy *OrderBy, cursor *PagerCursor, pageSize int32, peekForward bool) *PagerQuery

+ func (p *PagerQuery) GetCursor() gotenresource.Cursor

+ func (p *PagerQuery) GetLimit() int

+ func (p *PagerQuery) GetOrderBy() gotenresource.OrderBy

+ func (p *PagerQuery) GetPeekForward() bool

+ func (p *PagerQuery) GetResourceDescriptor() gotenresource.Descriptor

+ func (p *PagerQuery) PageDirection() gotenresource.PageDirection

+ type ParentName struct

+ ProjectId string

+ RegionId string

+ func MustParseParentName(name string) *ParentName

+ func ParseParentName(name string) (*ParentName, error)

+ func (name *ParentName) AsRawReference() gotenresource.Reference

+ func (name *ParentName) AsReference() *ParentReference

+ func (name *ParentName) DescendsFrom(ancestor string) bool

+ func (name *ParentName) FullyQualifiedName() (string, error)

+ func (name *ParentName) GetIdParts() map[string]string

+ func (name *ParentName) GetPattern() gotenresource.NamePattern

+ func (name *ParentName) GetProjectName() *project.Name

+ func (name *ParentName) GetResourceDescriptor() gotenresource.Descriptor

+ func (name *ParentName) GetSegments() gotenresource.NameSegments

+ func (name *ParentName) GotenEqual(other interface{}) bool

+ func (name *ParentName) IsFullyQualified() bool

+ func (name *ParentName) IsSpecified() bool

+ func (name *ParentName) Matches(other interface{}) bool

+ func (name *ParentName) ParseProtoString(data string) error

+ func (name *ParentName) ProtoString() (string, error)

+ func (name *ParentName) SetFromCliFlag(raw string) error

+ func (name *ParentName) SetFromSegments(segments gotenresource.NameSegments) error

+ func (name *ParentName) String() string

+ type ParentReference struct

+ func MakeParentReference(name *ParentName) (*ParentReference, error)

+ func MustParseParentReference(name string) *ParentReference

+ func ParseParentReference(name string) (*ParentReference, error)

+ func (name *ParentReference) Matches(other interface{}) bool

+ func (ref *ParentReference) ClearCached()

+ func (ref *ParentReference) GetIdParts() map[string]string

+ func (ref *ParentReference) GetPattern() gotenresource.NamePattern

+ func (ref *ParentReference) GetProject() *project.Project

+ func (ref *ParentReference) GetProjectReference() *project.Reference

+ func (ref *ParentReference) GetRawResource() gotenresource.Resource

+ func (ref *ParentReference) GetResourceDescriptor() gotenresource.Descriptor

+ func (ref *ParentReference) GetSegments() gotenresource.NameSegments

+ func (ref *ParentReference) GetUnderlyingReference() gotenresource.Reference

+ func (ref *ParentReference) GotenEqual(other interface{}) bool

+ func (ref *ParentReference) IsFullyQualified() bool

+ func (ref *ParentReference) IsSpecified() bool

+ func (ref *ParentReference) ParseProtoString(data string) error

+ func (ref *ParentReference) ProtoString() (string, error)

+ func (ref *ParentReference) ResolveRaw(res gotenresource.Resource) error

+ func (ref *ParentReference) Resolved() bool

+ func (ref *ParentReference) SetFromCliFlag(raw string) error

+ func (ref *ParentReference) String() string

+ type QueryResultChange struct

+ Changes []*AlertingPolicyChange

+ IsCurrent bool

+ IsHardReset bool

+ IsSoftReset bool

+ NextPageCursor *PagerCursor

+ PrevPageCursor *PagerCursor

+ ResumeToken string

+ SnapshotSize int64

+ func (qr *QueryResultChange) GetIsCurrent() bool

+ func (qr *QueryResultChange) GetIsHardReset() bool

+ func (qr *QueryResultChange) GetIsSoftReset() bool

+ func (qr *QueryResultChange) GetNextPageCursor() gotenresource.Cursor

+ func (qr *QueryResultChange) GetPrevPageCursor() gotenresource.Cursor

+ func (qr *QueryResultChange) GetResults() gotenresource.ResourceChangeList

+ func (qr *QueryResultChange) GetResumeToken() string

+ func (qr *QueryResultChange) GetSnapshotSize() int64

+ func (qr *QueryResultChange) SetCursors(nextPageCursor, prevPageCursor gotenresource.Cursor)

+ func (qr *QueryResultChange) SetIsCurrent()

+ func (qr *QueryResultChange) SetIsHardReset()

+ func (qr *QueryResultChange) SetIsSoftReset()

+ func (qr *QueryResultChange) SetResults(results gotenresource.ResourceChangeList)

+ func (qr *QueryResultChange) SetResumeToken(token string)

+ func (qr *QueryResultChange) SetSnapshotSize(size int64)

+ type QueryResultSnapshot struct

+ AlertingPolicies []*AlertingPolicy

+ NextPageCursor *PagerCursor

+ PrevPageCursor *PagerCursor

+ func (qr *QueryResultSnapshot) GetNextPageCursor() gotenresource.Cursor

+ func (qr *QueryResultSnapshot) GetPrevPageCursor() gotenresource.Cursor

+ func (qr *QueryResultSnapshot) GetResults() gotenresource.ResourceList

+ func (qr *QueryResultSnapshot) SetCursors(nextPageCursor, prevPageCursor gotenresource.Cursor)

+ func (qr *QueryResultSnapshot) SetResults(results gotenresource.ResourceList)

+ type Reference struct

+ func MakeReference(name *Name, alertingPolicy *AlertingPolicy) (*Reference, error)

+ func MustParseReference(name string) *Reference

+ func ParseReference(name string) (*Reference, error)

+ func (name *Reference) Matches(other interface{}) bool

+ func (ref *Reference) ClearCached()

+ func (ref *Reference) FullyQualifiedName() (string, error)

+ func (ref *Reference) GetAlertingPolicy() *AlertingPolicy

+ func (ref *Reference) GetIdParts() map[string]string

+ func (ref *Reference) GetPattern() gotenresource.NamePattern

+ func (ref *Reference) GetRawResource() gotenresource.Resource

+ func (ref *Reference) GetResourceDescriptor() gotenresource.Descriptor

+ func (ref *Reference) GetSegments() gotenresource.NameSegments

+ func (ref *Reference) GotenEqual(other interface{}) bool

+ func (ref *Reference) IsFullyQualified() bool

+ func (ref *Reference) IsSpecified() bool

+ func (ref *Reference) ParseProtoString(data string) error

+ func (ref *Reference) ProtoString() (string, error)

+ func (ref *Reference) Resolve(resolved *AlertingPolicy)

+ func (ref *Reference) ResolveRaw(res gotenresource.Resource) error

+ func (ref *Reference) Resolved() bool

+ func (ref *Reference) SetFromCliFlag(raw string) error

+ func (ref *Reference) String() string

+ type WatchQuery struct

+ ChunkSize int

+ ResumeToken string

+ WatchType watch_type.WatchType

+ func (q *WatchQuery) GetMaximumChunkSize() int

+ func (q *WatchQuery) GetResumeToken() string

+ func (q *WatchQuery) GetWatchType() watch_type.WatchType

+ func (q *WatchQuery) SetMaximumChunkSize(chunkSize int)

+ func (q *WatchQuery) SetResumeToken(token string)

+ func (q *WatchQuery) SetWatchType(watchType watch_type.WatchType)