activity_log

package
v1.5.12 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 8, 2024 License: Apache-2.0 Imports: 44 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	NamePattern_Project      = "projects/{project}/activityLogs/{activity_log}"
	NamePattern_Organization = "organizations/{organization}/activityLogs/{activity_log}"
	NamePattern_Service      = "services/{service}/activityLogs/{activity_log}"
)

Variables

View Source 
var (
	ActivityLog_Category_name = map[int32]string{
		0:  "Undefined",
		2:  "Operation",
		1:  "Creation",
		11: "Deletion",
		3:  "SpecUpdate",
		4:  "StateUpdate",
		6:  "MetaUpdate",
		5:  "Internal",
		7:  "Rejected",
		8:  "ClientError",
		9:  "ServerError",
		10: "Read",
	}

	ActivityLog_Category_value = map[string]int32{
		"Undefined":   0,
		"Operation":   2,
		"Creation":    1,
		"Deletion":    11,
		"SpecUpdate":  3,
		"StateUpdate": 4,
		"MetaUpdate":  6,
		"Internal":    5,
		"Rejected":    7,
		"ClientError": 8,
		"ServerError": 9,
		"Read":        10,
	}
)

Functions

This section is empty.

Types

type ActivityLog 

type ActivityLog struct {

	// Name of ActivityLog. It contains scope + ID of the log.
	// ID is a base64 encoded unique key that identifies tuple:
	//   scope
	//   request_id
	//   authentication.principal
	//   request_metadata.ip_address
	//   request_metadata.user_agent
	//   request_routing.via_region
	//   request_routing.dest_regions
	//   authorization.granted_permissions
	//   authorization.denied_permissions
	//   service.name
	//   service.region_id
	//   method.type
	//   method.version
	//   resource.name
	//   resource.difference.fields
	//   category
	//   labels
	//
	// Key is not to be decoded outside of service, but treated as opaque string
	Name *Name `protobuf:"bytes,1,opt,customtype=Name,name=name,proto3" json:"name,omitempty" firestore:"name"`
	// Contains scope from name field without resource ID.
	// Used for internal purpose for filtering (logs are using custom store).
	// Example formats are:
	// - organization/umbrella
	// - projects/mars_exploration
	// - services/devices.edgelq.com
	Scope string `protobuf:"bytes,2,opt,name=scope,proto3" json:"scope,omitempty" firestore:"scope"`
	// Generated ID of the request. Same ID must be used in ResourceChangeLog
	// objects associated with this request.
	RequestId uint64 `protobuf:"varint,3,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty" firestore:"requestId"`
	// Authentication data - informs who made a request
	Authentication *common.Authentication `protobuf:"bytes,5,opt,name=authentication,proto3" json:"authentication,omitempty" firestore:"authentication"`
	// Authorization data - informs what permissions were
	// granted or denied for associated request
	Authorization *common.Authorization `protobuf:"bytes,6,opt,name=authorization,proto3" json:"authorization,omitempty" firestore:"authorization"`
	// Information about the service
	Service *common.ServiceData `protobuf:"bytes,7,opt,name=service,proto3" json:"service,omitempty" firestore:"service"`
	// Information about the method
	Method *ActivityLog_Method `protobuf:"bytes,8,opt,name=method,proto3" json:"method,omitempty" firestore:"method"`
	// Request metadata
	RequestMetadata *ActivityLog_RequestMetadata `` /* 135-byte string literal not displayed */
	// Request routing
	RequestRouting *ActivityLog_RequestRouting `` /* 131-byte string literal not displayed */
	// Primary resource for this activity.
	Resource *ActivityLog_Resource `protobuf:"bytes,11,opt,name=resource,proto3" json:"resource,omitempty" firestore:"resource"`
	// Category of the activity log.
	Category ActivityLog_Category `` /* 131-byte string literal not displayed */
	// List of query-able labels
	Labels map[string]string `` /* 172-byte string literal not displayed */
	// List of events attached to this log
	Events []*ActivityLog_Event `protobuf:"bytes,10,rep,name=events,proto3" json:"events,omitempty" firestore:"events"`
	// contains filtered or unexported fields
}

ActivityLog Resource - describes notification of activity triggered by a request sent to an API service. ActivityLog creation is triggered by an API service when it receives either unary or stream request.

ActivityLog contains messages exchanged between client and server within single API call and finally exit status. ActivityLog is method oriented - service name + method name (for example IAM/CreateRoleBinding) is a leading information.

ActivityLog can have N associated ResourceChangeLog objects, if API call it describes made some changes in a data store. You can combine ActivityLog and ResourceChangeLog by making queries with request_id specified in a filter.

func (*ActivityLog) Clone 

func (o *ActivityLog) Clone() *ActivityLog

func (*ActivityLog) CloneRaw 

func (o *ActivityLog) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog) Descriptor 

func (*ActivityLog) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog.ProtoReflect.Descriptor instead.

func (*ActivityLog) EnsureMetadata 

func (r *ActivityLog) EnsureMetadata() *meta.Meta

func (*ActivityLog) GetAuthentication 

func (m *ActivityLog) GetAuthentication() *common.Authentication

func (*ActivityLog) GetAuthorization 

func (m *ActivityLog) GetAuthorization() *common.Authorization

func (*ActivityLog) GetCategory 

func (m *ActivityLog) GetCategory() ActivityLog_Category

func (*ActivityLog) GetEvents 

func (m *ActivityLog) GetEvents() []*ActivityLog_Event

func (*ActivityLog) GetLabels 

func (m *ActivityLog) GetLabels() map[string]string

func (*ActivityLog) GetMetadata 

func (r *ActivityLog) GetMetadata() *meta.Meta

func (*ActivityLog) GetMethod 

func (m *ActivityLog) GetMethod() *ActivityLog_Method

func (*ActivityLog) GetName 

func (m *ActivityLog) GetName() *Name

func (*ActivityLog) GetRawName 

func (r *ActivityLog) GetRawName() gotenresource.Name

func (*ActivityLog) GetRequestId 

func (m *ActivityLog) GetRequestId() uint64

func (*ActivityLog) GetRequestMetadata 

func (m *ActivityLog) GetRequestMetadata() *ActivityLog_RequestMetadata

func (*ActivityLog) GetRequestRouting 

func (m *ActivityLog) GetRequestRouting() *ActivityLog_RequestRouting

func (*ActivityLog) GetResource 

func (m *ActivityLog) GetResource() *ActivityLog_Resource

func (*ActivityLog) GetResourceDescriptor 

func (r *ActivityLog) GetResourceDescriptor() gotenresource.Descriptor

func (*ActivityLog) GetScope 

func (m *ActivityLog) GetScope() string

func (*ActivityLog) GetService 

func (m *ActivityLog) GetService() *common.ServiceData

func (*ActivityLog) GotenMessage 

func (*ActivityLog) GotenMessage()

func (*ActivityLog) GotenObjectExt 

func (o *ActivityLog) GotenObjectExt()

func (*ActivityLog) GotenValidate 

func (obj *ActivityLog) GotenValidate() error

func (*ActivityLog) MakeDiffFieldMask 

func (o *ActivityLog) MakeDiffFieldMask(other *ActivityLog) *ActivityLog_FieldMask

func (*ActivityLog) MakeFullFieldMask 

func (o *ActivityLog) MakeFullFieldMask() *ActivityLog_FieldMask

func (*ActivityLog) MakeRawDiffFieldMask 

func (o *ActivityLog) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog) MakeRawFullFieldMask 

func (o *ActivityLog) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog) Marshal 

func (m *ActivityLog) Marshal() ([]byte, error)

func (*ActivityLog) MarshalJSON 

func (m *ActivityLog) MarshalJSON() ([]byte, error)

func (*ActivityLog) MaybePopulateDefaults 

func (r *ActivityLog) MaybePopulateDefaults() error

func (*ActivityLog) Merge 

func (o *ActivityLog) Merge(source *ActivityLog)

func (*ActivityLog) MergeRaw 

func (o *ActivityLog) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog) ProtoMessage 

func (*ActivityLog) ProtoMessage()

func (*ActivityLog) ProtoReflect 

func (m *ActivityLog) ProtoReflect() preflect.Message

func (*ActivityLog) Reset 

func (m *ActivityLog) Reset()

func (*ActivityLog) SetAuthentication 

func (m *ActivityLog) SetAuthentication(fv *common.Authentication)

func (*ActivityLog) SetAuthorization 

func (m *ActivityLog) SetAuthorization(fv *common.Authorization)

func (*ActivityLog) SetCategory 

func (m *ActivityLog) SetCategory(fv ActivityLog_Category)

func (*ActivityLog) SetEvents 

func (m *ActivityLog) SetEvents(fv []*ActivityLog_Event)

func (*ActivityLog) SetLabels 

func (m *ActivityLog) SetLabels(fv map[string]string)

func (*ActivityLog) SetMethod 

func (m *ActivityLog) SetMethod(fv *ActivityLog_Method)

func (*ActivityLog) SetName 

func (m *ActivityLog) SetName(fv *Name)

func (*ActivityLog) SetRequestId 

func (m *ActivityLog) SetRequestId(fv uint64)

func (*ActivityLog) SetRequestMetadata 

func (m *ActivityLog) SetRequestMetadata(fv *ActivityLog_RequestMetadata)

func (*ActivityLog) SetRequestRouting 

func (m *ActivityLog) SetRequestRouting(fv *ActivityLog_RequestRouting)

func (*ActivityLog) SetResource 

func (m *ActivityLog) SetResource(fv *ActivityLog_Resource)

func (*ActivityLog) SetScope 

func (m *ActivityLog) SetScope(fv string)

func (*ActivityLog) SetService 

func (m *ActivityLog) SetService(fv *common.ServiceData)

func (*ActivityLog) String 

func (m *ActivityLog) String() string

func (*ActivityLog) Unmarshal 

func (m *ActivityLog) Unmarshal(b []byte) error

func (*ActivityLog) UnmarshalJSON 

func (m *ActivityLog) UnmarshalJSON(data []byte) error

type ActivityLogEventClientMsgEventFieldPathBuilder 

type ActivityLogEventClientMsgEventFieldPathBuilder struct{}

func NewActivityLogEventClientMsgEventFieldPathBuilder 

func NewActivityLogEventClientMsgEventFieldPathBuilder() ActivityLogEventClientMsgEventFieldPathBuilder

func (ActivityLogEventClientMsgEventFieldPathBuilder) Data 

func (ActivityLogEventClientMsgEventFieldPathBuilder) Data() ActivityLog_Event_ClientMsgEventPathSelectorData

func (ActivityLogEventClientMsgEventFieldPathBuilder) Time 

func (ActivityLogEventClientMsgEventFieldPathBuilder) Time() ActivityLog_Event_ClientMsgEventPathSelectorTime

type ActivityLogEventClientMsgEvent_FieldPath 

type ActivityLogEventClientMsgEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventClientMsgEvent_FieldPathSelector
	Get(source *ActivityLog_Event_ClientMsgEvent) []interface{}
	GetSingle(source *ActivityLog_Event_ClientMsgEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_ClientMsgEvent)

	// Those methods build corresponding ActivityLogEventClientMsgEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogEventClientMsgEvent_FieldPath 

func BuildActivityLogEventClientMsgEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventClientMsgEvent_FieldPath, error)

func MustParseActivityLogEventClientMsgEvent_FieldPath 

func MustParseActivityLogEventClientMsgEvent_FieldPath(rawField string) ActivityLogEventClientMsgEvent_FieldPath

func ParseActivityLogEventClientMsgEvent_FieldPath 

func ParseActivityLogEventClientMsgEvent_FieldPath(rawField string) (ActivityLogEventClientMsgEvent_FieldPath, error)

type ActivityLogEventClientMsgEvent_FieldPathArrayItemValue 

type ActivityLogEventClientMsgEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventClientMsgEvent_FieldPath
	ContainsValue(*ActivityLog_Event_ClientMsgEvent) bool
}

ActivityLogEventClientMsgEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for ClientMsgEvent according to their type Present only for array (repeated) types.

func MustParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue 

func MustParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventClientMsgEvent_FieldPathArrayItemValue

func ParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue 

func ParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventClientMsgEvent_FieldPathArrayItemValue, error)

ParseActivityLogEventClientMsgEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogEventClientMsgEvent_FieldPathArrayOfValues 

type ActivityLogEventClientMsgEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventClientMsgEvent_FieldPath
}

ActivityLogEventClientMsgEvent_FieldPathArrayOfValues allows storing slice of values for ClientMsgEvent fields according to their type

func MustParseActivityLogEventClientMsgEvent_FieldPathArrayOfValues 

func MustParseActivityLogEventClientMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventClientMsgEvent_FieldPathArrayOfValues

func ParseActivityLogEventClientMsgEvent_FieldPathArrayOfValues 

func ParseActivityLogEventClientMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventClientMsgEvent_FieldPathArrayOfValues, error)

type ActivityLogEventClientMsgEvent_FieldPathSelector 

type ActivityLogEventClientMsgEvent_FieldPathSelector int32
const (
	ActivityLogEventClientMsgEvent_FieldPathSelectorData ActivityLogEventClientMsgEvent_FieldPathSelector = 0
	ActivityLogEventClientMsgEvent_FieldPathSelectorTime ActivityLogEventClientMsgEvent_FieldPathSelector = 1
)

func (ActivityLogEventClientMsgEvent_FieldPathSelector) String 

func (s ActivityLogEventClientMsgEvent_FieldPathSelector) String() string

type ActivityLogEventClientMsgEvent_FieldPathValue 

type ActivityLogEventClientMsgEvent_FieldPathValue interface {
	ActivityLogEventClientMsgEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_ClientMsgEvent)
	CompareWith(*ActivityLog_Event_ClientMsgEvent) (cmp int, comparable bool)
}

ActivityLogEventClientMsgEvent_FieldPathValue allows storing values for ClientMsgEvent fields according to their type

func MustParseActivityLogEventClientMsgEvent_FieldPathValue 

func MustParseActivityLogEventClientMsgEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventClientMsgEvent_FieldPathValue

func ParseActivityLogEventClientMsgEvent_FieldPathValue 

func ParseActivityLogEventClientMsgEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventClientMsgEvent_FieldPathValue, error)

type ActivityLogEventClientMsgEvent_FieldTerminalPath 

type ActivityLogEventClientMsgEvent_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) ClearValue 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_ClientMsgEvent)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) Get 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) Get(source *ActivityLog_Event_ClientMsgEvent) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Event_ClientMsgEvent

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) GetDefault 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) GetRaw 

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

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) GetSingle 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_ClientMsgEvent) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Event_ClientMsgEvent

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) JSONString 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) Selector 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) Selector() ActivityLogEventClientMsgEvent_FieldPathSelector

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) String 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayItemValue

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventClientMsgEvent_FieldPathArrayOfValues

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIValue 

func (fp *ActivityLogEventClientMsgEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventClientMsgEvent_FieldPathValue

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogEventClientMsgEvent_FieldTerminalPath) WithRawIValue 

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

type ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue 

type ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventClientMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ClientMsgEvent) bool

Contains returns a boolean indicating if value that is being held is present in given 'ClientMsgEvent'

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Event_ClientMsgEvent as interface{}

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_ClientMsgEvent) (interface{}, bool)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues 

type ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventClientMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues 

func (fpaov *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues() ([]*anypb.Any, bool)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues 

func (fpaov *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogEventClientMsgEvent_FieldTerminalPathValue 

type ActivityLogEventClientMsgEvent_FieldTerminalPathValue struct {
	ActivityLogEventClientMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsDataValue 

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsDataValue() (*anypb.Any, bool)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsTimeValue 

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_ClientMsgEvent) (int, bool)

CompareWith compares value in the 'ActivityLogEventClientMsgEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_ClientMsgEvent'.

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'ClientMsgEvent' as interface{}

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_ClientMsgEvent)

SetTo stores value for selected field for object ClientMsgEvent

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogEventExitEventFieldPathBuilder 

type ActivityLogEventExitEventFieldPathBuilder struct{}

func NewActivityLogEventExitEventFieldPathBuilder 

func NewActivityLogEventExitEventFieldPathBuilder() ActivityLogEventExitEventFieldPathBuilder

func (ActivityLogEventExitEventFieldPathBuilder) Status 

func (ActivityLogEventExitEventFieldPathBuilder) Status() ActivityLog_Event_ExitEventPathSelectorStatus

func (ActivityLogEventExitEventFieldPathBuilder) Time 

func (ActivityLogEventExitEventFieldPathBuilder) Time() ActivityLog_Event_ExitEventPathSelectorTime

type ActivityLogEventExitEvent_FieldPath 

type ActivityLogEventExitEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventExitEvent_FieldPathSelector
	Get(source *ActivityLog_Event_ExitEvent) []interface{}
	GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_ExitEvent)

	// Those methods build corresponding ActivityLogEventExitEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventExitEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventExitEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventExitEvent_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogEventExitEvent_FieldPath 

func BuildActivityLogEventExitEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventExitEvent_FieldPath, error)

func MustParseActivityLogEventExitEvent_FieldPath 

func MustParseActivityLogEventExitEvent_FieldPath(rawField string) ActivityLogEventExitEvent_FieldPath

func ParseActivityLogEventExitEvent_FieldPath 

func ParseActivityLogEventExitEvent_FieldPath(rawField string) (ActivityLogEventExitEvent_FieldPath, error)

type ActivityLogEventExitEvent_FieldPathArrayItemValue 

type ActivityLogEventExitEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventExitEvent_FieldPath
	ContainsValue(*ActivityLog_Event_ExitEvent) bool
}

ActivityLogEventExitEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for ExitEvent according to their type Present only for array (repeated) types.

func MustParseActivityLogEventExitEvent_FieldPathArrayItemValue 

func MustParseActivityLogEventExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventExitEvent_FieldPathArrayItemValue

func ParseActivityLogEventExitEvent_FieldPathArrayItemValue 

func ParseActivityLogEventExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventExitEvent_FieldPathArrayItemValue, error)

ParseActivityLogEventExitEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogEventExitEvent_FieldPathArrayOfValues 

type ActivityLogEventExitEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventExitEvent_FieldPath
}

ActivityLogEventExitEvent_FieldPathArrayOfValues allows storing slice of values for ExitEvent fields according to their type

func MustParseActivityLogEventExitEvent_FieldPathArrayOfValues 

func MustParseActivityLogEventExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventExitEvent_FieldPathArrayOfValues

func ParseActivityLogEventExitEvent_FieldPathArrayOfValues 

func ParseActivityLogEventExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventExitEvent_FieldPathArrayOfValues, error)

type ActivityLogEventExitEvent_FieldPathSelector 

type ActivityLogEventExitEvent_FieldPathSelector int32
const (
	ActivityLogEventExitEvent_FieldPathSelectorStatus ActivityLogEventExitEvent_FieldPathSelector = 0
	ActivityLogEventExitEvent_FieldPathSelectorTime   ActivityLogEventExitEvent_FieldPathSelector = 1
)

func (ActivityLogEventExitEvent_FieldPathSelector) String 

func (s ActivityLogEventExitEvent_FieldPathSelector) String() string

type ActivityLogEventExitEvent_FieldPathValue 

type ActivityLogEventExitEvent_FieldPathValue interface {
	ActivityLogEventExitEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_ExitEvent)
	CompareWith(*ActivityLog_Event_ExitEvent) (cmp int, comparable bool)
}

ActivityLogEventExitEvent_FieldPathValue allows storing values for ExitEvent fields according to their type

func MustParseActivityLogEventExitEvent_FieldPathValue 

func MustParseActivityLogEventExitEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventExitEvent_FieldPathValue

func ParseActivityLogEventExitEvent_FieldPathValue 

func ParseActivityLogEventExitEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventExitEvent_FieldPathValue, error)

type ActivityLogEventExitEvent_FieldSubPath 

type ActivityLogEventExitEvent_FieldSubPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldSubPath) AsStatusSubPath 

func (fps *ActivityLogEventExitEvent_FieldSubPath) AsStatusSubPath() (rpc.Status_FieldPath, bool)

func (*ActivityLogEventExitEvent_FieldSubPath) ClearValue 

func (fps *ActivityLogEventExitEvent_FieldSubPath) ClearValue(item *ActivityLog_Event_ExitEvent)

func (*ActivityLogEventExitEvent_FieldSubPath) ClearValueRaw 

func (fps *ActivityLogEventExitEvent_FieldSubPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEventExitEvent_FieldSubPath) Get 

func (fps *ActivityLogEventExitEvent_FieldSubPath) Get(source *ActivityLog_Event_ExitEvent) (values []interface{})

Get returns all values pointed by selected field from source ActivityLog_Event_ExitEvent

func (*ActivityLogEventExitEvent_FieldSubPath) GetDefault 

func (fps *ActivityLogEventExitEvent_FieldSubPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEventExitEvent_FieldSubPath) GetRaw 

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

func (*ActivityLogEventExitEvent_FieldSubPath) GetSingle 

func (fps *ActivityLogEventExitEvent_FieldSubPath) GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool)

GetSingle returns value of selected field from source ActivityLog_Event_ExitEvent

func (*ActivityLogEventExitEvent_FieldSubPath) GetSingleRaw 

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

func (*ActivityLogEventExitEvent_FieldSubPath) IsLeaf 

func (fps *ActivityLogEventExitEvent_FieldSubPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEventExitEvent_FieldSubPath) JSONString 

func (fps *ActivityLogEventExitEvent_FieldSubPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEventExitEvent_FieldSubPath) Selector 

func (fps *ActivityLogEventExitEvent_FieldSubPath) Selector() ActivityLogEventExitEvent_FieldPathSelector

func (*ActivityLogEventExitEvent_FieldSubPath) SplitIntoTerminalIPaths 

func (fps *ActivityLogEventExitEvent_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEventExitEvent_FieldSubPath) String 

func (fps *ActivityLogEventExitEvent_FieldSubPath) String() string

String returns path representation in proto convention

func (*ActivityLogEventExitEvent_FieldSubPath) WithIArrayItemValue 

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogEventExitEvent_FieldPathArrayItemValue

func (*ActivityLogEventExitEvent_FieldSubPath) WithIArrayOfValues 

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogEventExitEvent_FieldPathArrayOfValues

func (*ActivityLogEventExitEvent_FieldSubPath) WithIValue 

func (fps *ActivityLogEventExitEvent_FieldSubPath) WithIValue(value interface{}) ActivityLogEventExitEvent_FieldPathValue

func (*ActivityLogEventExitEvent_FieldSubPath) WithRawIArrayItemValue 

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

func (*ActivityLogEventExitEvent_FieldSubPath) WithRawIArrayOfValues 

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

func (*ActivityLogEventExitEvent_FieldSubPath) WithRawIValue 

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

type ActivityLogEventExitEvent_FieldSubPathArrayItemValue 

type ActivityLogEventExitEvent_FieldSubPathArrayItemValue struct {
	ActivityLogEventExitEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldSubPathArrayItemValue) AsStatusPathItemValue 

func (fpaivs *ActivityLogEventExitEvent_FieldSubPathArrayItemValue) AsStatusPathItemValue() (rpc.Status_FieldPathArrayItemValue, bool)

func (*ActivityLogEventExitEvent_FieldSubPathArrayItemValue) ContainsValue 

func (fpaivs *ActivityLogEventExitEvent_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ExitEvent) bool

Contains returns a boolean indicating if value that is being held is present in given 'ExitEvent'

func (*ActivityLogEventExitEvent_FieldSubPathArrayItemValue) GetRawItemValue 

func (fpaivs *ActivityLogEventExitEvent_FieldSubPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored array item value

type ActivityLogEventExitEvent_FieldSubPathArrayOfValues 

type ActivityLogEventExitEvent_FieldSubPathArrayOfValues struct {
	ActivityLogEventExitEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues 

func (fpsaov *ActivityLogEventExitEvent_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues() (rpc.Status_FieldPathArrayOfValues, bool)

func (*ActivityLogEventExitEvent_FieldSubPathArrayOfValues) GetRawValues 

func (fpsaov *ActivityLogEventExitEvent_FieldSubPathArrayOfValues) GetRawValues() []interface{}

type ActivityLogEventExitEvent_FieldSubPathValue 

type ActivityLogEventExitEvent_FieldSubPathValue struct {
	ActivityLogEventExitEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldSubPathValue) AsStatusPathValue 

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) AsStatusPathValue() (rpc.Status_FieldPathValue, bool)

func (*ActivityLogEventExitEvent_FieldSubPathValue) CompareWith 

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) CompareWith(source *ActivityLog_Event_ExitEvent) (int, bool)

func (*ActivityLogEventExitEvent_FieldSubPathValue) CompareWithRaw 

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

func (*ActivityLogEventExitEvent_FieldSubPathValue) GetRawValue 

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) GetRawValue() interface{}

func (*ActivityLogEventExitEvent_FieldSubPathValue) SetTo 

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) SetTo(target **ActivityLog_Event_ExitEvent)

func (*ActivityLogEventExitEvent_FieldSubPathValue) SetToRaw 

func (fpvs *ActivityLogEventExitEvent_FieldSubPathValue) SetToRaw(target proto.Message)

type ActivityLogEventExitEvent_FieldTerminalPath 

type ActivityLogEventExitEvent_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldTerminalPath) ClearValue 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_ExitEvent)

func (*ActivityLogEventExitEvent_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEventExitEvent_FieldTerminalPath) Get 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) Get(source *ActivityLog_Event_ExitEvent) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Event_ExitEvent

func (*ActivityLogEventExitEvent_FieldTerminalPath) GetDefault 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEventExitEvent_FieldTerminalPath) GetRaw 

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

func (*ActivityLogEventExitEvent_FieldTerminalPath) GetSingle 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Event_ExitEvent

func (*ActivityLogEventExitEvent_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogEventExitEvent_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEventExitEvent_FieldTerminalPath) JSONString 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEventExitEvent_FieldTerminalPath) Selector 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) Selector() ActivityLogEventExitEvent_FieldPathSelector

func (*ActivityLogEventExitEvent_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEventExitEvent_FieldTerminalPath) String 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogEventExitEvent_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventExitEvent_FieldPathArrayItemValue

func (*ActivityLogEventExitEvent_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventExitEvent_FieldPathArrayOfValues

func (*ActivityLogEventExitEvent_FieldTerminalPath) WithIValue 

func (fp *ActivityLogEventExitEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventExitEvent_FieldPathValue

func (*ActivityLogEventExitEvent_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogEventExitEvent_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogEventExitEvent_FieldTerminalPath) WithRawIValue 

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

type ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue 

type ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventExitEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ExitEvent) bool

Contains returns a boolean indicating if value that is being held is present in given 'ExitEvent'

func (*ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Event_ExitEvent as interface{}

func (*ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_ExitEvent) (interface{}, bool)

func (*ActivityLogEventExitEvent_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues 

type ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventExitEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues 

func (fpaov *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*rpc.Status, bool)

func (*ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues 

func (fpaov *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool)

func (*ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogEventExitEvent_FieldTerminalPathValue 

type ActivityLogEventExitEvent_FieldTerminalPathValue struct {
	ActivityLogEventExitEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventExitEvent_FieldTerminalPathValue) AsStatusValue 

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) AsStatusValue() (*rpc.Status, bool)

func (*ActivityLogEventExitEvent_FieldTerminalPathValue) AsTimeValue 

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool)

func (*ActivityLogEventExitEvent_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_ExitEvent) (int, bool)

CompareWith compares value in the 'ActivityLogEventExitEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_ExitEvent'.

func (*ActivityLogEventExitEvent_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogEventExitEvent_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'ExitEvent' as interface{}

func (*ActivityLogEventExitEvent_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_ExitEvent)

SetTo stores value for selected field for object ExitEvent

func (*ActivityLogEventExitEvent_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogEventExitEvent_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogEventFieldPathBuilder 

type ActivityLogEventFieldPathBuilder struct{}

func NewActivityLogEventFieldPathBuilder 

func NewActivityLogEventFieldPathBuilder() ActivityLogEventFieldPathBuilder

func (ActivityLogEventFieldPathBuilder) ClientMessage 

func (ActivityLogEventFieldPathBuilder) ClientMessage() ActivityLog_EventPathSelectorClientMessage

func (ActivityLogEventFieldPathBuilder) Exit 

func (ActivityLogEventFieldPathBuilder) Exit() ActivityLog_EventPathSelectorExit

func (ActivityLogEventFieldPathBuilder) RegionalExit 

func (ActivityLogEventFieldPathBuilder) RegionalExit() ActivityLog_EventPathSelectorRegionalExit

func (ActivityLogEventFieldPathBuilder) RegionalServerMessage 

func (ActivityLogEventFieldPathBuilder) RegionalServerMessage() ActivityLog_EventPathSelectorRegionalServerMessage

func (ActivityLogEventFieldPathBuilder) ServerMessage 

func (ActivityLogEventFieldPathBuilder) ServerMessage() ActivityLog_EventPathSelectorServerMessage

type ActivityLogEventRegionalExitEventFieldPathBuilder 

type ActivityLogEventRegionalExitEventFieldPathBuilder struct{}

func NewActivityLogEventRegionalExitEventFieldPathBuilder 

func NewActivityLogEventRegionalExitEventFieldPathBuilder() ActivityLogEventRegionalExitEventFieldPathBuilder

func (ActivityLogEventRegionalExitEventFieldPathBuilder) RegionId 

func (ActivityLogEventRegionalExitEventFieldPathBuilder) RegionId() ActivityLog_Event_RegionalExitEventPathSelectorRegionId

func (ActivityLogEventRegionalExitEventFieldPathBuilder) Status 

func (ActivityLogEventRegionalExitEventFieldPathBuilder) Status() ActivityLog_Event_RegionalExitEventPathSelectorStatus

func (ActivityLogEventRegionalExitEventFieldPathBuilder) Time 

func (ActivityLogEventRegionalExitEventFieldPathBuilder) Time() ActivityLog_Event_RegionalExitEventPathSelectorTime

type ActivityLogEventRegionalExitEvent_FieldPath 

type ActivityLogEventRegionalExitEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventRegionalExitEvent_FieldPathSelector
	Get(source *ActivityLog_Event_RegionalExitEvent) []interface{}
	GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_RegionalExitEvent)

	// Those methods build corresponding ActivityLogEventRegionalExitEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogEventRegionalExitEvent_FieldPath 

func BuildActivityLogEventRegionalExitEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventRegionalExitEvent_FieldPath, error)

func MustParseActivityLogEventRegionalExitEvent_FieldPath 

func MustParseActivityLogEventRegionalExitEvent_FieldPath(rawField string) ActivityLogEventRegionalExitEvent_FieldPath

func ParseActivityLogEventRegionalExitEvent_FieldPath 

func ParseActivityLogEventRegionalExitEvent_FieldPath(rawField string) (ActivityLogEventRegionalExitEvent_FieldPath, error)

type ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue 

type ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventRegionalExitEvent_FieldPath
	ContainsValue(*ActivityLog_Event_RegionalExitEvent) bool
}

ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for RegionalExitEvent according to their type Present only for array (repeated) types.

func MustParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue 

func MustParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue

func ParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue 

func ParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue, error)

ParseActivityLogEventRegionalExitEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues 

type ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventRegionalExitEvent_FieldPath
}

ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues allows storing slice of values for RegionalExitEvent fields according to their type

func MustParseActivityLogEventRegionalExitEvent_FieldPathArrayOfValues 

func MustParseActivityLogEventRegionalExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues

func ParseActivityLogEventRegionalExitEvent_FieldPathArrayOfValues 

func ParseActivityLogEventRegionalExitEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues, error)

type ActivityLogEventRegionalExitEvent_FieldPathSelector 

type ActivityLogEventRegionalExitEvent_FieldPathSelector int32
const (
	ActivityLogEventRegionalExitEvent_FieldPathSelectorStatus   ActivityLogEventRegionalExitEvent_FieldPathSelector = 0
	ActivityLogEventRegionalExitEvent_FieldPathSelectorTime     ActivityLogEventRegionalExitEvent_FieldPathSelector = 1
	ActivityLogEventRegionalExitEvent_FieldPathSelectorRegionId ActivityLogEventRegionalExitEvent_FieldPathSelector = 2
)

func (ActivityLogEventRegionalExitEvent_FieldPathSelector) String 

func (s ActivityLogEventRegionalExitEvent_FieldPathSelector) String() string

type ActivityLogEventRegionalExitEvent_FieldPathValue 

type ActivityLogEventRegionalExitEvent_FieldPathValue interface {
	ActivityLogEventRegionalExitEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_RegionalExitEvent)
	CompareWith(*ActivityLog_Event_RegionalExitEvent) (cmp int, comparable bool)
}

ActivityLogEventRegionalExitEvent_FieldPathValue allows storing values for RegionalExitEvent fields according to their type

func MustParseActivityLogEventRegionalExitEvent_FieldPathValue 

func MustParseActivityLogEventRegionalExitEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventRegionalExitEvent_FieldPathValue

func ParseActivityLogEventRegionalExitEvent_FieldPathValue 

func ParseActivityLogEventRegionalExitEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventRegionalExitEvent_FieldPathValue, error)

type ActivityLogEventRegionalExitEvent_FieldSubPath 

type ActivityLogEventRegionalExitEvent_FieldSubPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) AsStatusSubPath 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) AsStatusSubPath() (rpc.Status_FieldPath, bool)

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) ClearValue 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) ClearValue(item *ActivityLog_Event_RegionalExitEvent)

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) ClearValueRaw 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) Get 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) Get(source *ActivityLog_Event_RegionalExitEvent) (values []interface{})

Get returns all values pointed by selected field from source ActivityLog_Event_RegionalExitEvent

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) GetDefault 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) GetRaw 

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

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) GetSingle 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool)

GetSingle returns value of selected field from source ActivityLog_Event_RegionalExitEvent

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) GetSingleRaw 

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

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) IsLeaf 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) JSONString 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) Selector 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) Selector() ActivityLogEventRegionalExitEvent_FieldPathSelector

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) SplitIntoTerminalIPaths 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) String 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) String() string

String returns path representation in proto convention

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) WithIArrayItemValue 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) WithIArrayOfValues 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) WithIValue 

func (fps *ActivityLogEventRegionalExitEvent_FieldSubPath) WithIValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathValue

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) WithRawIArrayItemValue 

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

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) WithRawIArrayOfValues 

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

func (*ActivityLogEventRegionalExitEvent_FieldSubPath) WithRawIValue 

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

type ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue 

type ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue struct {
	ActivityLogEventRegionalExitEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) AsStatusPathItemValue 

func (fpaivs *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) AsStatusPathItemValue() (rpc.Status_FieldPathArrayItemValue, bool)

func (*ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) ContainsValue 

func (fpaivs *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Event_RegionalExitEvent) bool

Contains returns a boolean indicating if value that is being held is present in given 'RegionalExitEvent'

func (*ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) GetRawItemValue 

func (fpaivs *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored array item value

type ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues 

type ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues struct {
	ActivityLogEventRegionalExitEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues 

func (fpsaov *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues) AsStatusPathArrayOfValues() (rpc.Status_FieldPathArrayOfValues, bool)

func (*ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues) GetRawValues 

func (fpsaov *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues) GetRawValues() []interface{}

type ActivityLogEventRegionalExitEvent_FieldSubPathValue 

type ActivityLogEventRegionalExitEvent_FieldSubPathValue struct {
	ActivityLogEventRegionalExitEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldSubPathValue) AsStatusPathValue 

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) AsStatusPathValue() (rpc.Status_FieldPathValue, bool)

func (*ActivityLogEventRegionalExitEvent_FieldSubPathValue) CompareWith 

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) CompareWith(source *ActivityLog_Event_RegionalExitEvent) (int, bool)

func (*ActivityLogEventRegionalExitEvent_FieldSubPathValue) CompareWithRaw 

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

func (*ActivityLogEventRegionalExitEvent_FieldSubPathValue) GetRawValue 

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) GetRawValue() interface{}

func (*ActivityLogEventRegionalExitEvent_FieldSubPathValue) SetTo 

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) SetTo(target **ActivityLog_Event_RegionalExitEvent)

func (*ActivityLogEventRegionalExitEvent_FieldSubPathValue) SetToRaw 

func (fpvs *ActivityLogEventRegionalExitEvent_FieldSubPathValue) SetToRaw(target proto.Message)

type ActivityLogEventRegionalExitEvent_FieldTerminalPath 

type ActivityLogEventRegionalExitEvent_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) ClearValue 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_RegionalExitEvent)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) Get 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) Get(source *ActivityLog_Event_RegionalExitEvent) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Event_RegionalExitEvent

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetDefault 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetRaw 

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

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetSingle 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Event_RegionalExitEvent

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) JSONString 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) Selector 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) Selector() ActivityLogEventRegionalExitEvent_FieldPathSelector

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) String 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayItemValue

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventRegionalExitEvent_FieldPathArrayOfValues

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIValue 

func (fp *ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventRegionalExitEvent_FieldPathValue

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPath) WithRawIValue 

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

type ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue 

type ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventRegionalExitEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_RegionalExitEvent) bool

Contains returns a boolean indicating if value that is being held is present in given 'RegionalExitEvent'

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Event_RegionalExitEvent as interface{}

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_RegionalExitEvent) (interface{}, bool)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues 

type ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventRegionalExitEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsRegionIdArrayOfValues 

func (fpaov *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsRegionIdArrayOfValues() ([]string, bool)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues 

func (fpaov *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsStatusArrayOfValues() ([]*rpc.Status, bool)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues 

func (fpaov *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogEventRegionalExitEvent_FieldTerminalPathValue 

type ActivityLogEventRegionalExitEvent_FieldTerminalPathValue struct {
	ActivityLogEventRegionalExitEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsRegionIdValue 

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsRegionIdValue() (string, bool)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsStatusValue 

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsStatusValue() (*rpc.Status, bool)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsTimeValue 

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool)

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_RegionalExitEvent) (int, bool)

CompareWith compares value in the 'ActivityLogEventRegionalExitEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_RegionalExitEvent'.

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'RegionalExitEvent' as interface{}

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_RegionalExitEvent)

SetTo stores value for selected field for object RegionalExitEvent

func (*ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogEventRegionalServerMsgEventFieldPathBuilder 

type ActivityLogEventRegionalServerMsgEventFieldPathBuilder struct{}

func NewActivityLogEventRegionalServerMsgEventFieldPathBuilder 

func NewActivityLogEventRegionalServerMsgEventFieldPathBuilder() ActivityLogEventRegionalServerMsgEventFieldPathBuilder

func (ActivityLogEventRegionalServerMsgEventFieldPathBuilder) Data 

func (ActivityLogEventRegionalServerMsgEventFieldPathBuilder) Data() ActivityLog_Event_RegionalServerMsgEventPathSelectorData

func (ActivityLogEventRegionalServerMsgEventFieldPathBuilder) RegionId 

func (ActivityLogEventRegionalServerMsgEventFieldPathBuilder) RegionId() ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId

func (ActivityLogEventRegionalServerMsgEventFieldPathBuilder) Time 

func (ActivityLogEventRegionalServerMsgEventFieldPathBuilder) Time() ActivityLog_Event_RegionalServerMsgEventPathSelectorTime

type ActivityLogEventRegionalServerMsgEvent_FieldPath 

type ActivityLogEventRegionalServerMsgEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventRegionalServerMsgEvent_FieldPathSelector
	Get(source *ActivityLog_Event_RegionalServerMsgEvent) []interface{}
	GetSingle(source *ActivityLog_Event_RegionalServerMsgEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_RegionalServerMsgEvent)

	// Those methods build corresponding ActivityLogEventRegionalServerMsgEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogEventRegionalServerMsgEvent_FieldPath 

func BuildActivityLogEventRegionalServerMsgEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventRegionalServerMsgEvent_FieldPath, error)

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPath 

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPath(rawField string) ActivityLogEventRegionalServerMsgEvent_FieldPath

func ParseActivityLogEventRegionalServerMsgEvent_FieldPath 

func ParseActivityLogEventRegionalServerMsgEvent_FieldPath(rawField string) (ActivityLogEventRegionalServerMsgEvent_FieldPath, error)

type ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue 

type ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventRegionalServerMsgEvent_FieldPath
	ContainsValue(*ActivityLog_Event_RegionalServerMsgEvent) bool
}

ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for RegionalServerMsgEvent according to their type Present only for array (repeated) types.

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue 

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue 

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue, error)

ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues 

type ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventRegionalServerMsgEvent_FieldPath
}

ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues allows storing slice of values for RegionalServerMsgEvent fields according to their type

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues 

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues 

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues, error)

type ActivityLogEventRegionalServerMsgEvent_FieldPathSelector 

type ActivityLogEventRegionalServerMsgEvent_FieldPathSelector int32
const (
	ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorData     ActivityLogEventRegionalServerMsgEvent_FieldPathSelector = 0
	ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorTime     ActivityLogEventRegionalServerMsgEvent_FieldPathSelector = 1
	ActivityLogEventRegionalServerMsgEvent_FieldPathSelectorRegionId ActivityLogEventRegionalServerMsgEvent_FieldPathSelector = 2
)

func (ActivityLogEventRegionalServerMsgEvent_FieldPathSelector) String 

func (s ActivityLogEventRegionalServerMsgEvent_FieldPathSelector) String() string

type ActivityLogEventRegionalServerMsgEvent_FieldPathValue 

type ActivityLogEventRegionalServerMsgEvent_FieldPathValue interface {
	ActivityLogEventRegionalServerMsgEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_RegionalServerMsgEvent)
	CompareWith(*ActivityLog_Event_RegionalServerMsgEvent) (cmp int, comparable bool)
}

ActivityLogEventRegionalServerMsgEvent_FieldPathValue allows storing values for RegionalServerMsgEvent fields according to their type

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathValue 

func MustParseActivityLogEventRegionalServerMsgEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventRegionalServerMsgEvent_FieldPathValue

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathValue 

func ParseActivityLogEventRegionalServerMsgEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventRegionalServerMsgEvent_FieldPathValue, error)

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath 

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) ClearValue 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_RegionalServerMsgEvent)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) Get 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) Get(source *ActivityLog_Event_RegionalServerMsgEvent) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Event_RegionalServerMsgEvent

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetDefault 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetRaw 

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

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetSingle 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_RegionalServerMsgEvent) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Event_RegionalServerMsgEvent

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) JSONString 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) Selector 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) Selector() ActivityLogEventRegionalServerMsgEvent_FieldPathSelector

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) String 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIValue 

func (fp *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventRegionalServerMsgEvent_FieldPathValue

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath) WithRawIValue 

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

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue 

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_RegionalServerMsgEvent) bool

Contains returns a boolean indicating if value that is being held is present in given 'RegionalServerMsgEvent'

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Event_RegionalServerMsgEvent as interface{}

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_RegionalServerMsgEvent) (interface{}, bool)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues 

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues 

func (fpaov *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues() ([]*anypb.Any, bool)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsRegionIdArrayOfValues 

func (fpaov *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsRegionIdArrayOfValues() ([]string, bool)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues 

func (fpaov *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue 

type ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue struct {
	ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsDataValue 

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsDataValue() (*anypb.Any, bool)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsRegionIdValue 

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsRegionIdValue() (string, bool)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsTimeValue 

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool)

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_RegionalServerMsgEvent) (int, bool)

CompareWith compares value in the 'ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_RegionalServerMsgEvent'.

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'RegionalServerMsgEvent' as interface{}

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_RegionalServerMsgEvent)

SetTo stores value for selected field for object RegionalServerMsgEvent

func (*ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogEventServerMsgEventFieldPathBuilder 

type ActivityLogEventServerMsgEventFieldPathBuilder struct{}

func NewActivityLogEventServerMsgEventFieldPathBuilder 

func NewActivityLogEventServerMsgEventFieldPathBuilder() ActivityLogEventServerMsgEventFieldPathBuilder

func (ActivityLogEventServerMsgEventFieldPathBuilder) Data 

func (ActivityLogEventServerMsgEventFieldPathBuilder) Data() ActivityLog_Event_ServerMsgEventPathSelectorData

func (ActivityLogEventServerMsgEventFieldPathBuilder) Time 

func (ActivityLogEventServerMsgEventFieldPathBuilder) Time() ActivityLog_Event_ServerMsgEventPathSelectorTime

type ActivityLogEventServerMsgEvent_FieldPath 

type ActivityLogEventServerMsgEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEventServerMsgEvent_FieldPathSelector
	Get(source *ActivityLog_Event_ServerMsgEvent) []interface{}
	GetSingle(source *ActivityLog_Event_ServerMsgEvent) (interface{}, bool)
	ClearValue(item *ActivityLog_Event_ServerMsgEvent)

	// Those methods build corresponding ActivityLogEventServerMsgEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogEventServerMsgEvent_FieldPath 

func BuildActivityLogEventServerMsgEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEventServerMsgEvent_FieldPath, error)

func MustParseActivityLogEventServerMsgEvent_FieldPath 

func MustParseActivityLogEventServerMsgEvent_FieldPath(rawField string) ActivityLogEventServerMsgEvent_FieldPath

func ParseActivityLogEventServerMsgEvent_FieldPath 

func ParseActivityLogEventServerMsgEvent_FieldPath(rawField string) (ActivityLogEventServerMsgEvent_FieldPath, error)

type ActivityLogEventServerMsgEvent_FieldPathArrayItemValue 

type ActivityLogEventServerMsgEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEventServerMsgEvent_FieldPath
	ContainsValue(*ActivityLog_Event_ServerMsgEvent) bool
}

ActivityLogEventServerMsgEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for ServerMsgEvent according to their type Present only for array (repeated) types.

func MustParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue 

func MustParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEventServerMsgEvent_FieldPathArrayItemValue

func ParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue 

func ParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEventServerMsgEvent_FieldPathArrayItemValue, error)

ParseActivityLogEventServerMsgEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogEventServerMsgEvent_FieldPathArrayOfValues 

type ActivityLogEventServerMsgEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEventServerMsgEvent_FieldPath
}

ActivityLogEventServerMsgEvent_FieldPathArrayOfValues allows storing slice of values for ServerMsgEvent fields according to their type

func MustParseActivityLogEventServerMsgEvent_FieldPathArrayOfValues 

func MustParseActivityLogEventServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEventServerMsgEvent_FieldPathArrayOfValues

func ParseActivityLogEventServerMsgEvent_FieldPathArrayOfValues 

func ParseActivityLogEventServerMsgEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEventServerMsgEvent_FieldPathArrayOfValues, error)

type ActivityLogEventServerMsgEvent_FieldPathSelector 

type ActivityLogEventServerMsgEvent_FieldPathSelector int32
const (
	ActivityLogEventServerMsgEvent_FieldPathSelectorData ActivityLogEventServerMsgEvent_FieldPathSelector = 0
	ActivityLogEventServerMsgEvent_FieldPathSelectorTime ActivityLogEventServerMsgEvent_FieldPathSelector = 1
)

func (ActivityLogEventServerMsgEvent_FieldPathSelector) String 

func (s ActivityLogEventServerMsgEvent_FieldPathSelector) String() string

type ActivityLogEventServerMsgEvent_FieldPathValue 

type ActivityLogEventServerMsgEvent_FieldPathValue interface {
	ActivityLogEventServerMsgEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event_ServerMsgEvent)
	CompareWith(*ActivityLog_Event_ServerMsgEvent) (cmp int, comparable bool)
}

ActivityLogEventServerMsgEvent_FieldPathValue allows storing values for ServerMsgEvent fields according to their type

func MustParseActivityLogEventServerMsgEvent_FieldPathValue 

func MustParseActivityLogEventServerMsgEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEventServerMsgEvent_FieldPathValue

func ParseActivityLogEventServerMsgEvent_FieldPathValue 

func ParseActivityLogEventServerMsgEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEventServerMsgEvent_FieldPathValue, error)

type ActivityLogEventServerMsgEvent_FieldTerminalPath 

type ActivityLogEventServerMsgEvent_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) ClearValue 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event_ServerMsgEvent)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) Get 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) Get(source *ActivityLog_Event_ServerMsgEvent) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Event_ServerMsgEvent

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) GetDefault 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) GetRaw 

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

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) GetSingle 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event_ServerMsgEvent) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Event_ServerMsgEvent

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) JSONString 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) Selector 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) Selector() ActivityLogEventServerMsgEvent_FieldPathSelector

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) String 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayItemValue

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEventServerMsgEvent_FieldPathArrayOfValues

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIValue 

func (fp *ActivityLogEventServerMsgEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEventServerMsgEvent_FieldPathValue

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogEventServerMsgEvent_FieldTerminalPath) WithRawIValue 

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

type ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue 

type ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEventServerMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event_ServerMsgEvent) bool

Contains returns a boolean indicating if value that is being held is present in given 'ServerMsgEvent'

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Event_ServerMsgEvent as interface{}

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event_ServerMsgEvent) (interface{}, bool)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues 

type ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEventServerMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues 

func (fpaov *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsDataArrayOfValues() ([]*anypb.Any, bool)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues 

func (fpaov *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamppb.Timestamp, bool)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogEventServerMsgEvent_FieldTerminalPathValue 

type ActivityLogEventServerMsgEvent_FieldTerminalPathValue struct {
	ActivityLogEventServerMsgEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsDataValue 

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsDataValue() (*anypb.Any, bool)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsTimeValue 

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamppb.Timestamp, bool)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event_ServerMsgEvent) (int, bool)

CompareWith compares value in the 'ActivityLogEventServerMsgEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event_ServerMsgEvent'.

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'ServerMsgEvent' as interface{}

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event_ServerMsgEvent)

SetTo stores value for selected field for object ServerMsgEvent

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogEvent_FieldPath 

type ActivityLogEvent_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogEvent_FieldPathSelector
	Get(source *ActivityLog_Event) []interface{}
	GetSingle(source *ActivityLog_Event) (interface{}, bool)
	ClearValue(item *ActivityLog_Event)

	// Those methods build corresponding ActivityLogEvent_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogEvent_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogEvent_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogEvent_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogEvent_FieldPath 

func BuildActivityLogEvent_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogEvent_FieldPath, error)

func MustParseActivityLogEvent_FieldPath 

func MustParseActivityLogEvent_FieldPath(rawField string) ActivityLogEvent_FieldPath

func ParseActivityLogEvent_FieldPath 

func ParseActivityLogEvent_FieldPath(rawField string) (ActivityLogEvent_FieldPath, error)

type ActivityLogEvent_FieldPathArrayItemValue 

type ActivityLogEvent_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogEvent_FieldPath
	ContainsValue(*ActivityLog_Event) bool
}

ActivityLogEvent_FieldPathArrayItemValue allows storing single item in Path-specific values for Event according to their type Present only for array (repeated) types.

func MustParseActivityLogEvent_FieldPathArrayItemValue 

func MustParseActivityLogEvent_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogEvent_FieldPathArrayItemValue

func ParseActivityLogEvent_FieldPathArrayItemValue 

func ParseActivityLogEvent_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogEvent_FieldPathArrayItemValue, error)

ParseActivityLogEvent_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogEvent_FieldPathArrayOfValues 

type ActivityLogEvent_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogEvent_FieldPath
}

ActivityLogEvent_FieldPathArrayOfValues allows storing slice of values for Event fields according to their type

func MustParseActivityLogEvent_FieldPathArrayOfValues 

func MustParseActivityLogEvent_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogEvent_FieldPathArrayOfValues

func ParseActivityLogEvent_FieldPathArrayOfValues 

func ParseActivityLogEvent_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogEvent_FieldPathArrayOfValues, error)

type ActivityLogEvent_FieldPathSelector 

type ActivityLogEvent_FieldPathSelector int32
const (
	ActivityLogEvent_FieldPathSelectorClientMessage         ActivityLogEvent_FieldPathSelector = 0
	ActivityLogEvent_FieldPathSelectorServerMessage         ActivityLogEvent_FieldPathSelector = 1
	ActivityLogEvent_FieldPathSelectorExit                  ActivityLogEvent_FieldPathSelector = 2
	ActivityLogEvent_FieldPathSelectorRegionalServerMessage ActivityLogEvent_FieldPathSelector = 3
	ActivityLogEvent_FieldPathSelectorRegionalExit          ActivityLogEvent_FieldPathSelector = 4
)

func (ActivityLogEvent_FieldPathSelector) String 

func (s ActivityLogEvent_FieldPathSelector) String() string

type ActivityLogEvent_FieldPathValue 

type ActivityLogEvent_FieldPathValue interface {
	ActivityLogEvent_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Event)
	CompareWith(*ActivityLog_Event) (cmp int, comparable bool)
}

ActivityLogEvent_FieldPathValue allows storing values for Event fields according to their type

func MustParseActivityLogEvent_FieldPathValue 

func MustParseActivityLogEvent_FieldPathValue(pathStr, valueStr string) ActivityLogEvent_FieldPathValue

func ParseActivityLogEvent_FieldPathValue 

func ParseActivityLogEvent_FieldPathValue(pathStr, valueStr string) (ActivityLogEvent_FieldPathValue, error)

type ActivityLogEvent_FieldSubPath 

type ActivityLogEvent_FieldSubPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldSubPath) AsClientMessageSubPath 

func (fps *ActivityLogEvent_FieldSubPath) AsClientMessageSubPath() (ActivityLogEventClientMsgEvent_FieldPath, bool)

func (*ActivityLogEvent_FieldSubPath) AsExitSubPath 

func (fps *ActivityLogEvent_FieldSubPath) AsExitSubPath() (ActivityLogEventExitEvent_FieldPath, bool)

func (*ActivityLogEvent_FieldSubPath) AsRegionalExitSubPath 

func (fps *ActivityLogEvent_FieldSubPath) AsRegionalExitSubPath() (ActivityLogEventRegionalServerMsgEvent_FieldPath, bool)

func (*ActivityLogEvent_FieldSubPath) AsRegionalServerMessageSubPath 

func (fps *ActivityLogEvent_FieldSubPath) AsRegionalServerMessageSubPath() (ActivityLogEventRegionalServerMsgEvent_FieldPath, bool)

func (*ActivityLogEvent_FieldSubPath) AsServerMessageSubPath 

func (fps *ActivityLogEvent_FieldSubPath) AsServerMessageSubPath() (ActivityLogEventServerMsgEvent_FieldPath, bool)

func (*ActivityLogEvent_FieldSubPath) ClearValue 

func (fps *ActivityLogEvent_FieldSubPath) ClearValue(item *ActivityLog_Event)

func (*ActivityLogEvent_FieldSubPath) ClearValueRaw 

func (fps *ActivityLogEvent_FieldSubPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEvent_FieldSubPath) Get 

func (fps *ActivityLogEvent_FieldSubPath) Get(source *ActivityLog_Event) (values []interface{})

Get returns all values pointed by selected field from source ActivityLog_Event

func (*ActivityLogEvent_FieldSubPath) GetDefault 

func (fps *ActivityLogEvent_FieldSubPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEvent_FieldSubPath) GetRaw 

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

func (*ActivityLogEvent_FieldSubPath) GetSingle 

func (fps *ActivityLogEvent_FieldSubPath) GetSingle(source *ActivityLog_Event) (interface{}, bool)

GetSingle returns value of selected field from source ActivityLog_Event

func (*ActivityLogEvent_FieldSubPath) GetSingleRaw 

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

func (*ActivityLogEvent_FieldSubPath) IsLeaf 

func (fps *ActivityLogEvent_FieldSubPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEvent_FieldSubPath) JSONString 

func (fps *ActivityLogEvent_FieldSubPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEvent_FieldSubPath) Selector 

func (fps *ActivityLogEvent_FieldSubPath) Selector() ActivityLogEvent_FieldPathSelector

func (*ActivityLogEvent_FieldSubPath) SplitIntoTerminalIPaths 

func (fps *ActivityLogEvent_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEvent_FieldSubPath) String 

func (fps *ActivityLogEvent_FieldSubPath) String() string

String returns path representation in proto convention

func (*ActivityLogEvent_FieldSubPath) WithIArrayItemValue 

func (fps *ActivityLogEvent_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogEvent_FieldPathArrayItemValue

func (*ActivityLogEvent_FieldSubPath) WithIArrayOfValues 

func (fps *ActivityLogEvent_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogEvent_FieldPathArrayOfValues

func (*ActivityLogEvent_FieldSubPath) WithIValue 

func (fps *ActivityLogEvent_FieldSubPath) WithIValue(value interface{}) ActivityLogEvent_FieldPathValue

func (*ActivityLogEvent_FieldSubPath) WithRawIArrayItemValue 

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

func (*ActivityLogEvent_FieldSubPath) WithRawIArrayOfValues 

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

func (*ActivityLogEvent_FieldSubPath) WithRawIValue 

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

type ActivityLogEvent_FieldSubPathArrayItemValue 

type ActivityLogEvent_FieldSubPathArrayItemValue struct {
	ActivityLogEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldSubPathArrayItemValue) AsClientMessagePathItemValue 

func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsClientMessagePathItemValue() (ActivityLogEventClientMsgEvent_FieldPathArrayItemValue, bool)

func (*ActivityLogEvent_FieldSubPathArrayItemValue) AsExitPathItemValue 

func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsExitPathItemValue() (ActivityLogEventExitEvent_FieldPathArrayItemValue, bool)

func (*ActivityLogEvent_FieldSubPathArrayItemValue) AsRegionalExitPathItemValue 

func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsRegionalExitPathItemValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue, bool)

func (*ActivityLogEvent_FieldSubPathArrayItemValue) AsRegionalServerMessagePathItemValue 

func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsRegionalServerMessagePathItemValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue, bool)

func (*ActivityLogEvent_FieldSubPathArrayItemValue) AsServerMessagePathItemValue 

func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) AsServerMessagePathItemValue() (ActivityLogEventServerMsgEvent_FieldPathArrayItemValue, bool)

func (*ActivityLogEvent_FieldSubPathArrayItemValue) ContainsValue 

func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Event) bool

Contains returns a boolean indicating if value that is being held is present in given 'Event'

func (*ActivityLogEvent_FieldSubPathArrayItemValue) GetRawItemValue 

func (fpaivs *ActivityLogEvent_FieldSubPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored array item value

type ActivityLogEvent_FieldSubPathArrayOfValues 

type ActivityLogEvent_FieldSubPathArrayOfValues struct {
	ActivityLogEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldSubPathArrayOfValues) AsClientMessagePathArrayOfValues 

func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsClientMessagePathArrayOfValues() (ActivityLogEventClientMsgEvent_FieldPathArrayOfValues, bool)

func (*ActivityLogEvent_FieldSubPathArrayOfValues) AsExitPathArrayOfValues 

func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsExitPathArrayOfValues() (ActivityLogEventExitEvent_FieldPathArrayOfValues, bool)

func (*ActivityLogEvent_FieldSubPathArrayOfValues) AsRegionalExitPathArrayOfValues 

func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsRegionalExitPathArrayOfValues() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues, bool)

func (*ActivityLogEvent_FieldSubPathArrayOfValues) AsRegionalServerMessagePathArrayOfValues 

func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsRegionalServerMessagePathArrayOfValues() (ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues, bool)

func (*ActivityLogEvent_FieldSubPathArrayOfValues) AsServerMessagePathArrayOfValues 

func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) AsServerMessagePathArrayOfValues() (ActivityLogEventServerMsgEvent_FieldPathArrayOfValues, bool)

func (*ActivityLogEvent_FieldSubPathArrayOfValues) GetRawValues 

func (fpsaov *ActivityLogEvent_FieldSubPathArrayOfValues) GetRawValues() []interface{}

type ActivityLogEvent_FieldSubPathValue 

type ActivityLogEvent_FieldSubPathValue struct {
	ActivityLogEvent_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldSubPathValue) AsClientMessagePathValue 

func (fpvs *ActivityLogEvent_FieldSubPathValue) AsClientMessagePathValue() (ActivityLogEventClientMsgEvent_FieldPathValue, bool)

func (*ActivityLogEvent_FieldSubPathValue) AsExitPathValue 

func (fpvs *ActivityLogEvent_FieldSubPathValue) AsExitPathValue() (ActivityLogEventExitEvent_FieldPathValue, bool)

func (*ActivityLogEvent_FieldSubPathValue) AsRegionalExitPathValue 

func (fpvs *ActivityLogEvent_FieldSubPathValue) AsRegionalExitPathValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathValue, bool)

func (*ActivityLogEvent_FieldSubPathValue) AsRegionalServerMessagePathValue 

func (fpvs *ActivityLogEvent_FieldSubPathValue) AsRegionalServerMessagePathValue() (ActivityLogEventRegionalServerMsgEvent_FieldPathValue, bool)

func (*ActivityLogEvent_FieldSubPathValue) AsServerMessagePathValue 

func (fpvs *ActivityLogEvent_FieldSubPathValue) AsServerMessagePathValue() (ActivityLogEventServerMsgEvent_FieldPathValue, bool)

func (*ActivityLogEvent_FieldSubPathValue) CompareWith 

func (fpvs *ActivityLogEvent_FieldSubPathValue) CompareWith(source *ActivityLog_Event) (int, bool)

func (*ActivityLogEvent_FieldSubPathValue) CompareWithRaw 

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

func (*ActivityLogEvent_FieldSubPathValue) GetRawValue 

func (fpvs *ActivityLogEvent_FieldSubPathValue) GetRawValue() interface{}

func (*ActivityLogEvent_FieldSubPathValue) SetTo 

func (fpvs *ActivityLogEvent_FieldSubPathValue) SetTo(target **ActivityLog_Event)

func (*ActivityLogEvent_FieldSubPathValue) SetToRaw 

func (fpvs *ActivityLogEvent_FieldSubPathValue) SetToRaw(target proto.Message)

type ActivityLogEvent_FieldTerminalPath 

type ActivityLogEvent_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldTerminalPath) ClearValue 

func (fp *ActivityLogEvent_FieldTerminalPath) ClearValue(item *ActivityLog_Event)

func (*ActivityLogEvent_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogEvent_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogEvent_FieldTerminalPath) Get 

func (fp *ActivityLogEvent_FieldTerminalPath) Get(source *ActivityLog_Event) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Event

func (*ActivityLogEvent_FieldTerminalPath) GetDefault 

func (fp *ActivityLogEvent_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogEvent_FieldTerminalPath) GetRaw 

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

func (*ActivityLogEvent_FieldTerminalPath) GetSingle 

func (fp *ActivityLogEvent_FieldTerminalPath) GetSingle(source *ActivityLog_Event) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Event

func (*ActivityLogEvent_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogEvent_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogEvent_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogEvent_FieldTerminalPath) JSONString 

func (fp *ActivityLogEvent_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogEvent_FieldTerminalPath) Selector 

func (fp *ActivityLogEvent_FieldTerminalPath) Selector() ActivityLogEvent_FieldPathSelector

func (*ActivityLogEvent_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogEvent_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogEvent_FieldTerminalPath) String 

func (fp *ActivityLogEvent_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogEvent_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogEvent_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogEvent_FieldPathArrayItemValue

func (*ActivityLogEvent_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogEvent_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogEvent_FieldPathArrayOfValues

func (*ActivityLogEvent_FieldTerminalPath) WithIValue 

func (fp *ActivityLogEvent_FieldTerminalPath) WithIValue(value interface{}) ActivityLogEvent_FieldPathValue

func (*ActivityLogEvent_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogEvent_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogEvent_FieldTerminalPath) WithRawIValue 

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

type ActivityLogEvent_FieldTerminalPathArrayItemValue 

type ActivityLogEvent_FieldTerminalPathArrayItemValue struct {
	ActivityLogEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogEvent_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Event) bool

Contains returns a boolean indicating if value that is being held is present in given 'Event'

func (*ActivityLogEvent_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogEvent_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Event as interface{}

func (*ActivityLogEvent_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogEvent_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Event) (interface{}, bool)

func (*ActivityLogEvent_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogEvent_FieldTerminalPathArrayOfValues 

type ActivityLogEvent_FieldTerminalPathArrayOfValues struct {
	ActivityLogEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldTerminalPathArrayOfValues) AsClientMessageArrayOfValues 

func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsClientMessageArrayOfValues() ([]*ActivityLog_Event_ClientMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathArrayOfValues) AsExitArrayOfValues 

func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsExitArrayOfValues() ([]*ActivityLog_Event_ExitEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathArrayOfValues) AsRegionalExitArrayOfValues 

func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsRegionalExitArrayOfValues() ([]*ActivityLog_Event_RegionalServerMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathArrayOfValues) AsRegionalServerMessageArrayOfValues 

func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsRegionalServerMessageArrayOfValues() ([]*ActivityLog_Event_RegionalServerMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathArrayOfValues) AsServerMessageArrayOfValues 

func (fpaov *ActivityLogEvent_FieldTerminalPathArrayOfValues) AsServerMessageArrayOfValues() ([]*ActivityLog_Event_ServerMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogEvent_FieldTerminalPathValue 

type ActivityLogEvent_FieldTerminalPathValue struct {
	ActivityLogEvent_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogEvent_FieldTerminalPathValue) AsClientMessageValue 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsClientMessageValue() (*ActivityLog_Event_ClientMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathValue) AsExitValue 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsExitValue() (*ActivityLog_Event_ExitEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathValue) AsRegionalExitValue 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsRegionalExitValue() (*ActivityLog_Event_RegionalServerMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathValue) AsRegionalServerMessageValue 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsRegionalServerMessageValue() (*ActivityLog_Event_RegionalServerMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathValue) AsServerMessageValue 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) AsServerMessageValue() (*ActivityLog_Event_ServerMsgEvent, bool)

func (*ActivityLogEvent_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) CompareWith(source *ActivityLog_Event) (int, bool)

CompareWith compares value in the 'ActivityLogEvent_FieldTerminalPathValue' with the value under path in 'ActivityLog_Event'.

func (*ActivityLogEvent_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogEvent_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'Event' as interface{}

func (*ActivityLogEvent_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) SetTo(target **ActivityLog_Event)

SetTo stores value for selected field for object Event

func (*ActivityLogEvent_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogEvent_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogFieldPathBuilder 

type ActivityLogFieldPathBuilder struct{}

func NewActivityLogFieldPathBuilder 

func NewActivityLogFieldPathBuilder() ActivityLogFieldPathBuilder

func (ActivityLogFieldPathBuilder) Authentication 

func (ActivityLogFieldPathBuilder) Authentication() ActivityLogPathSelectorAuthentication

func (ActivityLogFieldPathBuilder) Authorization 

func (ActivityLogFieldPathBuilder) Authorization() ActivityLogPathSelectorAuthorization

func (ActivityLogFieldPathBuilder) Category 

func (ActivityLogFieldPathBuilder) Category() ActivityLogPathSelectorCategory

func (ActivityLogFieldPathBuilder) Events 

func (ActivityLogFieldPathBuilder) Events() ActivityLogPathSelectorEvents

func (ActivityLogFieldPathBuilder) Labels 

func (ActivityLogFieldPathBuilder) Labels() ActivityLogPathSelectorLabels

func (ActivityLogFieldPathBuilder) Method 

func (ActivityLogFieldPathBuilder) Method() ActivityLogPathSelectorMethod

func (ActivityLogFieldPathBuilder) Name 

func (ActivityLogFieldPathBuilder) Name() ActivityLogPathSelectorName

func (ActivityLogFieldPathBuilder) RequestId 

func (ActivityLogFieldPathBuilder) RequestId() ActivityLogPathSelectorRequestId

func (ActivityLogFieldPathBuilder) RequestMetadata 

func (ActivityLogFieldPathBuilder) RequestMetadata() ActivityLogPathSelectorRequestMetadata

func (ActivityLogFieldPathBuilder) RequestRouting 

func (ActivityLogFieldPathBuilder) RequestRouting() ActivityLogPathSelectorRequestRouting

func (ActivityLogFieldPathBuilder) Resource 

func (ActivityLogFieldPathBuilder) Resource() ActivityLogPathSelectorResource

func (ActivityLogFieldPathBuilder) Scope 

func (ActivityLogFieldPathBuilder) Scope() ActivityLogPathSelectorScope

func (ActivityLogFieldPathBuilder) Service 

func (ActivityLogFieldPathBuilder) Service() ActivityLogPathSelectorService

type ActivityLogList 

type ActivityLogList []*ActivityLog

func (ActivityLogList) Append 

func (l ActivityLogList) Append(item gotenresource.Resource) gotenresource.ResourceList

func (ActivityLogList) AppendList 

func (l ActivityLogList) AppendList(list gotenresource.ResourceList) gotenresource.ResourceList

func (ActivityLogList) At 

func (l ActivityLogList) At(idx int) gotenresource.Resource

func (ActivityLogList) Length 

func (l ActivityLogList) Length() int

func (ActivityLogList) Set 

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

func (ActivityLogList) Slice 

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

type ActivityLogMap 

type ActivityLogMap map[Name]*ActivityLog

func (ActivityLogMap) Delete 

func (m ActivityLogMap) Delete(name gotenresource.Name)

func (ActivityLogMap) ForEach 

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

func (ActivityLogMap) Get 

func (m ActivityLogMap) Get(name gotenresource.Name) gotenresource.Resource

func (ActivityLogMap) Length 

func (m ActivityLogMap) Length() int

func (ActivityLogMap) Set 

func (m ActivityLogMap) Set(res gotenresource.Resource)

type ActivityLogMapPathSelectorLabels 

type ActivityLogMapPathSelectorLabels struct {
	// contains filtered or unexported fields
}

func (ActivityLogMapPathSelectorLabels) FieldPath 

func (s ActivityLogMapPathSelectorLabels) FieldPath() *ActivityLog_FieldPathMap

func (ActivityLogMapPathSelectorLabels) WithArrayOfValues 

func (s ActivityLogMapPathSelectorLabels) WithArrayOfValues(values []string) *ActivityLog_FieldPathMapArrayOfValues

func (ActivityLogMapPathSelectorLabels) WithValue 

func (s ActivityLogMapPathSelectorLabels) WithValue(value string) *ActivityLog_FieldPathMapValue

type ActivityLogMethodFieldPathBuilder 

type ActivityLogMethodFieldPathBuilder struct{}

func NewActivityLogMethodFieldPathBuilder 

func NewActivityLogMethodFieldPathBuilder() ActivityLogMethodFieldPathBuilder

func (ActivityLogMethodFieldPathBuilder) Type 

func (ActivityLogMethodFieldPathBuilder) Type() ActivityLog_MethodPathSelectorType

func (ActivityLogMethodFieldPathBuilder) Version 

func (ActivityLogMethodFieldPathBuilder) Version() ActivityLog_MethodPathSelectorVersion

type ActivityLogMethod_FieldPath 

type ActivityLogMethod_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogMethod_FieldPathSelector
	Get(source *ActivityLog_Method) []interface{}
	GetSingle(source *ActivityLog_Method) (interface{}, bool)
	ClearValue(item *ActivityLog_Method)

	// Those methods build corresponding ActivityLogMethod_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogMethod_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogMethod_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogMethod_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogMethod_FieldPath 

func BuildActivityLogMethod_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogMethod_FieldPath, error)

func MustParseActivityLogMethod_FieldPath 

func MustParseActivityLogMethod_FieldPath(rawField string) ActivityLogMethod_FieldPath

func ParseActivityLogMethod_FieldPath 

func ParseActivityLogMethod_FieldPath(rawField string) (ActivityLogMethod_FieldPath, error)

type ActivityLogMethod_FieldPathArrayItemValue 

type ActivityLogMethod_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogMethod_FieldPath
	ContainsValue(*ActivityLog_Method) bool
}

ActivityLogMethod_FieldPathArrayItemValue allows storing single item in Path-specific values for Method according to their type Present only for array (repeated) types.

func MustParseActivityLogMethod_FieldPathArrayItemValue 

func MustParseActivityLogMethod_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogMethod_FieldPathArrayItemValue

func ParseActivityLogMethod_FieldPathArrayItemValue 

func ParseActivityLogMethod_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogMethod_FieldPathArrayItemValue, error)

ParseActivityLogMethod_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogMethod_FieldPathArrayOfValues 

type ActivityLogMethod_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogMethod_FieldPath
}

ActivityLogMethod_FieldPathArrayOfValues allows storing slice of values for Method fields according to their type

func MustParseActivityLogMethod_FieldPathArrayOfValues 

func MustParseActivityLogMethod_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogMethod_FieldPathArrayOfValues

func ParseActivityLogMethod_FieldPathArrayOfValues 

func ParseActivityLogMethod_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogMethod_FieldPathArrayOfValues, error)

type ActivityLogMethod_FieldPathSelector 

type ActivityLogMethod_FieldPathSelector int32
const (
	ActivityLogMethod_FieldPathSelectorType    ActivityLogMethod_FieldPathSelector = 0
	ActivityLogMethod_FieldPathSelectorVersion ActivityLogMethod_FieldPathSelector = 1
)

func (ActivityLogMethod_FieldPathSelector) String 

func (s ActivityLogMethod_FieldPathSelector) String() string

type ActivityLogMethod_FieldPathValue 

type ActivityLogMethod_FieldPathValue interface {
	ActivityLogMethod_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Method)
	CompareWith(*ActivityLog_Method) (cmp int, comparable bool)
}

ActivityLogMethod_FieldPathValue allows storing values for Method fields according to their type

func MustParseActivityLogMethod_FieldPathValue 

func MustParseActivityLogMethod_FieldPathValue(pathStr, valueStr string) ActivityLogMethod_FieldPathValue

func ParseActivityLogMethod_FieldPathValue 

func ParseActivityLogMethod_FieldPathValue(pathStr, valueStr string) (ActivityLogMethod_FieldPathValue, error)

type ActivityLogMethod_FieldTerminalPath 

type ActivityLogMethod_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogMethod_FieldTerminalPath) ClearValue 

func (fp *ActivityLogMethod_FieldTerminalPath) ClearValue(item *ActivityLog_Method)

func (*ActivityLogMethod_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogMethod_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogMethod_FieldTerminalPath) Get 

func (fp *ActivityLogMethod_FieldTerminalPath) Get(source *ActivityLog_Method) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Method

func (*ActivityLogMethod_FieldTerminalPath) GetDefault 

func (fp *ActivityLogMethod_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogMethod_FieldTerminalPath) GetRaw 

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

func (*ActivityLogMethod_FieldTerminalPath) GetSingle 

func (fp *ActivityLogMethod_FieldTerminalPath) GetSingle(source *ActivityLog_Method) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Method

func (*ActivityLogMethod_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogMethod_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogMethod_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogMethod_FieldTerminalPath) JSONString 

func (fp *ActivityLogMethod_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogMethod_FieldTerminalPath) Selector 

func (fp *ActivityLogMethod_FieldTerminalPath) Selector() ActivityLogMethod_FieldPathSelector

func (*ActivityLogMethod_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogMethod_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogMethod_FieldTerminalPath) String 

func (fp *ActivityLogMethod_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogMethod_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogMethod_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogMethod_FieldPathArrayItemValue

func (*ActivityLogMethod_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogMethod_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogMethod_FieldPathArrayOfValues

func (*ActivityLogMethod_FieldTerminalPath) WithIValue 

func (fp *ActivityLogMethod_FieldTerminalPath) WithIValue(value interface{}) ActivityLogMethod_FieldPathValue

func (*ActivityLogMethod_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogMethod_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogMethod_FieldTerminalPath) WithRawIValue 

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

type ActivityLogMethod_FieldTerminalPathArrayItemValue 

type ActivityLogMethod_FieldTerminalPathArrayItemValue struct {
	ActivityLogMethod_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogMethod_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogMethod_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Method) bool

Contains returns a boolean indicating if value that is being held is present in given 'Method'

func (*ActivityLogMethod_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogMethod_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Method as interface{}

func (*ActivityLogMethod_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogMethod_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Method) (interface{}, bool)

func (*ActivityLogMethod_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogMethod_FieldTerminalPathArrayOfValues 

type ActivityLogMethod_FieldTerminalPathArrayOfValues struct {
	ActivityLogMethod_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogMethod_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues 

func (fpaov *ActivityLogMethod_FieldTerminalPathArrayOfValues) AsTypeArrayOfValues() ([]string, bool)

func (*ActivityLogMethod_FieldTerminalPathArrayOfValues) AsVersionArrayOfValues 

func (fpaov *ActivityLogMethod_FieldTerminalPathArrayOfValues) AsVersionArrayOfValues() ([]string, bool)

func (*ActivityLogMethod_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogMethod_FieldTerminalPathValue 

type ActivityLogMethod_FieldTerminalPathValue struct {
	ActivityLogMethod_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogMethod_FieldTerminalPathValue) AsTypeValue 

func (fpv *ActivityLogMethod_FieldTerminalPathValue) AsTypeValue() (string, bool)

func (*ActivityLogMethod_FieldTerminalPathValue) AsVersionValue 

func (fpv *ActivityLogMethod_FieldTerminalPathValue) AsVersionValue() (string, bool)

func (*ActivityLogMethod_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogMethod_FieldTerminalPathValue) CompareWith(source *ActivityLog_Method) (int, bool)

CompareWith compares value in the 'ActivityLogMethod_FieldTerminalPathValue' with the value under path in 'ActivityLog_Method'.

func (*ActivityLogMethod_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogMethod_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogMethod_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'Method' as interface{}

func (*ActivityLogMethod_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogMethod_FieldTerminalPathValue) SetTo(target **ActivityLog_Method)

SetTo stores value for selected field for object Method

func (*ActivityLogMethod_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogMethod_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogNameList 

type ActivityLogNameList []*Name

func (ActivityLogNameList) Append 

func (l ActivityLogNameList) Append(name gotenresource.Name) gotenresource.NameList

func (ActivityLogNameList) AppendList 

func (l ActivityLogNameList) AppendList(list gotenresource.NameList) gotenresource.NameList

func (ActivityLogNameList) At 

func (l ActivityLogNameList) At(idx int) gotenresource.Name

func (ActivityLogNameList) Length 

func (l ActivityLogNameList) Length() int

func (ActivityLogNameList) Set 

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

func (ActivityLogNameList) Slice 

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

type ActivityLogParentNameList 

type ActivityLogParentNameList []*ParentName

func (ActivityLogParentNameList) Append 

func (l ActivityLogParentNameList) Append(name gotenresource.Name) gotenresource.ParentNameList

func (ActivityLogParentNameList) AppendList 

func (l ActivityLogParentNameList) AppendList(list gotenresource.ParentNameList) gotenresource.ParentNameList

func (ActivityLogParentNameList) At 

func (l ActivityLogParentNameList) At(idx int) gotenresource.Name

func (ActivityLogParentNameList) Length 

func (l ActivityLogParentNameList) Length() int

func (ActivityLogParentNameList) Set 

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

func (ActivityLogParentNameList) Slice 

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

type ActivityLogParentReferenceList 

type ActivityLogParentReferenceList []*ParentReference

func (ActivityLogParentReferenceList) Append 

func (l ActivityLogParentReferenceList) Append(ref gotenresource.Reference) gotenresource.ParentReferenceList

func (ActivityLogParentReferenceList) AppendList 

func (l ActivityLogParentReferenceList) AppendList(list gotenresource.ParentReferenceList) gotenresource.ParentReferenceList

func (ActivityLogParentReferenceList) At 

func (l ActivityLogParentReferenceList) At(idx int) gotenresource.Reference

func (ActivityLogParentReferenceList) Length 

func (l ActivityLogParentReferenceList) Length() int

func (ActivityLogParentReferenceList) Set 

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

func (ActivityLogParentReferenceList) Slice 

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

type ActivityLogPathSelectorAuthentication 

type ActivityLogPathSelectorAuthentication struct{}

func (ActivityLogPathSelectorAuthentication) FieldPath 

func (ActivityLogPathSelectorAuthentication) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorAuthentication) Principal 

func (ActivityLogPathSelectorAuthentication) Principal() ActivityLogPathSelectorAuthenticationPrincipal

func (ActivityLogPathSelectorAuthentication) PrincipalType 

func (ActivityLogPathSelectorAuthentication) PrincipalType() ActivityLogPathSelectorAuthenticationPrincipalType

func (ActivityLogPathSelectorAuthentication) WithArrayOfValues 

func (s ActivityLogPathSelectorAuthentication) WithArrayOfValues(values []*common.Authentication) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorAuthentication) WithSubArrayItemValue 

func (s ActivityLogPathSelectorAuthentication) WithSubArrayItemValue(subPathArrayItemValue common.Authentication_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorAuthentication) WithSubArrayOfValues 

func (s ActivityLogPathSelectorAuthentication) WithSubArrayOfValues(subPathArrayOfValues common.Authentication_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorAuthentication) WithSubPath 

func (ActivityLogPathSelectorAuthentication) WithSubPath(subPath common.Authentication_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorAuthentication) WithSubValue 

func (s ActivityLogPathSelectorAuthentication) WithSubValue(subPathValue common.Authentication_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorAuthentication) WithValue 

func (s ActivityLogPathSelectorAuthentication) WithValue(value *common.Authentication) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorAuthenticationPrincipal 

type ActivityLogPathSelectorAuthenticationPrincipal struct{}

func (ActivityLogPathSelectorAuthenticationPrincipal) FieldPath 

func (ActivityLogPathSelectorAuthenticationPrincipal) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorAuthenticationPrincipal) WithArrayOfValues 

func (s ActivityLogPathSelectorAuthenticationPrincipal) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorAuthenticationPrincipal) WithValue 

func (s ActivityLogPathSelectorAuthenticationPrincipal) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorAuthenticationPrincipalType 

type ActivityLogPathSelectorAuthenticationPrincipalType struct{}

func (ActivityLogPathSelectorAuthenticationPrincipalType) FieldPath 

func (ActivityLogPathSelectorAuthenticationPrincipalType) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorAuthenticationPrincipalType) WithArrayOfValues 

func (s ActivityLogPathSelectorAuthenticationPrincipalType) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorAuthenticationPrincipalType) WithValue 

func (s ActivityLogPathSelectorAuthenticationPrincipalType) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorAuthorization 

type ActivityLogPathSelectorAuthorization struct{}

func (ActivityLogPathSelectorAuthorization) DeniedPermissions 

func (ActivityLogPathSelectorAuthorization) DeniedPermissions() ActivityLogPathSelectorAuthorizationDeniedPermissions

func (ActivityLogPathSelectorAuthorization) FieldPath 

func (ActivityLogPathSelectorAuthorization) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorAuthorization) GrantedPermissions 

func (ActivityLogPathSelectorAuthorization) GrantedPermissions() ActivityLogPathSelectorAuthorizationGrantedPermissions

func (ActivityLogPathSelectorAuthorization) WithArrayOfValues 

func (s ActivityLogPathSelectorAuthorization) WithArrayOfValues(values []*common.Authorization) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorAuthorization) WithSubArrayItemValue 

func (s ActivityLogPathSelectorAuthorization) WithSubArrayItemValue(subPathArrayItemValue common.Authorization_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorAuthorization) WithSubArrayOfValues 

func (s ActivityLogPathSelectorAuthorization) WithSubArrayOfValues(subPathArrayOfValues common.Authorization_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorAuthorization) WithSubPath 

func (ActivityLogPathSelectorAuthorization) WithSubPath(subPath common.Authorization_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorAuthorization) WithSubValue 

func (s ActivityLogPathSelectorAuthorization) WithSubValue(subPathValue common.Authorization_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorAuthorization) WithValue 

func (s ActivityLogPathSelectorAuthorization) WithValue(value *common.Authorization) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorAuthorizationDeniedPermissions 

type ActivityLogPathSelectorAuthorizationDeniedPermissions struct{}

func (ActivityLogPathSelectorAuthorizationDeniedPermissions) FieldPath 

func (ActivityLogPathSelectorAuthorizationDeniedPermissions) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorAuthorizationDeniedPermissions) WithArrayOfValues 

func (s ActivityLogPathSelectorAuthorizationDeniedPermissions) WithArrayOfValues(values [][]string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorAuthorizationDeniedPermissions) WithItemValue 

func (s ActivityLogPathSelectorAuthorizationDeniedPermissions) WithItemValue(value string) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorAuthorizationDeniedPermissions) WithValue 

func (s ActivityLogPathSelectorAuthorizationDeniedPermissions) WithValue(value []string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorAuthorizationGrantedPermissions 

type ActivityLogPathSelectorAuthorizationGrantedPermissions struct{}

func (ActivityLogPathSelectorAuthorizationGrantedPermissions) FieldPath 

func (ActivityLogPathSelectorAuthorizationGrantedPermissions) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorAuthorizationGrantedPermissions) WithArrayOfValues 

func (s ActivityLogPathSelectorAuthorizationGrantedPermissions) WithArrayOfValues(values [][]string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorAuthorizationGrantedPermissions) WithItemValue 

func (s ActivityLogPathSelectorAuthorizationGrantedPermissions) WithItemValue(value string) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorAuthorizationGrantedPermissions) WithValue 

func (s ActivityLogPathSelectorAuthorizationGrantedPermissions) WithValue(value []string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorCategory 

type ActivityLogPathSelectorCategory struct{}

func (ActivityLogPathSelectorCategory) FieldPath 

func (ActivityLogPathSelectorCategory) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorCategory) WithArrayOfValues 

func (s ActivityLogPathSelectorCategory) WithArrayOfValues(values []ActivityLog_Category) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorCategory) WithValue 

func (s ActivityLogPathSelectorCategory) WithValue(value ActivityLog_Category) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorEvents 

type ActivityLogPathSelectorEvents struct{}

func (ActivityLogPathSelectorEvents) ClientMessage 

func (ActivityLogPathSelectorEvents) ClientMessage() ActivityLogPathSelectorEventsClientMessage

func (ActivityLogPathSelectorEvents) Exit 

func (ActivityLogPathSelectorEvents) Exit() ActivityLogPathSelectorEventsExit

func (ActivityLogPathSelectorEvents) FieldPath 

func (ActivityLogPathSelectorEvents) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorEvents) RegionalExit 

func (ActivityLogPathSelectorEvents) RegionalExit() ActivityLogPathSelectorEventsRegionalExit

func (ActivityLogPathSelectorEvents) RegionalServerMessage 

func (ActivityLogPathSelectorEvents) RegionalServerMessage() ActivityLogPathSelectorEventsRegionalServerMessage

func (ActivityLogPathSelectorEvents) ServerMessage 

func (ActivityLogPathSelectorEvents) ServerMessage() ActivityLogPathSelectorEventsServerMessage

func (ActivityLogPathSelectorEvents) WithArrayOfValues 

func (s ActivityLogPathSelectorEvents) WithArrayOfValues(values [][]*ActivityLog_Event) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorEvents) WithItemValue 

func (s ActivityLogPathSelectorEvents) WithItemValue(value *ActivityLog_Event) *ActivityLog_FieldTerminalPathArrayItemValue

func (ActivityLogPathSelectorEvents) WithSubArrayItemValue 

func (s ActivityLogPathSelectorEvents) WithSubArrayItemValue(subPathArrayItemValue ActivityLogEvent_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorEvents) WithSubArrayOfValues 

func (s ActivityLogPathSelectorEvents) WithSubArrayOfValues(subPathArrayOfValues ActivityLogEvent_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEvents) WithSubPath 

func (ActivityLogPathSelectorEvents) WithSubPath(subPath ActivityLogEvent_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEvents) WithSubValue 

func (s ActivityLogPathSelectorEvents) WithSubValue(subPathValue ActivityLogEvent_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorEvents) WithValue 

func (s ActivityLogPathSelectorEvents) WithValue(value []*ActivityLog_Event) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorEventsClientMessage 

type ActivityLogPathSelectorEventsClientMessage struct{}

func (ActivityLogPathSelectorEventsClientMessage) Data 

func (ActivityLogPathSelectorEventsClientMessage) Data() ActivityLogPathSelectorEventsClientMessageData

func (ActivityLogPathSelectorEventsClientMessage) FieldPath 

func (ActivityLogPathSelectorEventsClientMessage) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsClientMessage) Time 

func (ActivityLogPathSelectorEventsClientMessage) Time() ActivityLogPathSelectorEventsClientMessageTime

func (ActivityLogPathSelectorEventsClientMessage) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsClientMessage) WithArrayOfValues(values []*ActivityLog_Event_ClientMsgEvent) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsClientMessage) WithValue 

func (s ActivityLogPathSelectorEventsClientMessage) WithValue(value *ActivityLog_Event_ClientMsgEvent) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsClientMessageData 

type ActivityLogPathSelectorEventsClientMessageData struct{}

func (ActivityLogPathSelectorEventsClientMessageData) FieldPath 

func (ActivityLogPathSelectorEventsClientMessageData) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsClientMessageData) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsClientMessageData) WithArrayOfValues(values []*anypb.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsClientMessageData) WithValue 

func (s ActivityLogPathSelectorEventsClientMessageData) WithValue(value *anypb.Any) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsClientMessageTime 

type ActivityLogPathSelectorEventsClientMessageTime struct{}

func (ActivityLogPathSelectorEventsClientMessageTime) FieldPath 

func (ActivityLogPathSelectorEventsClientMessageTime) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsClientMessageTime) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsClientMessageTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsClientMessageTime) WithValue 

func (s ActivityLogPathSelectorEventsClientMessageTime) WithValue(value *timestamppb.Timestamp) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsExit 

type ActivityLogPathSelectorEventsExit struct{}

func (ActivityLogPathSelectorEventsExit) FieldPath 

func (ActivityLogPathSelectorEventsExit) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsExit) Status 

func (ActivityLogPathSelectorEventsExit) Status() ActivityLogPathSelectorEventsExitStatus

func (ActivityLogPathSelectorEventsExit) Time 

func (ActivityLogPathSelectorEventsExit) Time() ActivityLogPathSelectorEventsExitTime

func (ActivityLogPathSelectorEventsExit) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsExit) WithArrayOfValues(values []*ActivityLog_Event_ExitEvent) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExit) WithValue 

func (s ActivityLogPathSelectorEventsExit) WithValue(value *ActivityLog_Event_ExitEvent) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsExitStatus 

type ActivityLogPathSelectorEventsExitStatus struct{}

func (ActivityLogPathSelectorEventsExitStatus) Code 

func (ActivityLogPathSelectorEventsExitStatus) Code() ActivityLogPathSelectorEventsExitStatusCode

func (ActivityLogPathSelectorEventsExitStatus) Details 

func (ActivityLogPathSelectorEventsExitStatus) Details() ActivityLogPathSelectorEventsExitStatusDetails

func (ActivityLogPathSelectorEventsExitStatus) FieldPath 

func (ActivityLogPathSelectorEventsExitStatus) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsExitStatus) Message 

func (ActivityLogPathSelectorEventsExitStatus) Message() ActivityLogPathSelectorEventsExitStatusMessage

func (ActivityLogPathSelectorEventsExitStatus) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsExitStatus) WithArrayOfValues(values []*rpc.Status) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExitStatus) WithValue 

func (s ActivityLogPathSelectorEventsExitStatus) WithValue(value *rpc.Status) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsExitStatusCode 

type ActivityLogPathSelectorEventsExitStatusCode struct{}

func (ActivityLogPathSelectorEventsExitStatusCode) FieldPath 

func (ActivityLogPathSelectorEventsExitStatusCode) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsExitStatusCode) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsExitStatusCode) WithArrayOfValues(values []int32) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExitStatusCode) WithValue 

func (s ActivityLogPathSelectorEventsExitStatusCode) WithValue(value int32) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsExitStatusDetails 

type ActivityLogPathSelectorEventsExitStatusDetails struct{}

func (ActivityLogPathSelectorEventsExitStatusDetails) FieldPath 

func (ActivityLogPathSelectorEventsExitStatusDetails) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsExitStatusDetails) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsExitStatusDetails) WithArrayOfValues(values [][]*anypb.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExitStatusDetails) WithItemValue 

func (s ActivityLogPathSelectorEventsExitStatusDetails) WithItemValue(value *anypb.Any) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorEventsExitStatusDetails) WithValue 

func (s ActivityLogPathSelectorEventsExitStatusDetails) WithValue(value []*anypb.Any) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsExitStatusMessage 

type ActivityLogPathSelectorEventsExitStatusMessage struct{}

func (ActivityLogPathSelectorEventsExitStatusMessage) FieldPath 

func (ActivityLogPathSelectorEventsExitStatusMessage) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsExitStatusMessage) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsExitStatusMessage) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExitStatusMessage) WithValue 

func (s ActivityLogPathSelectorEventsExitStatusMessage) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsExitTime 

type ActivityLogPathSelectorEventsExitTime struct{}

func (ActivityLogPathSelectorEventsExitTime) FieldPath 

func (ActivityLogPathSelectorEventsExitTime) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsExitTime) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsExitTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExitTime) WithValue 

func (s ActivityLogPathSelectorEventsExitTime) WithValue(value *timestamppb.Timestamp) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalExit 

type ActivityLogPathSelectorEventsRegionalExit struct{}

func (ActivityLogPathSelectorEventsRegionalExit) Data 

func (ActivityLogPathSelectorEventsRegionalExit) Data() ActivityLogPathSelectorEventsRegionalExitData

func (ActivityLogPathSelectorEventsRegionalExit) FieldPath 

func (ActivityLogPathSelectorEventsRegionalExit) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalExit) RegionId 

func (ActivityLogPathSelectorEventsRegionalExit) RegionId() ActivityLogPathSelectorEventsRegionalExitRegionId

func (ActivityLogPathSelectorEventsRegionalExit) Time 

func (ActivityLogPathSelectorEventsRegionalExit) Time() ActivityLogPathSelectorEventsRegionalExitTime

func (ActivityLogPathSelectorEventsRegionalExit) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalExit) WithArrayOfValues(values []*ActivityLog_Event_RegionalServerMsgEvent) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalExit) WithValue 

func (s ActivityLogPathSelectorEventsRegionalExit) WithValue(value *ActivityLog_Event_RegionalServerMsgEvent) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalExitData 

type ActivityLogPathSelectorEventsRegionalExitData struct{}

func (ActivityLogPathSelectorEventsRegionalExitData) FieldPath 

func (ActivityLogPathSelectorEventsRegionalExitData) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalExitData) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalExitData) WithArrayOfValues(values []*anypb.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalExitData) WithValue 

func (s ActivityLogPathSelectorEventsRegionalExitData) WithValue(value *anypb.Any) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalExitRegionId 

type ActivityLogPathSelectorEventsRegionalExitRegionId struct{}

func (ActivityLogPathSelectorEventsRegionalExitRegionId) FieldPath 

func (ActivityLogPathSelectorEventsRegionalExitRegionId) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalExitRegionId) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalExitRegionId) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalExitRegionId) WithValue 

func (s ActivityLogPathSelectorEventsRegionalExitRegionId) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalExitTime 

type ActivityLogPathSelectorEventsRegionalExitTime struct{}

func (ActivityLogPathSelectorEventsRegionalExitTime) FieldPath 

func (ActivityLogPathSelectorEventsRegionalExitTime) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalExitTime) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalExitTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalExitTime) WithValue 

func (s ActivityLogPathSelectorEventsRegionalExitTime) WithValue(value *timestamppb.Timestamp) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalServerMessage 

type ActivityLogPathSelectorEventsRegionalServerMessage struct{}

func (ActivityLogPathSelectorEventsRegionalServerMessage) Data 

func (ActivityLogPathSelectorEventsRegionalServerMessage) Data() ActivityLogPathSelectorEventsRegionalServerMessageData

func (ActivityLogPathSelectorEventsRegionalServerMessage) FieldPath 

func (ActivityLogPathSelectorEventsRegionalServerMessage) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalServerMessage) RegionId 

func (ActivityLogPathSelectorEventsRegionalServerMessage) RegionId() ActivityLogPathSelectorEventsRegionalServerMessageRegionId

func (ActivityLogPathSelectorEventsRegionalServerMessage) Time 

func (ActivityLogPathSelectorEventsRegionalServerMessage) Time() ActivityLogPathSelectorEventsRegionalServerMessageTime

func (ActivityLogPathSelectorEventsRegionalServerMessage) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalServerMessage) WithArrayOfValues(values []*ActivityLog_Event_RegionalServerMsgEvent) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalServerMessage) WithValue 

func (s ActivityLogPathSelectorEventsRegionalServerMessage) WithValue(value *ActivityLog_Event_RegionalServerMsgEvent) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalServerMessageData 

type ActivityLogPathSelectorEventsRegionalServerMessageData struct{}

func (ActivityLogPathSelectorEventsRegionalServerMessageData) FieldPath 

func (ActivityLogPathSelectorEventsRegionalServerMessageData) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalServerMessageData) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalServerMessageData) WithArrayOfValues(values []*anypb.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalServerMessageData) WithValue 

func (s ActivityLogPathSelectorEventsRegionalServerMessageData) WithValue(value *anypb.Any) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalServerMessageRegionId 

type ActivityLogPathSelectorEventsRegionalServerMessageRegionId struct{}

func (ActivityLogPathSelectorEventsRegionalServerMessageRegionId) FieldPath 

func (ActivityLogPathSelectorEventsRegionalServerMessageRegionId) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalServerMessageRegionId) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalServerMessageRegionId) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalServerMessageRegionId) WithValue 

func (s ActivityLogPathSelectorEventsRegionalServerMessageRegionId) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsRegionalServerMessageTime 

type ActivityLogPathSelectorEventsRegionalServerMessageTime struct{}

func (ActivityLogPathSelectorEventsRegionalServerMessageTime) FieldPath 

func (ActivityLogPathSelectorEventsRegionalServerMessageTime) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsRegionalServerMessageTime) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsRegionalServerMessageTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsRegionalServerMessageTime) WithValue 

func (s ActivityLogPathSelectorEventsRegionalServerMessageTime) WithValue(value *timestamppb.Timestamp) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsServerMessage 

type ActivityLogPathSelectorEventsServerMessage struct{}

func (ActivityLogPathSelectorEventsServerMessage) Data 

func (ActivityLogPathSelectorEventsServerMessage) Data() ActivityLogPathSelectorEventsServerMessageData

func (ActivityLogPathSelectorEventsServerMessage) FieldPath 

func (ActivityLogPathSelectorEventsServerMessage) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsServerMessage) Time 

func (ActivityLogPathSelectorEventsServerMessage) Time() ActivityLogPathSelectorEventsServerMessageTime

func (ActivityLogPathSelectorEventsServerMessage) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsServerMessage) WithArrayOfValues(values []*ActivityLog_Event_ServerMsgEvent) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsServerMessage) WithValue 

func (s ActivityLogPathSelectorEventsServerMessage) WithValue(value *ActivityLog_Event_ServerMsgEvent) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsServerMessageData 

type ActivityLogPathSelectorEventsServerMessageData struct{}

func (ActivityLogPathSelectorEventsServerMessageData) FieldPath 

func (ActivityLogPathSelectorEventsServerMessageData) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsServerMessageData) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsServerMessageData) WithArrayOfValues(values []*anypb.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsServerMessageData) WithValue 

func (s ActivityLogPathSelectorEventsServerMessageData) WithValue(value *anypb.Any) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorEventsServerMessageTime 

type ActivityLogPathSelectorEventsServerMessageTime struct{}

func (ActivityLogPathSelectorEventsServerMessageTime) FieldPath 

func (ActivityLogPathSelectorEventsServerMessageTime) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsServerMessageTime) WithArrayOfValues 

func (s ActivityLogPathSelectorEventsServerMessageTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsServerMessageTime) WithValue 

func (s ActivityLogPathSelectorEventsServerMessageTime) WithValue(value *timestamppb.Timestamp) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorLabels 

type ActivityLogPathSelectorLabels struct{}

func (ActivityLogPathSelectorLabels) FieldPath 

func (ActivityLogPathSelectorLabels) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorLabels) WithArrayOfValues 

func (s ActivityLogPathSelectorLabels) WithArrayOfValues(values []map[string]string) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorLabels) WithKey 

func (ActivityLogPathSelectorLabels) WithKey(key string) ActivityLogMapPathSelectorLabels

func (ActivityLogPathSelectorLabels) WithValue 

func (s ActivityLogPathSelectorLabels) WithValue(value map[string]string) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorMethod 

type ActivityLogPathSelectorMethod struct{}

func (ActivityLogPathSelectorMethod) FieldPath 

func (ActivityLogPathSelectorMethod) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorMethod) Type 

func (ActivityLogPathSelectorMethod) Type() ActivityLogPathSelectorMethodType

func (ActivityLogPathSelectorMethod) Version 

func (ActivityLogPathSelectorMethod) Version() ActivityLogPathSelectorMethodVersion

func (ActivityLogPathSelectorMethod) WithArrayOfValues 

func (s ActivityLogPathSelectorMethod) WithArrayOfValues(values []*ActivityLog_Method) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorMethod) WithSubArrayItemValue 

func (s ActivityLogPathSelectorMethod) WithSubArrayItemValue(subPathArrayItemValue ActivityLogMethod_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorMethod) WithSubArrayOfValues 

func (s ActivityLogPathSelectorMethod) WithSubArrayOfValues(subPathArrayOfValues ActivityLogMethod_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorMethod) WithSubPath 

func (ActivityLogPathSelectorMethod) WithSubPath(subPath ActivityLogMethod_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorMethod) WithSubValue 

func (s ActivityLogPathSelectorMethod) WithSubValue(subPathValue ActivityLogMethod_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorMethod) WithValue 

func (s ActivityLogPathSelectorMethod) WithValue(value *ActivityLog_Method) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorMethodType 

type ActivityLogPathSelectorMethodType struct{}

func (ActivityLogPathSelectorMethodType) FieldPath 

func (ActivityLogPathSelectorMethodType) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorMethodType) WithArrayOfValues 

func (s ActivityLogPathSelectorMethodType) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorMethodType) WithValue 

func (s ActivityLogPathSelectorMethodType) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorMethodVersion 

type ActivityLogPathSelectorMethodVersion struct{}

func (ActivityLogPathSelectorMethodVersion) FieldPath 

func (ActivityLogPathSelectorMethodVersion) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorMethodVersion) WithArrayOfValues 

func (s ActivityLogPathSelectorMethodVersion) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorMethodVersion) WithValue 

func (s ActivityLogPathSelectorMethodVersion) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorName 

type ActivityLogPathSelectorName struct{}

func (ActivityLogPathSelectorName) FieldPath 

func (ActivityLogPathSelectorName) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorName) WithArrayOfValues 

func (s ActivityLogPathSelectorName) WithArrayOfValues(values []*Name) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorName) WithValue 

func (s ActivityLogPathSelectorName) WithValue(value *Name) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorRequestId 

type ActivityLogPathSelectorRequestId struct{}

func (ActivityLogPathSelectorRequestId) FieldPath 

func (ActivityLogPathSelectorRequestId) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorRequestId) WithArrayOfValues 

func (s ActivityLogPathSelectorRequestId) WithArrayOfValues(values []uint64) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorRequestId) WithValue 

func (s ActivityLogPathSelectorRequestId) WithValue(value uint64) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorRequestMetadata 

type ActivityLogPathSelectorRequestMetadata struct{}

func (ActivityLogPathSelectorRequestMetadata) FieldPath 

func (ActivityLogPathSelectorRequestMetadata) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorRequestMetadata) IpAddress 

func (ActivityLogPathSelectorRequestMetadata) IpAddress() ActivityLogPathSelectorRequestMetadataIpAddress

func (ActivityLogPathSelectorRequestMetadata) UserAgent 

func (ActivityLogPathSelectorRequestMetadata) UserAgent() ActivityLogPathSelectorRequestMetadataUserAgent

func (ActivityLogPathSelectorRequestMetadata) WithArrayOfValues 

func (s ActivityLogPathSelectorRequestMetadata) WithArrayOfValues(values []*ActivityLog_RequestMetadata) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorRequestMetadata) WithSubArrayItemValue 

func (s ActivityLogPathSelectorRequestMetadata) WithSubArrayItemValue(subPathArrayItemValue ActivityLogRequestMetadata_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorRequestMetadata) WithSubArrayOfValues 

func (s ActivityLogPathSelectorRequestMetadata) WithSubArrayOfValues(subPathArrayOfValues ActivityLogRequestMetadata_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorRequestMetadata) WithSubPath 

func (ActivityLogPathSelectorRequestMetadata) WithSubPath(subPath ActivityLogRequestMetadata_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorRequestMetadata) WithSubValue 

func (s ActivityLogPathSelectorRequestMetadata) WithSubValue(subPathValue ActivityLogRequestMetadata_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorRequestMetadata) WithValue 

func (s ActivityLogPathSelectorRequestMetadata) WithValue(value *ActivityLog_RequestMetadata) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorRequestMetadataIpAddress 

type ActivityLogPathSelectorRequestMetadataIpAddress struct{}

func (ActivityLogPathSelectorRequestMetadataIpAddress) FieldPath 

func (ActivityLogPathSelectorRequestMetadataIpAddress) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorRequestMetadataIpAddress) WithArrayOfValues 

func (s ActivityLogPathSelectorRequestMetadataIpAddress) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorRequestMetadataIpAddress) WithValue 

func (s ActivityLogPathSelectorRequestMetadataIpAddress) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorRequestMetadataUserAgent 

type ActivityLogPathSelectorRequestMetadataUserAgent struct{}

func (ActivityLogPathSelectorRequestMetadataUserAgent) FieldPath 

func (ActivityLogPathSelectorRequestMetadataUserAgent) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorRequestMetadataUserAgent) WithArrayOfValues 

func (s ActivityLogPathSelectorRequestMetadataUserAgent) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorRequestMetadataUserAgent) WithValue 

func (s ActivityLogPathSelectorRequestMetadataUserAgent) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorRequestRouting 

type ActivityLogPathSelectorRequestRouting struct{}

func (ActivityLogPathSelectorRequestRouting) DestRegions 

func (ActivityLogPathSelectorRequestRouting) DestRegions() ActivityLogPathSelectorRequestRoutingDestRegions

func (ActivityLogPathSelectorRequestRouting) FieldPath 

func (ActivityLogPathSelectorRequestRouting) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorRequestRouting) ViaRegion 

func (ActivityLogPathSelectorRequestRouting) ViaRegion() ActivityLogPathSelectorRequestRoutingViaRegion

func (ActivityLogPathSelectorRequestRouting) WithArrayOfValues 

func (s ActivityLogPathSelectorRequestRouting) WithArrayOfValues(values []*ActivityLog_RequestRouting) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorRequestRouting) WithSubArrayItemValue 

func (s ActivityLogPathSelectorRequestRouting) WithSubArrayItemValue(subPathArrayItemValue ActivityLogRequestRouting_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorRequestRouting) WithSubArrayOfValues 

func (s ActivityLogPathSelectorRequestRouting) WithSubArrayOfValues(subPathArrayOfValues ActivityLogRequestRouting_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorRequestRouting) WithSubPath 

func (ActivityLogPathSelectorRequestRouting) WithSubPath(subPath ActivityLogRequestRouting_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorRequestRouting) WithSubValue 

func (s ActivityLogPathSelectorRequestRouting) WithSubValue(subPathValue ActivityLogRequestRouting_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorRequestRouting) WithValue 

func (s ActivityLogPathSelectorRequestRouting) WithValue(value *ActivityLog_RequestRouting) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorRequestRoutingDestRegions 

type ActivityLogPathSelectorRequestRoutingDestRegions struct{}

func (ActivityLogPathSelectorRequestRoutingDestRegions) FieldPath 

func (ActivityLogPathSelectorRequestRoutingDestRegions) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorRequestRoutingDestRegions) WithArrayOfValues 

func (s ActivityLogPathSelectorRequestRoutingDestRegions) WithArrayOfValues(values [][]string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorRequestRoutingDestRegions) WithItemValue 

func (s ActivityLogPathSelectorRequestRoutingDestRegions) WithItemValue(value string) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorRequestRoutingDestRegions) WithValue 

func (s ActivityLogPathSelectorRequestRoutingDestRegions) WithValue(value []string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorRequestRoutingViaRegion 

type ActivityLogPathSelectorRequestRoutingViaRegion struct{}

func (ActivityLogPathSelectorRequestRoutingViaRegion) FieldPath 

func (ActivityLogPathSelectorRequestRoutingViaRegion) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorRequestRoutingViaRegion) WithArrayOfValues 

func (s ActivityLogPathSelectorRequestRoutingViaRegion) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorRequestRoutingViaRegion) WithValue 

func (s ActivityLogPathSelectorRequestRoutingViaRegion) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorResource 

type ActivityLogPathSelectorResource struct{}

func (ActivityLogPathSelectorResource) Difference 

func (ActivityLogPathSelectorResource) Difference() ActivityLogPathSelectorResourceDifference

func (ActivityLogPathSelectorResource) FieldPath 

func (ActivityLogPathSelectorResource) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorResource) Name 

func (ActivityLogPathSelectorResource) Name() ActivityLogPathSelectorResourceName

func (ActivityLogPathSelectorResource) WithArrayOfValues 

func (s ActivityLogPathSelectorResource) WithArrayOfValues(values []*ActivityLog_Resource) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorResource) WithSubArrayItemValue 

func (s ActivityLogPathSelectorResource) WithSubArrayItemValue(subPathArrayItemValue ActivityLogResource_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorResource) WithSubArrayOfValues 

func (s ActivityLogPathSelectorResource) WithSubArrayOfValues(subPathArrayOfValues ActivityLogResource_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorResource) WithSubPath 

func (ActivityLogPathSelectorResource) WithSubPath(subPath ActivityLogResource_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResource) WithSubValue 

func (s ActivityLogPathSelectorResource) WithSubValue(subPathValue ActivityLogResource_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorResource) WithValue 

func (s ActivityLogPathSelectorResource) WithValue(value *ActivityLog_Resource) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorResourceDifference 

type ActivityLogPathSelectorResourceDifference struct{}

func (ActivityLogPathSelectorResourceDifference) After 

func (ActivityLogPathSelectorResourceDifference) After() ActivityLogPathSelectorResourceDifferenceAfter

func (ActivityLogPathSelectorResourceDifference) Before 

func (ActivityLogPathSelectorResourceDifference) Before() ActivityLogPathSelectorResourceDifferenceBefore

func (ActivityLogPathSelectorResourceDifference) FieldPath 

func (ActivityLogPathSelectorResourceDifference) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceDifference) Fields 

func (ActivityLogPathSelectorResourceDifference) Fields() ActivityLogPathSelectorResourceDifferenceFields

func (ActivityLogPathSelectorResourceDifference) WithArrayOfValues 

func (s ActivityLogPathSelectorResourceDifference) WithArrayOfValues(values []*ActivityLog_Resource_Difference) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorResourceDifference) WithValue 

func (s ActivityLogPathSelectorResourceDifference) WithValue(value *ActivityLog_Resource_Difference) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorResourceDifferenceAfter 

type ActivityLogPathSelectorResourceDifferenceAfter struct{}

func (ActivityLogPathSelectorResourceDifferenceAfter) FieldPath 

func (ActivityLogPathSelectorResourceDifferenceAfter) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceDifferenceAfter) WithArrayOfValues 

func (s ActivityLogPathSelectorResourceDifferenceAfter) WithArrayOfValues(values []*anypb.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorResourceDifferenceAfter) WithValue 

func (s ActivityLogPathSelectorResourceDifferenceAfter) WithValue(value *anypb.Any) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorResourceDifferenceBefore 

type ActivityLogPathSelectorResourceDifferenceBefore struct{}

func (ActivityLogPathSelectorResourceDifferenceBefore) FieldPath 

func (ActivityLogPathSelectorResourceDifferenceBefore) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceDifferenceBefore) WithArrayOfValues 

func (s ActivityLogPathSelectorResourceDifferenceBefore) WithArrayOfValues(values []*anypb.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorResourceDifferenceBefore) WithValue 

func (s ActivityLogPathSelectorResourceDifferenceBefore) WithValue(value *anypb.Any) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorResourceDifferenceFields 

type ActivityLogPathSelectorResourceDifferenceFields struct{}

func (ActivityLogPathSelectorResourceDifferenceFields) FieldPath 

func (ActivityLogPathSelectorResourceDifferenceFields) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceDifferenceFields) WithArrayOfValues 

func (s ActivityLogPathSelectorResourceDifferenceFields) WithArrayOfValues(values []*fieldmaskpb.FieldMask) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorResourceDifferenceFields) WithValue 

func (s ActivityLogPathSelectorResourceDifferenceFields) WithValue(value *fieldmaskpb.FieldMask) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorResourceName 

type ActivityLogPathSelectorResourceName struct{}

func (ActivityLogPathSelectorResourceName) FieldPath 

func (ActivityLogPathSelectorResourceName) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceName) WithArrayOfValues 

func (s ActivityLogPathSelectorResourceName) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorResourceName) WithValue 

func (s ActivityLogPathSelectorResourceName) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorScope 

type ActivityLogPathSelectorScope struct{}

func (ActivityLogPathSelectorScope) FieldPath 

func (ActivityLogPathSelectorScope) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorScope) WithArrayOfValues 

func (s ActivityLogPathSelectorScope) WithArrayOfValues(values []string) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorScope) WithValue 

func (s ActivityLogPathSelectorScope) WithValue(value string) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorService 

type ActivityLogPathSelectorService struct{}

func (ActivityLogPathSelectorService) FieldPath 

func (ActivityLogPathSelectorService) FieldPath() *ActivityLog_FieldTerminalPath

func (ActivityLogPathSelectorService) Name 

func (ActivityLogPathSelectorService) Name() ActivityLogPathSelectorServiceName

func (ActivityLogPathSelectorService) RegionId 

func (ActivityLogPathSelectorService) RegionId() ActivityLogPathSelectorServiceRegionId

func (ActivityLogPathSelectorService) WithArrayOfValues 

func (s ActivityLogPathSelectorService) WithArrayOfValues(values []*common.ServiceData) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorService) WithSubArrayItemValue 

func (s ActivityLogPathSelectorService) WithSubArrayItemValue(subPathArrayItemValue common.ServiceData_FieldPathArrayItemValue) *ActivityLog_FieldSubPathArrayItemValue

func (ActivityLogPathSelectorService) WithSubArrayOfValues 

func (s ActivityLogPathSelectorService) WithSubArrayOfValues(subPathArrayOfValues common.ServiceData_FieldPathArrayOfValues) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorService) WithSubPath 

func (ActivityLogPathSelectorService) WithSubPath(subPath common.ServiceData_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorService) WithSubValue 

func (s ActivityLogPathSelectorService) WithSubValue(subPathValue common.ServiceData_FieldPathValue) *ActivityLog_FieldSubPathValue

func (ActivityLogPathSelectorService) WithValue 

func (s ActivityLogPathSelectorService) WithValue(value *common.ServiceData) *ActivityLog_FieldTerminalPathValue

type ActivityLogPathSelectorServiceName 

type ActivityLogPathSelectorServiceName struct{}

func (ActivityLogPathSelectorServiceName) FieldPath 

func (ActivityLogPathSelectorServiceName) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorServiceName) WithArrayOfValues 

func (s ActivityLogPathSelectorServiceName) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorServiceName) WithValue 

func (s ActivityLogPathSelectorServiceName) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogPathSelectorServiceRegionId 

type ActivityLogPathSelectorServiceRegionId struct{}

func (ActivityLogPathSelectorServiceRegionId) FieldPath 

func (ActivityLogPathSelectorServiceRegionId) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorServiceRegionId) WithArrayOfValues 

func (s ActivityLogPathSelectorServiceRegionId) WithArrayOfValues(values []string) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorServiceRegionId) WithValue 

func (s ActivityLogPathSelectorServiceRegionId) WithValue(value string) *ActivityLog_FieldSubPathValue

type ActivityLogReferenceList 

type ActivityLogReferenceList []*Reference

func (ActivityLogReferenceList) Append 

func (l ActivityLogReferenceList) Append(ref gotenresource.Reference) gotenresource.ReferenceList

func (ActivityLogReferenceList) AppendList 

func (l ActivityLogReferenceList) AppendList(list gotenresource.ReferenceList) gotenresource.ReferenceList

func (ActivityLogReferenceList) At 

func (l ActivityLogReferenceList) At(idx int) gotenresource.Reference

func (ActivityLogReferenceList) Length 

func (l ActivityLogReferenceList) Length() int

func (ActivityLogReferenceList) Set 

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

func (ActivityLogReferenceList) Slice 

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

type ActivityLogRequestMetadataFieldPathBuilder 

type ActivityLogRequestMetadataFieldPathBuilder struct{}

func NewActivityLogRequestMetadataFieldPathBuilder 

func NewActivityLogRequestMetadataFieldPathBuilder() ActivityLogRequestMetadataFieldPathBuilder

func (ActivityLogRequestMetadataFieldPathBuilder) IpAddress 

func (ActivityLogRequestMetadataFieldPathBuilder) IpAddress() ActivityLog_RequestMetadataPathSelectorIpAddress

func (ActivityLogRequestMetadataFieldPathBuilder) UserAgent 

func (ActivityLogRequestMetadataFieldPathBuilder) UserAgent() ActivityLog_RequestMetadataPathSelectorUserAgent

type ActivityLogRequestMetadata_FieldPath 

type ActivityLogRequestMetadata_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogRequestMetadata_FieldPathSelector
	Get(source *ActivityLog_RequestMetadata) []interface{}
	GetSingle(source *ActivityLog_RequestMetadata) (interface{}, bool)
	ClearValue(item *ActivityLog_RequestMetadata)

	// Those methods build corresponding ActivityLogRequestMetadata_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogRequestMetadata_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogRequestMetadata_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogRequestMetadata_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogRequestMetadata_FieldPath 

func BuildActivityLogRequestMetadata_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogRequestMetadata_FieldPath, error)

func MustParseActivityLogRequestMetadata_FieldPath 

func MustParseActivityLogRequestMetadata_FieldPath(rawField string) ActivityLogRequestMetadata_FieldPath

func ParseActivityLogRequestMetadata_FieldPath 

func ParseActivityLogRequestMetadata_FieldPath(rawField string) (ActivityLogRequestMetadata_FieldPath, error)

type ActivityLogRequestMetadata_FieldPathArrayItemValue 

type ActivityLogRequestMetadata_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogRequestMetadata_FieldPath
	ContainsValue(*ActivityLog_RequestMetadata) bool
}

ActivityLogRequestMetadata_FieldPathArrayItemValue allows storing single item in Path-specific values for RequestMetadata according to their type Present only for array (repeated) types.

func MustParseActivityLogRequestMetadata_FieldPathArrayItemValue 

func MustParseActivityLogRequestMetadata_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogRequestMetadata_FieldPathArrayItemValue

func ParseActivityLogRequestMetadata_FieldPathArrayItemValue 

func ParseActivityLogRequestMetadata_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogRequestMetadata_FieldPathArrayItemValue, error)

ParseActivityLogRequestMetadata_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogRequestMetadata_FieldPathArrayOfValues 

type ActivityLogRequestMetadata_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogRequestMetadata_FieldPath
}

ActivityLogRequestMetadata_FieldPathArrayOfValues allows storing slice of values for RequestMetadata fields according to their type

func MustParseActivityLogRequestMetadata_FieldPathArrayOfValues 

func MustParseActivityLogRequestMetadata_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogRequestMetadata_FieldPathArrayOfValues

func ParseActivityLogRequestMetadata_FieldPathArrayOfValues 

func ParseActivityLogRequestMetadata_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogRequestMetadata_FieldPathArrayOfValues, error)

type ActivityLogRequestMetadata_FieldPathSelector 

type ActivityLogRequestMetadata_FieldPathSelector int32
const (
	ActivityLogRequestMetadata_FieldPathSelectorIpAddress ActivityLogRequestMetadata_FieldPathSelector = 0
	ActivityLogRequestMetadata_FieldPathSelectorUserAgent ActivityLogRequestMetadata_FieldPathSelector = 1
)

func (ActivityLogRequestMetadata_FieldPathSelector) String 

func (s ActivityLogRequestMetadata_FieldPathSelector) String() string

type ActivityLogRequestMetadata_FieldPathValue 

type ActivityLogRequestMetadata_FieldPathValue interface {
	ActivityLogRequestMetadata_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_RequestMetadata)
	CompareWith(*ActivityLog_RequestMetadata) (cmp int, comparable bool)
}

ActivityLogRequestMetadata_FieldPathValue allows storing values for RequestMetadata fields according to their type

func MustParseActivityLogRequestMetadata_FieldPathValue 

func MustParseActivityLogRequestMetadata_FieldPathValue(pathStr, valueStr string) ActivityLogRequestMetadata_FieldPathValue

func ParseActivityLogRequestMetadata_FieldPathValue 

func ParseActivityLogRequestMetadata_FieldPathValue(pathStr, valueStr string) (ActivityLogRequestMetadata_FieldPathValue, error)

type ActivityLogRequestMetadata_FieldTerminalPath 

type ActivityLogRequestMetadata_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogRequestMetadata_FieldTerminalPath) ClearValue 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) ClearValue(item *ActivityLog_RequestMetadata)

func (*ActivityLogRequestMetadata_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogRequestMetadata_FieldTerminalPath) Get 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) Get(source *ActivityLog_RequestMetadata) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_RequestMetadata

func (*ActivityLogRequestMetadata_FieldTerminalPath) GetDefault 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogRequestMetadata_FieldTerminalPath) GetRaw 

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

func (*ActivityLogRequestMetadata_FieldTerminalPath) GetSingle 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) GetSingle(source *ActivityLog_RequestMetadata) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_RequestMetadata

func (*ActivityLogRequestMetadata_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogRequestMetadata_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogRequestMetadata_FieldTerminalPath) JSONString 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogRequestMetadata_FieldTerminalPath) Selector 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) Selector() ActivityLogRequestMetadata_FieldPathSelector

func (*ActivityLogRequestMetadata_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogRequestMetadata_FieldTerminalPath) String 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogRequestMetadata_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogRequestMetadata_FieldPathArrayItemValue

func (*ActivityLogRequestMetadata_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogRequestMetadata_FieldPathArrayOfValues

func (*ActivityLogRequestMetadata_FieldTerminalPath) WithIValue 

func (fp *ActivityLogRequestMetadata_FieldTerminalPath) WithIValue(value interface{}) ActivityLogRequestMetadata_FieldPathValue

func (*ActivityLogRequestMetadata_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogRequestMetadata_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogRequestMetadata_FieldTerminalPath) WithRawIValue 

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

type ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue 

type ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue struct {
	ActivityLogRequestMetadata_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_RequestMetadata) bool

Contains returns a boolean indicating if value that is being held is present in given 'RequestMetadata'

func (*ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_RequestMetadata as interface{}

func (*ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_RequestMetadata) (interface{}, bool)

func (*ActivityLogRequestMetadata_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues 

type ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues struct {
	ActivityLogRequestMetadata_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) AsIpAddressArrayOfValues 

func (fpaov *ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) AsIpAddressArrayOfValues() ([]string, bool)

func (*ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) AsUserAgentArrayOfValues 

func (fpaov *ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) AsUserAgentArrayOfValues() ([]string, bool)

func (*ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogRequestMetadata_FieldTerminalPathValue 

type ActivityLogRequestMetadata_FieldTerminalPathValue struct {
	ActivityLogRequestMetadata_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogRequestMetadata_FieldTerminalPathValue) AsIpAddressValue 

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) AsIpAddressValue() (string, bool)

func (*ActivityLogRequestMetadata_FieldTerminalPathValue) AsUserAgentValue 

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) AsUserAgentValue() (string, bool)

func (*ActivityLogRequestMetadata_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) CompareWith(source *ActivityLog_RequestMetadata) (int, bool)

CompareWith compares value in the 'ActivityLogRequestMetadata_FieldTerminalPathValue' with the value under path in 'ActivityLog_RequestMetadata'.

func (*ActivityLogRequestMetadata_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogRequestMetadata_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'RequestMetadata' as interface{}

func (*ActivityLogRequestMetadata_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) SetTo(target **ActivityLog_RequestMetadata)

SetTo stores value for selected field for object RequestMetadata

func (*ActivityLogRequestMetadata_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogRequestMetadata_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogRequestRoutingFieldPathBuilder 

type ActivityLogRequestRoutingFieldPathBuilder struct{}

func NewActivityLogRequestRoutingFieldPathBuilder 

func NewActivityLogRequestRoutingFieldPathBuilder() ActivityLogRequestRoutingFieldPathBuilder

func (ActivityLogRequestRoutingFieldPathBuilder) DestRegions 

func (ActivityLogRequestRoutingFieldPathBuilder) DestRegions() ActivityLog_RequestRoutingPathSelectorDestRegions

func (ActivityLogRequestRoutingFieldPathBuilder) ViaRegion 

func (ActivityLogRequestRoutingFieldPathBuilder) ViaRegion() ActivityLog_RequestRoutingPathSelectorViaRegion

type ActivityLogRequestRouting_FieldPath 

type ActivityLogRequestRouting_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogRequestRouting_FieldPathSelector
	Get(source *ActivityLog_RequestRouting) []interface{}
	GetSingle(source *ActivityLog_RequestRouting) (interface{}, bool)
	ClearValue(item *ActivityLog_RequestRouting)

	// Those methods build corresponding ActivityLogRequestRouting_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogRequestRouting_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogRequestRouting_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogRequestRouting_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogRequestRouting_FieldPath 

func BuildActivityLogRequestRouting_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogRequestRouting_FieldPath, error)

func MustParseActivityLogRequestRouting_FieldPath 

func MustParseActivityLogRequestRouting_FieldPath(rawField string) ActivityLogRequestRouting_FieldPath

func ParseActivityLogRequestRouting_FieldPath 

func ParseActivityLogRequestRouting_FieldPath(rawField string) (ActivityLogRequestRouting_FieldPath, error)

type ActivityLogRequestRouting_FieldPathArrayItemValue 

type ActivityLogRequestRouting_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogRequestRouting_FieldPath
	ContainsValue(*ActivityLog_RequestRouting) bool
}

ActivityLogRequestRouting_FieldPathArrayItemValue allows storing single item in Path-specific values for RequestRouting according to their type Present only for array (repeated) types.

func MustParseActivityLogRequestRouting_FieldPathArrayItemValue 

func MustParseActivityLogRequestRouting_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogRequestRouting_FieldPathArrayItemValue

func ParseActivityLogRequestRouting_FieldPathArrayItemValue 

func ParseActivityLogRequestRouting_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogRequestRouting_FieldPathArrayItemValue, error)

ParseActivityLogRequestRouting_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogRequestRouting_FieldPathArrayOfValues 

type ActivityLogRequestRouting_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogRequestRouting_FieldPath
}

ActivityLogRequestRouting_FieldPathArrayOfValues allows storing slice of values for RequestRouting fields according to their type

func MustParseActivityLogRequestRouting_FieldPathArrayOfValues 

func MustParseActivityLogRequestRouting_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogRequestRouting_FieldPathArrayOfValues

func ParseActivityLogRequestRouting_FieldPathArrayOfValues 

func ParseActivityLogRequestRouting_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogRequestRouting_FieldPathArrayOfValues, error)

type ActivityLogRequestRouting_FieldPathSelector 

type ActivityLogRequestRouting_FieldPathSelector int32
const (
	ActivityLogRequestRouting_FieldPathSelectorViaRegion   ActivityLogRequestRouting_FieldPathSelector = 0
	ActivityLogRequestRouting_FieldPathSelectorDestRegions ActivityLogRequestRouting_FieldPathSelector = 1
)

func (ActivityLogRequestRouting_FieldPathSelector) String 

func (s ActivityLogRequestRouting_FieldPathSelector) String() string

type ActivityLogRequestRouting_FieldPathValue 

type ActivityLogRequestRouting_FieldPathValue interface {
	ActivityLogRequestRouting_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_RequestRouting)
	CompareWith(*ActivityLog_RequestRouting) (cmp int, comparable bool)
}

ActivityLogRequestRouting_FieldPathValue allows storing values for RequestRouting fields according to their type

func MustParseActivityLogRequestRouting_FieldPathValue 

func MustParseActivityLogRequestRouting_FieldPathValue(pathStr, valueStr string) ActivityLogRequestRouting_FieldPathValue

func ParseActivityLogRequestRouting_FieldPathValue 

func ParseActivityLogRequestRouting_FieldPathValue(pathStr, valueStr string) (ActivityLogRequestRouting_FieldPathValue, error)

type ActivityLogRequestRouting_FieldTerminalPath 

type ActivityLogRequestRouting_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogRequestRouting_FieldTerminalPath) ClearValue 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) ClearValue(item *ActivityLog_RequestRouting)

func (*ActivityLogRequestRouting_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogRequestRouting_FieldTerminalPath) Get 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) Get(source *ActivityLog_RequestRouting) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_RequestRouting

func (*ActivityLogRequestRouting_FieldTerminalPath) GetDefault 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogRequestRouting_FieldTerminalPath) GetRaw 

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

func (*ActivityLogRequestRouting_FieldTerminalPath) GetSingle 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) GetSingle(source *ActivityLog_RequestRouting) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_RequestRouting

func (*ActivityLogRequestRouting_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogRequestRouting_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogRequestRouting_FieldTerminalPath) JSONString 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogRequestRouting_FieldTerminalPath) Selector 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) Selector() ActivityLogRequestRouting_FieldPathSelector

func (*ActivityLogRequestRouting_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogRequestRouting_FieldTerminalPath) String 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogRequestRouting_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogRequestRouting_FieldPathArrayItemValue

func (*ActivityLogRequestRouting_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogRequestRouting_FieldPathArrayOfValues

func (*ActivityLogRequestRouting_FieldTerminalPath) WithIValue 

func (fp *ActivityLogRequestRouting_FieldTerminalPath) WithIValue(value interface{}) ActivityLogRequestRouting_FieldPathValue

func (*ActivityLogRequestRouting_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogRequestRouting_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogRequestRouting_FieldTerminalPath) WithRawIValue 

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

type ActivityLogRequestRouting_FieldTerminalPathArrayItemValue 

type ActivityLogRequestRouting_FieldTerminalPathArrayItemValue struct {
	ActivityLogRequestRouting_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) AsDestRegionsItemValue 

func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) AsDestRegionsItemValue() (string, bool)

func (*ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_RequestRouting) bool

Contains returns a boolean indicating if value that is being held is present in given 'RequestRouting'

func (*ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_RequestRouting as interface{}

func (*ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_RequestRouting) (interface{}, bool)

func (*ActivityLogRequestRouting_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogRequestRouting_FieldTerminalPathArrayOfValues 

type ActivityLogRequestRouting_FieldTerminalPathArrayOfValues struct {
	ActivityLogRequestRouting_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) AsDestRegionsArrayOfValues 

func (fpaov *ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) AsDestRegionsArrayOfValues() ([][]string, bool)

func (*ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) AsViaRegionArrayOfValues 

func (fpaov *ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) AsViaRegionArrayOfValues() ([]string, bool)

func (*ActivityLogRequestRouting_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogRequestRouting_FieldTerminalPathValue 

type ActivityLogRequestRouting_FieldTerminalPathValue struct {
	ActivityLogRequestRouting_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogRequestRouting_FieldTerminalPathValue) AsDestRegionsValue 

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) AsDestRegionsValue() ([]string, bool)

func (*ActivityLogRequestRouting_FieldTerminalPathValue) AsViaRegionValue 

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) AsViaRegionValue() (string, bool)

func (*ActivityLogRequestRouting_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) CompareWith(source *ActivityLog_RequestRouting) (int, bool)

CompareWith compares value in the 'ActivityLogRequestRouting_FieldTerminalPathValue' with the value under path in 'ActivityLog_RequestRouting'.

func (*ActivityLogRequestRouting_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogRequestRouting_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'RequestRouting' as interface{}

func (*ActivityLogRequestRouting_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) SetTo(target **ActivityLog_RequestRouting)

SetTo stores value for selected field for object RequestRouting

func (*ActivityLogRequestRouting_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogRequestRouting_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogResourceDifferenceFieldPathBuilder 

type ActivityLogResourceDifferenceFieldPathBuilder struct{}

func NewActivityLogResourceDifferenceFieldPathBuilder 

func NewActivityLogResourceDifferenceFieldPathBuilder() ActivityLogResourceDifferenceFieldPathBuilder

func (ActivityLogResourceDifferenceFieldPathBuilder) After 

func (ActivityLogResourceDifferenceFieldPathBuilder) After() ActivityLog_Resource_DifferencePathSelectorAfter

func (ActivityLogResourceDifferenceFieldPathBuilder) Before 

func (ActivityLogResourceDifferenceFieldPathBuilder) Before() ActivityLog_Resource_DifferencePathSelectorBefore

func (ActivityLogResourceDifferenceFieldPathBuilder) Fields 

func (ActivityLogResourceDifferenceFieldPathBuilder) Fields() ActivityLog_Resource_DifferencePathSelectorFields

type ActivityLogResourceDifference_FieldPath 

type ActivityLogResourceDifference_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogResourceDifference_FieldPathSelector
	Get(source *ActivityLog_Resource_Difference) []interface{}
	GetSingle(source *ActivityLog_Resource_Difference) (interface{}, bool)
	ClearValue(item *ActivityLog_Resource_Difference)

	// Those methods build corresponding ActivityLogResourceDifference_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogResourceDifference_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogResourceDifference_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogResourceDifference_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogResourceDifference_FieldPath 

func BuildActivityLogResourceDifference_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogResourceDifference_FieldPath, error)

func MustParseActivityLogResourceDifference_FieldPath 

func MustParseActivityLogResourceDifference_FieldPath(rawField string) ActivityLogResourceDifference_FieldPath

func ParseActivityLogResourceDifference_FieldPath 

func ParseActivityLogResourceDifference_FieldPath(rawField string) (ActivityLogResourceDifference_FieldPath, error)

type ActivityLogResourceDifference_FieldPathArrayItemValue 

type ActivityLogResourceDifference_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogResourceDifference_FieldPath
	ContainsValue(*ActivityLog_Resource_Difference) bool
}

ActivityLogResourceDifference_FieldPathArrayItemValue allows storing single item in Path-specific values for Difference according to their type Present only for array (repeated) types.

func MustParseActivityLogResourceDifference_FieldPathArrayItemValue 

func MustParseActivityLogResourceDifference_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogResourceDifference_FieldPathArrayItemValue

func ParseActivityLogResourceDifference_FieldPathArrayItemValue 

func ParseActivityLogResourceDifference_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogResourceDifference_FieldPathArrayItemValue, error)

ParseActivityLogResourceDifference_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogResourceDifference_FieldPathArrayOfValues 

type ActivityLogResourceDifference_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogResourceDifference_FieldPath
}

ActivityLogResourceDifference_FieldPathArrayOfValues allows storing slice of values for Difference fields according to their type

func MustParseActivityLogResourceDifference_FieldPathArrayOfValues 

func MustParseActivityLogResourceDifference_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogResourceDifference_FieldPathArrayOfValues

func ParseActivityLogResourceDifference_FieldPathArrayOfValues 

func ParseActivityLogResourceDifference_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogResourceDifference_FieldPathArrayOfValues, error)

type ActivityLogResourceDifference_FieldPathSelector 

type ActivityLogResourceDifference_FieldPathSelector int32
const (
	ActivityLogResourceDifference_FieldPathSelectorFields ActivityLogResourceDifference_FieldPathSelector = 0
	ActivityLogResourceDifference_FieldPathSelectorBefore ActivityLogResourceDifference_FieldPathSelector = 1
	ActivityLogResourceDifference_FieldPathSelectorAfter  ActivityLogResourceDifference_FieldPathSelector = 2
)

func (ActivityLogResourceDifference_FieldPathSelector) String 

func (s ActivityLogResourceDifference_FieldPathSelector) String() string

type ActivityLogResourceDifference_FieldPathValue 

type ActivityLogResourceDifference_FieldPathValue interface {
	ActivityLogResourceDifference_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Resource_Difference)
	CompareWith(*ActivityLog_Resource_Difference) (cmp int, comparable bool)
}

ActivityLogResourceDifference_FieldPathValue allows storing values for Difference fields according to their type

func MustParseActivityLogResourceDifference_FieldPathValue 

func MustParseActivityLogResourceDifference_FieldPathValue(pathStr, valueStr string) ActivityLogResourceDifference_FieldPathValue

func ParseActivityLogResourceDifference_FieldPathValue 

func ParseActivityLogResourceDifference_FieldPathValue(pathStr, valueStr string) (ActivityLogResourceDifference_FieldPathValue, error)

type ActivityLogResourceDifference_FieldTerminalPath 

type ActivityLogResourceDifference_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogResourceDifference_FieldTerminalPath) ClearValue 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) ClearValue(item *ActivityLog_Resource_Difference)

func (*ActivityLogResourceDifference_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogResourceDifference_FieldTerminalPath) Get 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) Get(source *ActivityLog_Resource_Difference) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Resource_Difference

func (*ActivityLogResourceDifference_FieldTerminalPath) GetDefault 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogResourceDifference_FieldTerminalPath) GetRaw 

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

func (*ActivityLogResourceDifference_FieldTerminalPath) GetSingle 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) GetSingle(source *ActivityLog_Resource_Difference) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Resource_Difference

func (*ActivityLogResourceDifference_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogResourceDifference_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogResourceDifference_FieldTerminalPath) JSONString 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogResourceDifference_FieldTerminalPath) Selector 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) Selector() ActivityLogResourceDifference_FieldPathSelector

func (*ActivityLogResourceDifference_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogResourceDifference_FieldTerminalPath) String 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogResourceDifference_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogResourceDifference_FieldPathArrayItemValue

func (*ActivityLogResourceDifference_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogResourceDifference_FieldPathArrayOfValues

func (*ActivityLogResourceDifference_FieldTerminalPath) WithIValue 

func (fp *ActivityLogResourceDifference_FieldTerminalPath) WithIValue(value interface{}) ActivityLogResourceDifference_FieldPathValue

func (*ActivityLogResourceDifference_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogResourceDifference_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogResourceDifference_FieldTerminalPath) WithRawIValue 

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

type ActivityLogResourceDifference_FieldTerminalPathArrayItemValue 

type ActivityLogResourceDifference_FieldTerminalPathArrayItemValue struct {
	ActivityLogResourceDifference_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Resource_Difference) bool

Contains returns a boolean indicating if value that is being held is present in given 'Difference'

func (*ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Resource_Difference as interface{}

func (*ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Resource_Difference) (interface{}, bool)

func (*ActivityLogResourceDifference_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogResourceDifference_FieldTerminalPathArrayOfValues 

type ActivityLogResourceDifference_FieldTerminalPathArrayOfValues struct {
	ActivityLogResourceDifference_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsAfterArrayOfValues 

func (fpaov *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsAfterArrayOfValues() ([]*anypb.Any, bool)

func (*ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsBeforeArrayOfValues 

func (fpaov *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsBeforeArrayOfValues() ([]*anypb.Any, bool)

func (*ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsFieldsArrayOfValues 

func (fpaov *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) AsFieldsArrayOfValues() ([]*fieldmaskpb.FieldMask, bool)

func (*ActivityLogResourceDifference_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogResourceDifference_FieldTerminalPathValue 

type ActivityLogResourceDifference_FieldTerminalPathValue struct {
	ActivityLogResourceDifference_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogResourceDifference_FieldTerminalPathValue) AsAfterValue 

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) AsAfterValue() (*anypb.Any, bool)

func (*ActivityLogResourceDifference_FieldTerminalPathValue) AsBeforeValue 

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) AsBeforeValue() (*anypb.Any, bool)

func (*ActivityLogResourceDifference_FieldTerminalPathValue) AsFieldsValue 

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) AsFieldsValue() (*fieldmaskpb.FieldMask, bool)

func (*ActivityLogResourceDifference_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) CompareWith(source *ActivityLog_Resource_Difference) (int, bool)

CompareWith compares value in the 'ActivityLogResourceDifference_FieldTerminalPathValue' with the value under path in 'ActivityLog_Resource_Difference'.

func (*ActivityLogResourceDifference_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogResourceDifference_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'Difference' as interface{}

func (*ActivityLogResourceDifference_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) SetTo(target **ActivityLog_Resource_Difference)

SetTo stores value for selected field for object Difference

func (*ActivityLogResourceDifference_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogResourceDifference_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLogResourceFieldPathBuilder 

type ActivityLogResourceFieldPathBuilder struct{}

func NewActivityLogResourceFieldPathBuilder 

func NewActivityLogResourceFieldPathBuilder() ActivityLogResourceFieldPathBuilder

func (ActivityLogResourceFieldPathBuilder) Difference 

func (ActivityLogResourceFieldPathBuilder) Difference() ActivityLog_ResourcePathSelectorDifference

func (ActivityLogResourceFieldPathBuilder) Name 

func (ActivityLogResourceFieldPathBuilder) Name() ActivityLog_ResourcePathSelectorName

type ActivityLogResource_FieldPath 

type ActivityLogResource_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogResource_FieldPathSelector
	Get(source *ActivityLog_Resource) []interface{}
	GetSingle(source *ActivityLog_Resource) (interface{}, bool)
	ClearValue(item *ActivityLog_Resource)

	// Those methods build corresponding ActivityLogResource_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLogResource_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLogResource_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLogResource_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLogResource_FieldPath 

func BuildActivityLogResource_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogResource_FieldPath, error)

func MustParseActivityLogResource_FieldPath 

func MustParseActivityLogResource_FieldPath(rawField string) ActivityLogResource_FieldPath

func ParseActivityLogResource_FieldPath 

func ParseActivityLogResource_FieldPath(rawField string) (ActivityLogResource_FieldPath, error)

type ActivityLogResource_FieldPathArrayItemValue 

type ActivityLogResource_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogResource_FieldPath
	ContainsValue(*ActivityLog_Resource) bool
}

ActivityLogResource_FieldPathArrayItemValue allows storing single item in Path-specific values for Resource according to their type Present only for array (repeated) types.

func MustParseActivityLogResource_FieldPathArrayItemValue 

func MustParseActivityLogResource_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogResource_FieldPathArrayItemValue

func ParseActivityLogResource_FieldPathArrayItemValue 

func ParseActivityLogResource_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogResource_FieldPathArrayItemValue, error)

ParseActivityLogResource_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogResource_FieldPathArrayOfValues 

type ActivityLogResource_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogResource_FieldPath
}

ActivityLogResource_FieldPathArrayOfValues allows storing slice of values for Resource fields according to their type

func MustParseActivityLogResource_FieldPathArrayOfValues 

func MustParseActivityLogResource_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogResource_FieldPathArrayOfValues

func ParseActivityLogResource_FieldPathArrayOfValues 

func ParseActivityLogResource_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogResource_FieldPathArrayOfValues, error)

type ActivityLogResource_FieldPathSelector 

type ActivityLogResource_FieldPathSelector int32
const (
	ActivityLogResource_FieldPathSelectorName       ActivityLogResource_FieldPathSelector = 0
	ActivityLogResource_FieldPathSelectorDifference ActivityLogResource_FieldPathSelector = 1
)

func (ActivityLogResource_FieldPathSelector) String 

func (s ActivityLogResource_FieldPathSelector) String() string

type ActivityLogResource_FieldPathValue 

type ActivityLogResource_FieldPathValue interface {
	ActivityLogResource_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_Resource)
	CompareWith(*ActivityLog_Resource) (cmp int, comparable bool)
}

ActivityLogResource_FieldPathValue allows storing values for Resource fields according to their type

func MustParseActivityLogResource_FieldPathValue 

func MustParseActivityLogResource_FieldPathValue(pathStr, valueStr string) ActivityLogResource_FieldPathValue

func ParseActivityLogResource_FieldPathValue 

func ParseActivityLogResource_FieldPathValue(pathStr, valueStr string) (ActivityLogResource_FieldPathValue, error)

type ActivityLogResource_FieldSubPath 

type ActivityLogResource_FieldSubPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldSubPath) AsDifferenceSubPath 

func (fps *ActivityLogResource_FieldSubPath) AsDifferenceSubPath() (ActivityLogResourceDifference_FieldPath, bool)

func (*ActivityLogResource_FieldSubPath) ClearValue 

func (fps *ActivityLogResource_FieldSubPath) ClearValue(item *ActivityLog_Resource)

func (*ActivityLogResource_FieldSubPath) ClearValueRaw 

func (fps *ActivityLogResource_FieldSubPath) ClearValueRaw(item proto.Message)

func (*ActivityLogResource_FieldSubPath) Get 

func (fps *ActivityLogResource_FieldSubPath) Get(source *ActivityLog_Resource) (values []interface{})

Get returns all values pointed by selected field from source ActivityLog_Resource

func (*ActivityLogResource_FieldSubPath) GetDefault 

func (fps *ActivityLogResource_FieldSubPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogResource_FieldSubPath) GetRaw 

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

func (*ActivityLogResource_FieldSubPath) GetSingle 

func (fps *ActivityLogResource_FieldSubPath) GetSingle(source *ActivityLog_Resource) (interface{}, bool)

GetSingle returns value of selected field from source ActivityLog_Resource

func (*ActivityLogResource_FieldSubPath) GetSingleRaw 

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

func (*ActivityLogResource_FieldSubPath) IsLeaf 

func (fps *ActivityLogResource_FieldSubPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogResource_FieldSubPath) JSONString 

func (fps *ActivityLogResource_FieldSubPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogResource_FieldSubPath) Selector 

func (fps *ActivityLogResource_FieldSubPath) Selector() ActivityLogResource_FieldPathSelector

func (*ActivityLogResource_FieldSubPath) SplitIntoTerminalIPaths 

func (fps *ActivityLogResource_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogResource_FieldSubPath) String 

func (fps *ActivityLogResource_FieldSubPath) String() string

String returns path representation in proto convention

func (*ActivityLogResource_FieldSubPath) WithIArrayItemValue 

func (fps *ActivityLogResource_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogResource_FieldPathArrayItemValue

func (*ActivityLogResource_FieldSubPath) WithIArrayOfValues 

func (fps *ActivityLogResource_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogResource_FieldPathArrayOfValues

func (*ActivityLogResource_FieldSubPath) WithIValue 

func (fps *ActivityLogResource_FieldSubPath) WithIValue(value interface{}) ActivityLogResource_FieldPathValue

func (*ActivityLogResource_FieldSubPath) WithRawIArrayItemValue 

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

func (*ActivityLogResource_FieldSubPath) WithRawIArrayOfValues 

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

func (*ActivityLogResource_FieldSubPath) WithRawIValue 

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

type ActivityLogResource_FieldSubPathArrayItemValue 

type ActivityLogResource_FieldSubPathArrayItemValue struct {
	ActivityLogResource_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldSubPathArrayItemValue) AsDifferencePathItemValue 

func (fpaivs *ActivityLogResource_FieldSubPathArrayItemValue) AsDifferencePathItemValue() (ActivityLogResourceDifference_FieldPathArrayItemValue, bool)

func (*ActivityLogResource_FieldSubPathArrayItemValue) ContainsValue 

func (fpaivs *ActivityLogResource_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_Resource) bool

Contains returns a boolean indicating if value that is being held is present in given 'Resource'

func (*ActivityLogResource_FieldSubPathArrayItemValue) GetRawItemValue 

func (fpaivs *ActivityLogResource_FieldSubPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored array item value

type ActivityLogResource_FieldSubPathArrayOfValues 

type ActivityLogResource_FieldSubPathArrayOfValues struct {
	ActivityLogResource_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldSubPathArrayOfValues) AsDifferencePathArrayOfValues 

func (fpsaov *ActivityLogResource_FieldSubPathArrayOfValues) AsDifferencePathArrayOfValues() (ActivityLogResourceDifference_FieldPathArrayOfValues, bool)

func (*ActivityLogResource_FieldSubPathArrayOfValues) GetRawValues 

func (fpsaov *ActivityLogResource_FieldSubPathArrayOfValues) GetRawValues() []interface{}

type ActivityLogResource_FieldSubPathValue 

type ActivityLogResource_FieldSubPathValue struct {
	ActivityLogResource_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldSubPathValue) AsDifferencePathValue 

func (fpvs *ActivityLogResource_FieldSubPathValue) AsDifferencePathValue() (ActivityLogResourceDifference_FieldPathValue, bool)

func (*ActivityLogResource_FieldSubPathValue) CompareWith 

func (fpvs *ActivityLogResource_FieldSubPathValue) CompareWith(source *ActivityLog_Resource) (int, bool)

func (*ActivityLogResource_FieldSubPathValue) CompareWithRaw 

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

func (*ActivityLogResource_FieldSubPathValue) GetRawValue 

func (fpvs *ActivityLogResource_FieldSubPathValue) GetRawValue() interface{}

func (*ActivityLogResource_FieldSubPathValue) SetTo 

func (fpvs *ActivityLogResource_FieldSubPathValue) SetTo(target **ActivityLog_Resource)

func (*ActivityLogResource_FieldSubPathValue) SetToRaw 

func (fpvs *ActivityLogResource_FieldSubPathValue) SetToRaw(target proto.Message)

type ActivityLogResource_FieldTerminalPath 

type ActivityLogResource_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldTerminalPath) ClearValue 

func (fp *ActivityLogResource_FieldTerminalPath) ClearValue(item *ActivityLog_Resource)

func (*ActivityLogResource_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLogResource_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLogResource_FieldTerminalPath) Get 

func (fp *ActivityLogResource_FieldTerminalPath) Get(source *ActivityLog_Resource) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_Resource

func (*ActivityLogResource_FieldTerminalPath) GetDefault 

func (fp *ActivityLogResource_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLogResource_FieldTerminalPath) GetRaw 

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

func (*ActivityLogResource_FieldTerminalPath) GetSingle 

func (fp *ActivityLogResource_FieldTerminalPath) GetSingle(source *ActivityLog_Resource) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_Resource

func (*ActivityLogResource_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogResource_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogResource_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogResource_FieldTerminalPath) JSONString 

func (fp *ActivityLogResource_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogResource_FieldTerminalPath) Selector 

func (fp *ActivityLogResource_FieldTerminalPath) Selector() ActivityLogResource_FieldPathSelector

func (*ActivityLogResource_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLogResource_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLogResource_FieldTerminalPath) String 

func (fp *ActivityLogResource_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogResource_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogResource_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogResource_FieldPathArrayItemValue

func (*ActivityLogResource_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogResource_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogResource_FieldPathArrayOfValues

func (*ActivityLogResource_FieldTerminalPath) WithIValue 

func (fp *ActivityLogResource_FieldTerminalPath) WithIValue(value interface{}) ActivityLogResource_FieldPathValue

func (*ActivityLogResource_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogResource_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogResource_FieldTerminalPath) WithRawIValue 

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

type ActivityLogResource_FieldTerminalPathArrayItemValue 

type ActivityLogResource_FieldTerminalPathArrayItemValue struct {
	ActivityLogResource_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogResource_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_Resource) bool

Contains returns a boolean indicating if value that is being held is present in given 'Resource'

func (*ActivityLogResource_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLogResource_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog_Resource as interface{}

func (*ActivityLogResource_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogResource_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_Resource) (interface{}, bool)

func (*ActivityLogResource_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogResource_FieldTerminalPathArrayOfValues 

type ActivityLogResource_FieldTerminalPathArrayOfValues struct {
	ActivityLogResource_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldTerminalPathArrayOfValues) AsDifferenceArrayOfValues 

func (fpaov *ActivityLogResource_FieldTerminalPathArrayOfValues) AsDifferenceArrayOfValues() ([]*ActivityLog_Resource_Difference, bool)

func (*ActivityLogResource_FieldTerminalPathArrayOfValues) AsNameArrayOfValues 

func (fpaov *ActivityLogResource_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool)

func (*ActivityLogResource_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogResource_FieldTerminalPathValue 

type ActivityLogResource_FieldTerminalPathValue struct {
	ActivityLogResource_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogResource_FieldTerminalPathValue) AsDifferenceValue 

func (fpv *ActivityLogResource_FieldTerminalPathValue) AsDifferenceValue() (*ActivityLog_Resource_Difference, bool)

func (*ActivityLogResource_FieldTerminalPathValue) AsNameValue 

func (fpv *ActivityLogResource_FieldTerminalPathValue) AsNameValue() (string, bool)

func (*ActivityLogResource_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogResource_FieldTerminalPathValue) CompareWith(source *ActivityLog_Resource) (int, bool)

CompareWith compares value in the 'ActivityLogResource_FieldTerminalPathValue' with the value under path in 'ActivityLog_Resource'.

func (*ActivityLogResource_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogResource_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLogResource_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'Resource' as interface{}

func (*ActivityLogResource_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogResource_FieldTerminalPathValue) SetTo(target **ActivityLog_Resource)

SetTo stores value for selected field for object Resource

func (*ActivityLogResource_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogResource_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLog_Category 

type ActivityLog_Category int32

Activity log category. Each activity log basically describes read or write action, optionally describes other "operation" type. 

const (
	// Undefined, should never be used
	ActivityLog_Undefined ActivityLog_Category = 0
	// Describes all requests that involved execution of some special operation,
	// for example, SSH connection could be put in this category.
	// It's for requests that cannot be classified clearly as a read or write.
	ActivityLog_Operation ActivityLog_Category = 2
	// Describes all requests that involved creation of a new resource.
	ActivityLog_Creation ActivityLog_Category = 1
	// Describes all requests which involved deletion of an existing resource.
	ActivityLog_Deletion ActivityLog_Category = 11
	// Describes all update requests that changed specification fields in
	// an existing resource(s).
	ActivityLog_SpecUpdate ActivityLog_Category = 3
	// Describes all update requests that changed state fields in an existing
	// resource(s) (but not specification).
	ActivityLog_StateUpdate ActivityLog_Category = 4
	// Describes all update requests that are neither of SpecUpdate or
	// StateUpdate type. It is for non-significant updates like modification of
	// metadata annotations.
	ActivityLog_MetaUpdate ActivityLog_Category = 6
	// Describes an internal update of the system (like controller creating role
	// binding for each group member for each role assigned to group).
	// It includes all CUD requests as long as they are result of an internal
	// system balancing.
	ActivityLog_Internal ActivityLog_Category = 5
	// Describes request that has been rejected and therefore no action
	// has happened. This is result of lack of permission/authentication.
	ActivityLog_Rejected ActivityLog_Category = 7
	// Describes request that has failed due to client error (like validation
	// error)
	ActivityLog_ClientError ActivityLog_Category = 8
	// Describes request that has failed due to server issue.
	ActivityLog_ServerError ActivityLog_Category = 9
	// Describes any read request (like BatchGet, Get, List, Watch).
	ActivityLog_Read ActivityLog_Category = 10
)

func (ActivityLog_Category) Descriptor 

func (ActivityLog_Category) Descriptor() preflect.EnumDescriptor

func (ActivityLog_Category) Enum 

func (x ActivityLog_Category) Enum() *ActivityLog_Category

func (ActivityLog_Category) EnumDescriptor 

func (ActivityLog_Category) EnumDescriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Category.ProtoReflect.Descriptor instead.

func (ActivityLog_Category) Number 

func (x ActivityLog_Category) Number() preflect.EnumNumber

func (ActivityLog_Category) String 

func (x ActivityLog_Category) String() string

func (ActivityLog_Category) Type 

func (ActivityLog_Category) Type() preflect.EnumType

type ActivityLog_Event 

type ActivityLog_Event struct {

	// Types that are valid to be assigned to Evt:
	//	*ActivityLog_Event_ClientMessage
	//	*ActivityLog_Event_ServerMessage
	//	*ActivityLog_Event_Exit
	//	*ActivityLog_Event_RegionalServerMessage
	//	*ActivityLog_Event_RegionalExit
	Evt isActivityLog_Event_Evt `protobuf_oneof:"evt"`
	// contains filtered or unexported fields
}

Event associated with activity.

func (*ActivityLog_Event) Clone 

func (o *ActivityLog_Event) Clone() *ActivityLog_Event

func (*ActivityLog_Event) CloneRaw 

func (o *ActivityLog_Event) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Event) Descriptor 

func (*ActivityLog_Event) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Event.ProtoReflect.Descriptor instead.

func (*ActivityLog_Event) GetClientMessage 

func (m *ActivityLog_Event) GetClientMessage() *ActivityLog_Event_ClientMsgEvent

func (*ActivityLog_Event) GetEvt 

func (m *ActivityLog_Event) GetEvt() isActivityLog_Event_Evt

func (*ActivityLog_Event) GetExit 

func (m *ActivityLog_Event) GetExit() *ActivityLog_Event_ExitEvent

func (*ActivityLog_Event) GetRegionalExit 

func (m *ActivityLog_Event) GetRegionalExit() *ActivityLog_Event_RegionalServerMsgEvent

func (*ActivityLog_Event) GetRegionalServerMessage 

func (m *ActivityLog_Event) GetRegionalServerMessage() *ActivityLog_Event_RegionalServerMsgEvent

func (*ActivityLog_Event) GetServerMessage 

func (m *ActivityLog_Event) GetServerMessage() *ActivityLog_Event_ServerMsgEvent

func (*ActivityLog_Event) GotenMessage 

func (*ActivityLog_Event) GotenMessage()

func (*ActivityLog_Event) GotenObjectExt 

func (o *ActivityLog_Event) GotenObjectExt()

func (*ActivityLog_Event) GotenValidate 

func (obj *ActivityLog_Event) GotenValidate() error

func (*ActivityLog_Event) MakeDiffFieldMask 

func (o *ActivityLog_Event) MakeDiffFieldMask(other *ActivityLog_Event) *ActivityLog_Event_FieldMask

func (*ActivityLog_Event) MakeFullFieldMask 

func (o *ActivityLog_Event) MakeFullFieldMask() *ActivityLog_Event_FieldMask

func (*ActivityLog_Event) MakeRawDiffFieldMask 

func (o *ActivityLog_Event) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Event) MakeRawFullFieldMask 

func (o *ActivityLog_Event) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Event) Marshal 

func (m *ActivityLog_Event) Marshal() ([]byte, error)

func (*ActivityLog_Event) MarshalJSON 

func (m *ActivityLog_Event) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event) Merge 

func (o *ActivityLog_Event) Merge(source *ActivityLog_Event)

func (*ActivityLog_Event) MergeRaw 

func (o *ActivityLog_Event) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Event) ProtoMessage 

func (*ActivityLog_Event) ProtoMessage()

func (*ActivityLog_Event) ProtoReflect 

func (m *ActivityLog_Event) ProtoReflect() preflect.Message

func (*ActivityLog_Event) Reset 

func (m *ActivityLog_Event) Reset()

func (*ActivityLog_Event) SetClientMessage 

func (m *ActivityLog_Event) SetClientMessage(fv *ActivityLog_Event_ClientMsgEvent)

func (*ActivityLog_Event) SetEvt 

func (m *ActivityLog_Event) SetEvt(ofv isActivityLog_Event_Evt)

func (*ActivityLog_Event) SetExit 

func (m *ActivityLog_Event) SetExit(fv *ActivityLog_Event_ExitEvent)

func (*ActivityLog_Event) SetRegionalExit 

func (m *ActivityLog_Event) SetRegionalExit(fv *ActivityLog_Event_RegionalServerMsgEvent)

func (*ActivityLog_Event) SetRegionalServerMessage 

func (m *ActivityLog_Event) SetRegionalServerMessage(fv *ActivityLog_Event_RegionalServerMsgEvent)

func (*ActivityLog_Event) SetServerMessage 

func (m *ActivityLog_Event) SetServerMessage(fv *ActivityLog_Event_ServerMsgEvent)

func (*ActivityLog_Event) String 

func (m *ActivityLog_Event) String() string

func (*ActivityLog_Event) Unmarshal 

func (m *ActivityLog_Event) Unmarshal(b []byte) error

func (*ActivityLog_Event) UnmarshalJSON 

func (m *ActivityLog_Event) UnmarshalJSON(data []byte) error

type ActivityLog_EventPathSelectorClientMessage 

type ActivityLog_EventPathSelectorClientMessage struct{}

func (ActivityLog_EventPathSelectorClientMessage) Data 

func (ActivityLog_EventPathSelectorClientMessage) Data() ActivityLog_EventPathSelectorClientMessageData

func (ActivityLog_EventPathSelectorClientMessage) FieldPath 

func (ActivityLog_EventPathSelectorClientMessage) FieldPath() *ActivityLogEvent_FieldTerminalPath

func (ActivityLog_EventPathSelectorClientMessage) Time 

func (ActivityLog_EventPathSelectorClientMessage) Time() ActivityLog_EventPathSelectorClientMessageTime

func (ActivityLog_EventPathSelectorClientMessage) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorClientMessage) WithArrayOfValues(values []*ActivityLog_Event_ClientMsgEvent) *ActivityLogEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_EventPathSelectorClientMessage) WithSubArrayItemValue 

func (s ActivityLog_EventPathSelectorClientMessage) WithSubArrayItemValue(subPathArrayItemValue ActivityLogEventClientMsgEvent_FieldPathArrayItemValue) *ActivityLogEvent_FieldSubPathArrayItemValue

func (ActivityLog_EventPathSelectorClientMessage) WithSubArrayOfValues 

func (s ActivityLog_EventPathSelectorClientMessage) WithSubArrayOfValues(subPathArrayOfValues ActivityLogEventClientMsgEvent_FieldPathArrayOfValues) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorClientMessage) WithSubPath 

func (ActivityLog_EventPathSelectorClientMessage) WithSubPath(subPath ActivityLogEventClientMsgEvent_FieldPath) *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorClientMessage) WithSubValue 

func (s ActivityLog_EventPathSelectorClientMessage) WithSubValue(subPathValue ActivityLogEventClientMsgEvent_FieldPathValue) *ActivityLogEvent_FieldSubPathValue

func (ActivityLog_EventPathSelectorClientMessage) WithValue 

func (s ActivityLog_EventPathSelectorClientMessage) WithValue(value *ActivityLog_Event_ClientMsgEvent) *ActivityLogEvent_FieldTerminalPathValue

type ActivityLog_EventPathSelectorClientMessageData 

type ActivityLog_EventPathSelectorClientMessageData struct{}

func (ActivityLog_EventPathSelectorClientMessageData) FieldPath 

func (ActivityLog_EventPathSelectorClientMessageData) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorClientMessageData) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorClientMessageData) WithArrayOfValues(values []*anypb.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorClientMessageData) WithValue 

func (s ActivityLog_EventPathSelectorClientMessageData) WithValue(value *anypb.Any) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorClientMessageTime 

type ActivityLog_EventPathSelectorClientMessageTime struct{}

func (ActivityLog_EventPathSelectorClientMessageTime) FieldPath 

func (ActivityLog_EventPathSelectorClientMessageTime) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorClientMessageTime) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorClientMessageTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorClientMessageTime) WithValue 

func (s ActivityLog_EventPathSelectorClientMessageTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorExit 

type ActivityLog_EventPathSelectorExit struct{}

func (ActivityLog_EventPathSelectorExit) FieldPath 

func (ActivityLog_EventPathSelectorExit) FieldPath() *ActivityLogEvent_FieldTerminalPath

func (ActivityLog_EventPathSelectorExit) Status 

func (ActivityLog_EventPathSelectorExit) Status() ActivityLog_EventPathSelectorExitStatus

func (ActivityLog_EventPathSelectorExit) Time 

func (ActivityLog_EventPathSelectorExit) Time() ActivityLog_EventPathSelectorExitTime

func (ActivityLog_EventPathSelectorExit) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorExit) WithArrayOfValues(values []*ActivityLog_Event_ExitEvent) *ActivityLogEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_EventPathSelectorExit) WithSubArrayItemValue 

func (s ActivityLog_EventPathSelectorExit) WithSubArrayItemValue(subPathArrayItemValue ActivityLogEventExitEvent_FieldPathArrayItemValue) *ActivityLogEvent_FieldSubPathArrayItemValue

func (ActivityLog_EventPathSelectorExit) WithSubArrayOfValues 

func (s ActivityLog_EventPathSelectorExit) WithSubArrayOfValues(subPathArrayOfValues ActivityLogEventExitEvent_FieldPathArrayOfValues) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExit) WithSubPath 

func (ActivityLog_EventPathSelectorExit) WithSubPath(subPath ActivityLogEventExitEvent_FieldPath) *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorExit) WithSubValue 

func (s ActivityLog_EventPathSelectorExit) WithSubValue(subPathValue ActivityLogEventExitEvent_FieldPathValue) *ActivityLogEvent_FieldSubPathValue

func (ActivityLog_EventPathSelectorExit) WithValue 

func (s ActivityLog_EventPathSelectorExit) WithValue(value *ActivityLog_Event_ExitEvent) *ActivityLogEvent_FieldTerminalPathValue

type ActivityLog_EventPathSelectorExitStatus 

type ActivityLog_EventPathSelectorExitStatus struct{}

func (ActivityLog_EventPathSelectorExitStatus) Code 

func (ActivityLog_EventPathSelectorExitStatus) Code() ActivityLog_EventPathSelectorExitStatusCode

func (ActivityLog_EventPathSelectorExitStatus) Details 

func (ActivityLog_EventPathSelectorExitStatus) Details() ActivityLog_EventPathSelectorExitStatusDetails

func (ActivityLog_EventPathSelectorExitStatus) FieldPath 

func (ActivityLog_EventPathSelectorExitStatus) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorExitStatus) Message 

func (ActivityLog_EventPathSelectorExitStatus) Message() ActivityLog_EventPathSelectorExitStatusMessage

func (ActivityLog_EventPathSelectorExitStatus) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorExitStatus) WithArrayOfValues(values []*rpc.Status) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExitStatus) WithValue 

func (s ActivityLog_EventPathSelectorExitStatus) WithValue(value *rpc.Status) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorExitStatusCode 

type ActivityLog_EventPathSelectorExitStatusCode struct{}

func (ActivityLog_EventPathSelectorExitStatusCode) FieldPath 

func (ActivityLog_EventPathSelectorExitStatusCode) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorExitStatusCode) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorExitStatusCode) WithArrayOfValues(values []int32) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExitStatusCode) WithValue 

func (s ActivityLog_EventPathSelectorExitStatusCode) WithValue(value int32) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorExitStatusDetails 

type ActivityLog_EventPathSelectorExitStatusDetails struct{}

func (ActivityLog_EventPathSelectorExitStatusDetails) FieldPath 

func (ActivityLog_EventPathSelectorExitStatusDetails) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorExitStatusDetails) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorExitStatusDetails) WithArrayOfValues(values [][]*anypb.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExitStatusDetails) WithItemValue 

func (s ActivityLog_EventPathSelectorExitStatusDetails) WithItemValue(value *anypb.Any) *ActivityLogEvent_FieldSubPathArrayItemValue

func (ActivityLog_EventPathSelectorExitStatusDetails) WithValue 

func (s ActivityLog_EventPathSelectorExitStatusDetails) WithValue(value []*anypb.Any) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorExitStatusMessage 

type ActivityLog_EventPathSelectorExitStatusMessage struct{}

func (ActivityLog_EventPathSelectorExitStatusMessage) FieldPath 

func (ActivityLog_EventPathSelectorExitStatusMessage) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorExitStatusMessage) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorExitStatusMessage) WithArrayOfValues(values []string) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExitStatusMessage) WithValue 

func (s ActivityLog_EventPathSelectorExitStatusMessage) WithValue(value string) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorExitTime 

type ActivityLog_EventPathSelectorExitTime struct{}

func (ActivityLog_EventPathSelectorExitTime) FieldPath 

func (ActivityLog_EventPathSelectorExitTime) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorExitTime) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorExitTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExitTime) WithValue 

func (s ActivityLog_EventPathSelectorExitTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorRegionalExit 

type ActivityLog_EventPathSelectorRegionalExit struct{}

func (ActivityLog_EventPathSelectorRegionalExit) Data 

func (ActivityLog_EventPathSelectorRegionalExit) Data() ActivityLog_EventPathSelectorRegionalExitData

func (ActivityLog_EventPathSelectorRegionalExit) FieldPath 

func (ActivityLog_EventPathSelectorRegionalExit) FieldPath() *ActivityLogEvent_FieldTerminalPath

func (ActivityLog_EventPathSelectorRegionalExit) RegionId 

func (ActivityLog_EventPathSelectorRegionalExit) RegionId() ActivityLog_EventPathSelectorRegionalExitRegionId

func (ActivityLog_EventPathSelectorRegionalExit) Time 

func (ActivityLog_EventPathSelectorRegionalExit) Time() ActivityLog_EventPathSelectorRegionalExitTime

func (ActivityLog_EventPathSelectorRegionalExit) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalExit) WithArrayOfValues(values []*ActivityLog_Event_RegionalServerMsgEvent) *ActivityLogEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalExit) WithSubArrayItemValue 

func (s ActivityLog_EventPathSelectorRegionalExit) WithSubArrayItemValue(subPathArrayItemValue ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue) *ActivityLogEvent_FieldSubPathArrayItemValue

func (ActivityLog_EventPathSelectorRegionalExit) WithSubArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalExit) WithSubArrayOfValues(subPathArrayOfValues ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalExit) WithSubPath 

func (ActivityLog_EventPathSelectorRegionalExit) WithSubPath(subPath ActivityLogEventRegionalServerMsgEvent_FieldPath) *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalExit) WithSubValue 

func (s ActivityLog_EventPathSelectorRegionalExit) WithSubValue(subPathValue ActivityLogEventRegionalServerMsgEvent_FieldPathValue) *ActivityLogEvent_FieldSubPathValue

func (ActivityLog_EventPathSelectorRegionalExit) WithValue 

func (s ActivityLog_EventPathSelectorRegionalExit) WithValue(value *ActivityLog_Event_RegionalServerMsgEvent) *ActivityLogEvent_FieldTerminalPathValue

type ActivityLog_EventPathSelectorRegionalExitData 

type ActivityLog_EventPathSelectorRegionalExitData struct{}

func (ActivityLog_EventPathSelectorRegionalExitData) FieldPath 

func (ActivityLog_EventPathSelectorRegionalExitData) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalExitData) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalExitData) WithArrayOfValues(values []*anypb.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalExitData) WithValue 

func (s ActivityLog_EventPathSelectorRegionalExitData) WithValue(value *anypb.Any) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorRegionalExitRegionId 

type ActivityLog_EventPathSelectorRegionalExitRegionId struct{}

func (ActivityLog_EventPathSelectorRegionalExitRegionId) FieldPath 

func (ActivityLog_EventPathSelectorRegionalExitRegionId) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalExitRegionId) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalExitRegionId) WithArrayOfValues(values []string) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalExitRegionId) WithValue 

func (s ActivityLog_EventPathSelectorRegionalExitRegionId) WithValue(value string) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorRegionalExitTime 

type ActivityLog_EventPathSelectorRegionalExitTime struct{}

func (ActivityLog_EventPathSelectorRegionalExitTime) FieldPath 

func (ActivityLog_EventPathSelectorRegionalExitTime) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalExitTime) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalExitTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalExitTime) WithValue 

func (s ActivityLog_EventPathSelectorRegionalExitTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorRegionalServerMessage 

type ActivityLog_EventPathSelectorRegionalServerMessage struct{}

func (ActivityLog_EventPathSelectorRegionalServerMessage) Data 

func (ActivityLog_EventPathSelectorRegionalServerMessage) Data() ActivityLog_EventPathSelectorRegionalServerMessageData

func (ActivityLog_EventPathSelectorRegionalServerMessage) FieldPath 

func (ActivityLog_EventPathSelectorRegionalServerMessage) FieldPath() *ActivityLogEvent_FieldTerminalPath

func (ActivityLog_EventPathSelectorRegionalServerMessage) RegionId 

func (ActivityLog_EventPathSelectorRegionalServerMessage) RegionId() ActivityLog_EventPathSelectorRegionalServerMessageRegionId

func (ActivityLog_EventPathSelectorRegionalServerMessage) Time 

func (ActivityLog_EventPathSelectorRegionalServerMessage) Time() ActivityLog_EventPathSelectorRegionalServerMessageTime

func (ActivityLog_EventPathSelectorRegionalServerMessage) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalServerMessage) WithArrayOfValues(values []*ActivityLog_Event_RegionalServerMsgEvent) *ActivityLogEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalServerMessage) WithSubArrayItemValue 

func (s ActivityLog_EventPathSelectorRegionalServerMessage) WithSubArrayItemValue(subPathArrayItemValue ActivityLogEventRegionalServerMsgEvent_FieldPathArrayItemValue) *ActivityLogEvent_FieldSubPathArrayItemValue

func (ActivityLog_EventPathSelectorRegionalServerMessage) WithSubArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalServerMessage) WithSubArrayOfValues(subPathArrayOfValues ActivityLogEventRegionalServerMsgEvent_FieldPathArrayOfValues) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalServerMessage) WithSubPath 

func (ActivityLog_EventPathSelectorRegionalServerMessage) WithSubPath(subPath ActivityLogEventRegionalServerMsgEvent_FieldPath) *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalServerMessage) WithSubValue 

func (s ActivityLog_EventPathSelectorRegionalServerMessage) WithSubValue(subPathValue ActivityLogEventRegionalServerMsgEvent_FieldPathValue) *ActivityLogEvent_FieldSubPathValue

func (ActivityLog_EventPathSelectorRegionalServerMessage) WithValue 

func (s ActivityLog_EventPathSelectorRegionalServerMessage) WithValue(value *ActivityLog_Event_RegionalServerMsgEvent) *ActivityLogEvent_FieldTerminalPathValue

type ActivityLog_EventPathSelectorRegionalServerMessageData 

type ActivityLog_EventPathSelectorRegionalServerMessageData struct{}

func (ActivityLog_EventPathSelectorRegionalServerMessageData) FieldPath 

func (ActivityLog_EventPathSelectorRegionalServerMessageData) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalServerMessageData) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalServerMessageData) WithArrayOfValues(values []*anypb.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalServerMessageData) WithValue 

func (s ActivityLog_EventPathSelectorRegionalServerMessageData) WithValue(value *anypb.Any) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorRegionalServerMessageRegionId 

type ActivityLog_EventPathSelectorRegionalServerMessageRegionId struct{}

func (ActivityLog_EventPathSelectorRegionalServerMessageRegionId) FieldPath 

func (ActivityLog_EventPathSelectorRegionalServerMessageRegionId) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalServerMessageRegionId) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalServerMessageRegionId) WithArrayOfValues(values []string) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalServerMessageRegionId) WithValue 

func (s ActivityLog_EventPathSelectorRegionalServerMessageRegionId) WithValue(value string) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorRegionalServerMessageTime 

type ActivityLog_EventPathSelectorRegionalServerMessageTime struct{}

func (ActivityLog_EventPathSelectorRegionalServerMessageTime) FieldPath 

func (ActivityLog_EventPathSelectorRegionalServerMessageTime) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorRegionalServerMessageTime) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorRegionalServerMessageTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorRegionalServerMessageTime) WithValue 

func (s ActivityLog_EventPathSelectorRegionalServerMessageTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorServerMessage 

type ActivityLog_EventPathSelectorServerMessage struct{}

func (ActivityLog_EventPathSelectorServerMessage) Data 

func (ActivityLog_EventPathSelectorServerMessage) Data() ActivityLog_EventPathSelectorServerMessageData

func (ActivityLog_EventPathSelectorServerMessage) FieldPath 

func (ActivityLog_EventPathSelectorServerMessage) FieldPath() *ActivityLogEvent_FieldTerminalPath

func (ActivityLog_EventPathSelectorServerMessage) Time 

func (ActivityLog_EventPathSelectorServerMessage) Time() ActivityLog_EventPathSelectorServerMessageTime

func (ActivityLog_EventPathSelectorServerMessage) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorServerMessage) WithArrayOfValues(values []*ActivityLog_Event_ServerMsgEvent) *ActivityLogEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_EventPathSelectorServerMessage) WithSubArrayItemValue 

func (s ActivityLog_EventPathSelectorServerMessage) WithSubArrayItemValue(subPathArrayItemValue ActivityLogEventServerMsgEvent_FieldPathArrayItemValue) *ActivityLogEvent_FieldSubPathArrayItemValue

func (ActivityLog_EventPathSelectorServerMessage) WithSubArrayOfValues 

func (s ActivityLog_EventPathSelectorServerMessage) WithSubArrayOfValues(subPathArrayOfValues ActivityLogEventServerMsgEvent_FieldPathArrayOfValues) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorServerMessage) WithSubPath 

func (ActivityLog_EventPathSelectorServerMessage) WithSubPath(subPath ActivityLogEventServerMsgEvent_FieldPath) *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorServerMessage) WithSubValue 

func (s ActivityLog_EventPathSelectorServerMessage) WithSubValue(subPathValue ActivityLogEventServerMsgEvent_FieldPathValue) *ActivityLogEvent_FieldSubPathValue

func (ActivityLog_EventPathSelectorServerMessage) WithValue 

func (s ActivityLog_EventPathSelectorServerMessage) WithValue(value *ActivityLog_Event_ServerMsgEvent) *ActivityLogEvent_FieldTerminalPathValue

type ActivityLog_EventPathSelectorServerMessageData 

type ActivityLog_EventPathSelectorServerMessageData struct{}

func (ActivityLog_EventPathSelectorServerMessageData) FieldPath 

func (ActivityLog_EventPathSelectorServerMessageData) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorServerMessageData) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorServerMessageData) WithArrayOfValues(values []*anypb.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorServerMessageData) WithValue 

func (s ActivityLog_EventPathSelectorServerMessageData) WithValue(value *anypb.Any) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_EventPathSelectorServerMessageTime 

type ActivityLog_EventPathSelectorServerMessageTime struct{}

func (ActivityLog_EventPathSelectorServerMessageTime) FieldPath 

func (ActivityLog_EventPathSelectorServerMessageTime) FieldPath() *ActivityLogEvent_FieldSubPath

func (ActivityLog_EventPathSelectorServerMessageTime) WithArrayOfValues 

func (s ActivityLog_EventPathSelectorServerMessageTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorServerMessageTime) WithValue 

func (s ActivityLog_EventPathSelectorServerMessageTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEvent_FieldSubPathValue

type ActivityLog_Event_ClientMessage 

type ActivityLog_Event_ClientMessage struct {
	// Client message received event
	ClientMessage *ActivityLog_Event_ClientMsgEvent `protobuf:"bytes,1,opt,name=client_message,json=clientMessage,proto3,oneof" firestore:"clientMessage"`
}

type ActivityLog_Event_ClientMsgEvent 

type ActivityLog_Event_ClientMsgEvent struct {

	// Message contents
	Data *anypb.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" firestore:"data"`
	// Time of a message
	Time *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty" firestore:"time"`
	// contains filtered or unexported fields
}

Describes client message event

func (*ActivityLog_Event_ClientMsgEvent) Clone 

func (o *ActivityLog_Event_ClientMsgEvent) Clone() *ActivityLog_Event_ClientMsgEvent

func (*ActivityLog_Event_ClientMsgEvent) CloneRaw 

func (o *ActivityLog_Event_ClientMsgEvent) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Event_ClientMsgEvent) Descriptor 

func (*ActivityLog_Event_ClientMsgEvent) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Event_ClientMsgEvent.ProtoReflect.Descriptor instead.

func (*ActivityLog_Event_ClientMsgEvent) GetData 

func (m *ActivityLog_Event_ClientMsgEvent) GetData() *anypb.Any

func (*ActivityLog_Event_ClientMsgEvent) GetTime 

func (m *ActivityLog_Event_ClientMsgEvent) GetTime() *timestamppb.Timestamp

func (*ActivityLog_Event_ClientMsgEvent) GotenMessage 

func (*ActivityLog_Event_ClientMsgEvent) GotenMessage()

func (*ActivityLog_Event_ClientMsgEvent) GotenObjectExt 

func (o *ActivityLog_Event_ClientMsgEvent) GotenObjectExt()

func (*ActivityLog_Event_ClientMsgEvent) GotenValidate 

func (obj *ActivityLog_Event_ClientMsgEvent) GotenValidate() error

func (*ActivityLog_Event_ClientMsgEvent) MakeDiffFieldMask 

func (o *ActivityLog_Event_ClientMsgEvent) MakeDiffFieldMask(other *ActivityLog_Event_ClientMsgEvent) *ActivityLog_Event_ClientMsgEvent_FieldMask

func (*ActivityLog_Event_ClientMsgEvent) MakeFullFieldMask 

func (o *ActivityLog_Event_ClientMsgEvent) MakeFullFieldMask() *ActivityLog_Event_ClientMsgEvent_FieldMask

func (*ActivityLog_Event_ClientMsgEvent) MakeRawDiffFieldMask 

func (o *ActivityLog_Event_ClientMsgEvent) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Event_ClientMsgEvent) MakeRawFullFieldMask 

func (o *ActivityLog_Event_ClientMsgEvent) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Event_ClientMsgEvent) Marshal 

func (m *ActivityLog_Event_ClientMsgEvent) Marshal() ([]byte, error)

func (*ActivityLog_Event_ClientMsgEvent) MarshalJSON 

func (m *ActivityLog_Event_ClientMsgEvent) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_ClientMsgEvent) Merge 

func (o *ActivityLog_Event_ClientMsgEvent) Merge(source *ActivityLog_Event_ClientMsgEvent)

func (*ActivityLog_Event_ClientMsgEvent) MergeRaw 

func (o *ActivityLog_Event_ClientMsgEvent) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Event_ClientMsgEvent) ProtoMessage 

func (*ActivityLog_Event_ClientMsgEvent) ProtoMessage()

func (*ActivityLog_Event_ClientMsgEvent) ProtoReflect 

func (m *ActivityLog_Event_ClientMsgEvent) ProtoReflect() preflect.Message

func (*ActivityLog_Event_ClientMsgEvent) Reset 

func (m *ActivityLog_Event_ClientMsgEvent) Reset()

func (*ActivityLog_Event_ClientMsgEvent) SetData 

func (m *ActivityLog_Event_ClientMsgEvent) SetData(fv *anypb.Any)

func (*ActivityLog_Event_ClientMsgEvent) SetTime 

func (m *ActivityLog_Event_ClientMsgEvent) SetTime(fv *timestamppb.Timestamp)

func (*ActivityLog_Event_ClientMsgEvent) String 

func (m *ActivityLog_Event_ClientMsgEvent) String() string

func (*ActivityLog_Event_ClientMsgEvent) Unmarshal 

func (m *ActivityLog_Event_ClientMsgEvent) Unmarshal(b []byte) error

func (*ActivityLog_Event_ClientMsgEvent) UnmarshalJSON 

func (m *ActivityLog_Event_ClientMsgEvent) UnmarshalJSON(data []byte) error

type ActivityLog_Event_ClientMsgEventPathSelectorData 

type ActivityLog_Event_ClientMsgEventPathSelectorData struct{}

func (ActivityLog_Event_ClientMsgEventPathSelectorData) FieldPath 

func (ActivityLog_Event_ClientMsgEventPathSelectorData) FieldPath() *ActivityLogEventClientMsgEvent_FieldTerminalPath

func (ActivityLog_Event_ClientMsgEventPathSelectorData) WithArrayOfValues 

func (s ActivityLog_Event_ClientMsgEventPathSelectorData) WithArrayOfValues(values []*anypb.Any) *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ClientMsgEventPathSelectorData) WithValue 

func (s ActivityLog_Event_ClientMsgEventPathSelectorData) WithValue(value *anypb.Any) *ActivityLogEventClientMsgEvent_FieldTerminalPathValue

type ActivityLog_Event_ClientMsgEventPathSelectorTime 

type ActivityLog_Event_ClientMsgEventPathSelectorTime struct{}

func (ActivityLog_Event_ClientMsgEventPathSelectorTime) FieldPath 

func (ActivityLog_Event_ClientMsgEventPathSelectorTime) FieldPath() *ActivityLogEventClientMsgEvent_FieldTerminalPath

func (ActivityLog_Event_ClientMsgEventPathSelectorTime) WithArrayOfValues 

func (s ActivityLog_Event_ClientMsgEventPathSelectorTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ClientMsgEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_ClientMsgEventPathSelectorTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEventClientMsgEvent_FieldTerminalPathValue

type ActivityLog_Event_ClientMsgEvent_FieldMask 

type ActivityLog_Event_ClientMsgEvent_FieldMask struct {
	Paths []ActivityLogEventClientMsgEvent_FieldPath
}

func FullActivityLog_Event_ClientMsgEvent_FieldMask 

func FullActivityLog_Event_ClientMsgEvent_FieldMask() *ActivityLog_Event_ClientMsgEvent_FieldMask

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) AppendPath(path ActivityLogEventClientMsgEvent_FieldPath)

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) FilterInputFields() *ActivityLog_Event_ClientMsgEvent_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) GetPaths() []ActivityLogEventClientMsgEvent_FieldPath

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) IsFull 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) IsFull() bool

func (ActivityLog_Event_ClientMsgEvent_FieldMask) Marshal 

func (fieldMask ActivityLog_Event_ClientMsgEvent_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Event_ClientMsgEvent_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Event_ClientMsgEvent_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) PathsCount() int

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) Project 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) Project(source *ActivityLog_Event_ClientMsgEvent) *ActivityLog_Event_ClientMsgEvent

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) ProtoMessage()

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) Reset 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) Reset()

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) Set 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) Set(target, source *ActivityLog_Event_ClientMsgEvent)

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) SetRaw 

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

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) Size 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) Size() int

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) String 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) String() string

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) Subtract 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) Subtract(other *ActivityLog_Event_ClientMsgEvent_FieldMask) *ActivityLog_Event_ClientMsgEvent_FieldMask

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Event_ClientMsgEvent_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Event_ClientMsgEvent_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_Event_Exit 

type ActivityLog_Event_Exit struct {
	// Request finished event
	Exit *ActivityLog_Event_ExitEvent `protobuf:"bytes,3,opt,name=exit,proto3,oneof" firestore:"exit"`
}

type ActivityLog_Event_ExitEvent 

type ActivityLog_Event_ExitEvent struct {

	// Final status of a request
	Status *rpc.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty" firestore:"status"`
	// Time when request finished
	Time *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty" firestore:"time"`
	// contains filtered or unexported fields
}

Describes exit event (request finished)

func (*ActivityLog_Event_ExitEvent) Clone 

func (o *ActivityLog_Event_ExitEvent) Clone() *ActivityLog_Event_ExitEvent

func (*ActivityLog_Event_ExitEvent) CloneRaw 

func (o *ActivityLog_Event_ExitEvent) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Event_ExitEvent) Descriptor 

func (*ActivityLog_Event_ExitEvent) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Event_ExitEvent.ProtoReflect.Descriptor instead.

func (*ActivityLog_Event_ExitEvent) GetStatus 

func (m *ActivityLog_Event_ExitEvent) GetStatus() *rpc.Status

func (*ActivityLog_Event_ExitEvent) GetTime 

func (m *ActivityLog_Event_ExitEvent) GetTime() *timestamppb.Timestamp

func (*ActivityLog_Event_ExitEvent) GotenMessage 

func (*ActivityLog_Event_ExitEvent) GotenMessage()

func (*ActivityLog_Event_ExitEvent) GotenObjectExt 

func (o *ActivityLog_Event_ExitEvent) GotenObjectExt()

func (*ActivityLog_Event_ExitEvent) GotenValidate 

func (obj *ActivityLog_Event_ExitEvent) GotenValidate() error

func (*ActivityLog_Event_ExitEvent) MakeDiffFieldMask 

func (o *ActivityLog_Event_ExitEvent) MakeDiffFieldMask(other *ActivityLog_Event_ExitEvent) *ActivityLog_Event_ExitEvent_FieldMask

func (*ActivityLog_Event_ExitEvent) MakeFullFieldMask 

func (o *ActivityLog_Event_ExitEvent) MakeFullFieldMask() *ActivityLog_Event_ExitEvent_FieldMask

func (*ActivityLog_Event_ExitEvent) MakeRawDiffFieldMask 

func (o *ActivityLog_Event_ExitEvent) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Event_ExitEvent) MakeRawFullFieldMask 

func (o *ActivityLog_Event_ExitEvent) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Event_ExitEvent) Marshal 

func (m *ActivityLog_Event_ExitEvent) Marshal() ([]byte, error)

func (*ActivityLog_Event_ExitEvent) MarshalJSON 

func (m *ActivityLog_Event_ExitEvent) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_ExitEvent) Merge 

func (o *ActivityLog_Event_ExitEvent) Merge(source *ActivityLog_Event_ExitEvent)

func (*ActivityLog_Event_ExitEvent) MergeRaw 

func (o *ActivityLog_Event_ExitEvent) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Event_ExitEvent) ProtoMessage 

func (*ActivityLog_Event_ExitEvent) ProtoMessage()

func (*ActivityLog_Event_ExitEvent) ProtoReflect 

func (m *ActivityLog_Event_ExitEvent) ProtoReflect() preflect.Message

func (*ActivityLog_Event_ExitEvent) Reset 

func (m *ActivityLog_Event_ExitEvent) Reset()

func (*ActivityLog_Event_ExitEvent) SetStatus 

func (m *ActivityLog_Event_ExitEvent) SetStatus(fv *rpc.Status)

func (*ActivityLog_Event_ExitEvent) SetTime 

func (m *ActivityLog_Event_ExitEvent) SetTime(fv *timestamppb.Timestamp)

func (*ActivityLog_Event_ExitEvent) String 

func (m *ActivityLog_Event_ExitEvent) String() string

func (*ActivityLog_Event_ExitEvent) Unmarshal 

func (m *ActivityLog_Event_ExitEvent) Unmarshal(b []byte) error

func (*ActivityLog_Event_ExitEvent) UnmarshalJSON 

func (m *ActivityLog_Event_ExitEvent) UnmarshalJSON(data []byte) error

type ActivityLog_Event_ExitEventPathSelectorStatus 

type ActivityLog_Event_ExitEventPathSelectorStatus struct{}

func (ActivityLog_Event_ExitEventPathSelectorStatus) Code 

func (ActivityLog_Event_ExitEventPathSelectorStatus) Code() ActivityLog_Event_ExitEventPathSelectorStatusCode

func (ActivityLog_Event_ExitEventPathSelectorStatus) Details 

func (ActivityLog_Event_ExitEventPathSelectorStatus) Details() ActivityLog_Event_ExitEventPathSelectorStatusDetails

func (ActivityLog_Event_ExitEventPathSelectorStatus) FieldPath 

func (ActivityLog_Event_ExitEventPathSelectorStatus) FieldPath() *ActivityLogEventExitEvent_FieldTerminalPath

func (ActivityLog_Event_ExitEventPathSelectorStatus) Message 

func (ActivityLog_Event_ExitEventPathSelectorStatus) Message() ActivityLog_Event_ExitEventPathSelectorStatusMessage

func (ActivityLog_Event_ExitEventPathSelectorStatus) WithArrayOfValues 

func (s ActivityLog_Event_ExitEventPathSelectorStatus) WithArrayOfValues(values []*rpc.Status) *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorStatus) WithSubArrayItemValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatus) WithSubArrayItemValue(subPathArrayItemValue rpc.Status_FieldPathArrayItemValue) *ActivityLogEventExitEvent_FieldSubPathArrayItemValue

func (ActivityLog_Event_ExitEventPathSelectorStatus) WithSubArrayOfValues 

func (s ActivityLog_Event_ExitEventPathSelectorStatus) WithSubArrayOfValues(subPathArrayOfValues rpc.Status_FieldPathArrayOfValues) *ActivityLogEventExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorStatus) WithSubPath 

func (ActivityLog_Event_ExitEventPathSelectorStatus) WithSubPath(subPath rpc.Status_FieldPath) *ActivityLogEventExitEvent_FieldSubPath

func (ActivityLog_Event_ExitEventPathSelectorStatus) WithSubValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatus) WithSubValue(subPathValue rpc.Status_FieldPathValue) *ActivityLogEventExitEvent_FieldSubPathValue

func (ActivityLog_Event_ExitEventPathSelectorStatus) WithValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatus) WithValue(value *rpc.Status) *ActivityLogEventExitEvent_FieldTerminalPathValue

type ActivityLog_Event_ExitEventPathSelectorStatusCode 

type ActivityLog_Event_ExitEventPathSelectorStatusCode struct{}

func (ActivityLog_Event_ExitEventPathSelectorStatusCode) FieldPath 

func (ActivityLog_Event_ExitEventPathSelectorStatusCode) FieldPath() *ActivityLogEventExitEvent_FieldSubPath

func (ActivityLog_Event_ExitEventPathSelectorStatusCode) WithArrayOfValues 

func (s ActivityLog_Event_ExitEventPathSelectorStatusCode) WithArrayOfValues(values []int32) *ActivityLogEventExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorStatusCode) WithValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatusCode) WithValue(value int32) *ActivityLogEventExitEvent_FieldSubPathValue

type ActivityLog_Event_ExitEventPathSelectorStatusDetails 

type ActivityLog_Event_ExitEventPathSelectorStatusDetails struct{}

func (ActivityLog_Event_ExitEventPathSelectorStatusDetails) FieldPath 

func (ActivityLog_Event_ExitEventPathSelectorStatusDetails) FieldPath() *ActivityLogEventExitEvent_FieldSubPath

func (ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithArrayOfValues 

func (s ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithArrayOfValues(values [][]*anypb.Any) *ActivityLogEventExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithItemValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithItemValue(value *anypb.Any) *ActivityLogEventExitEvent_FieldSubPathArrayItemValue

func (ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithValue(value []*anypb.Any) *ActivityLogEventExitEvent_FieldSubPathValue

type ActivityLog_Event_ExitEventPathSelectorStatusMessage 

type ActivityLog_Event_ExitEventPathSelectorStatusMessage struct{}

func (ActivityLog_Event_ExitEventPathSelectorStatusMessage) FieldPath 

func (ActivityLog_Event_ExitEventPathSelectorStatusMessage) FieldPath() *ActivityLogEventExitEvent_FieldSubPath

func (ActivityLog_Event_ExitEventPathSelectorStatusMessage) WithArrayOfValues 

func (s ActivityLog_Event_ExitEventPathSelectorStatusMessage) WithArrayOfValues(values []string) *ActivityLogEventExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorStatusMessage) WithValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatusMessage) WithValue(value string) *ActivityLogEventExitEvent_FieldSubPathValue

type ActivityLog_Event_ExitEventPathSelectorTime 

type ActivityLog_Event_ExitEventPathSelectorTime struct{}

func (ActivityLog_Event_ExitEventPathSelectorTime) FieldPath 

func (ActivityLog_Event_ExitEventPathSelectorTime) FieldPath() *ActivityLogEventExitEvent_FieldTerminalPath

func (ActivityLog_Event_ExitEventPathSelectorTime) WithArrayOfValues 

func (s ActivityLog_Event_ExitEventPathSelectorTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_ExitEventPathSelectorTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEventExitEvent_FieldTerminalPathValue

type ActivityLog_Event_ExitEvent_FieldMask 

type ActivityLog_Event_ExitEvent_FieldMask struct {
	Paths []ActivityLogEventExitEvent_FieldPath
}

func FullActivityLog_Event_ExitEvent_FieldMask 

func FullActivityLog_Event_ExitEvent_FieldMask() *ActivityLog_Event_ExitEvent_FieldMask

func (*ActivityLog_Event_ExitEvent_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) AppendPath(path ActivityLogEventExitEvent_FieldPath)

func (*ActivityLog_Event_ExitEvent_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Event_ExitEvent_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Event_ExitEvent_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Event_ExitEvent_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) FilterInputFields() *ActivityLog_Event_ExitEvent_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Event_ExitEvent_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Event_ExitEvent_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) GetPaths() []ActivityLogEventExitEvent_FieldPath

func (*ActivityLog_Event_ExitEvent_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Event_ExitEvent_FieldMask) IsFull 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) IsFull() bool

func (ActivityLog_Event_ExitEvent_FieldMask) Marshal 

func (fieldMask ActivityLog_Event_ExitEvent_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Event_ExitEvent_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Event_ExitEvent_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_ExitEvent_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) PathsCount() int

func (*ActivityLog_Event_ExitEvent_FieldMask) Project 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) Project(source *ActivityLog_Event_ExitEvent) *ActivityLog_Event_ExitEvent

func (*ActivityLog_Event_ExitEvent_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Event_ExitEvent_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) ProtoMessage()

func (*ActivityLog_Event_ExitEvent_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Event_ExitEvent_FieldMask) Reset 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) Reset()

func (*ActivityLog_Event_ExitEvent_FieldMask) Set 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) Set(target, source *ActivityLog_Event_ExitEvent)

func (*ActivityLog_Event_ExitEvent_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Event_ExitEvent_FieldMask) SetRaw 

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

func (*ActivityLog_Event_ExitEvent_FieldMask) Size 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) Size() int

func (*ActivityLog_Event_ExitEvent_FieldMask) String 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) String() string

func (*ActivityLog_Event_ExitEvent_FieldMask) Subtract 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) Subtract(other *ActivityLog_Event_ExitEvent_FieldMask) *ActivityLog_Event_ExitEvent_FieldMask

func (*ActivityLog_Event_ExitEvent_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Event_ExitEvent_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Event_ExitEvent_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Event_ExitEvent_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Event_ExitEvent_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_Event_FieldMask 

type ActivityLog_Event_FieldMask struct {
	Paths []ActivityLogEvent_FieldPath
}

func FullActivityLog_Event_FieldMask 

func FullActivityLog_Event_FieldMask() *ActivityLog_Event_FieldMask

func (*ActivityLog_Event_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Event_FieldMask) AppendPath(path ActivityLogEvent_FieldPath)

func (*ActivityLog_Event_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Event_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Event_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Event_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Event_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Event_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Event_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Event_FieldMask) FilterInputFields() *ActivityLog_Event_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Event_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Event_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Event_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Event_FieldMask) GetPaths() []ActivityLogEvent_FieldPath

func (*ActivityLog_Event_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Event_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Event_FieldMask) IsFull 

func (fieldMask *ActivityLog_Event_FieldMask) IsFull() bool

func (ActivityLog_Event_FieldMask) Marshal 

func (fieldMask ActivityLog_Event_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Event_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Event_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Event_FieldMask) PathsCount() int

func (*ActivityLog_Event_FieldMask) Project 

func (fieldMask *ActivityLog_Event_FieldMask) Project(source *ActivityLog_Event) *ActivityLog_Event

func (*ActivityLog_Event_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Event_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Event_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Event_FieldMask) ProtoMessage()

func (*ActivityLog_Event_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Event_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Event_FieldMask) Reset 

func (fieldMask *ActivityLog_Event_FieldMask) Reset()

func (*ActivityLog_Event_FieldMask) Set 

func (fieldMask *ActivityLog_Event_FieldMask) Set(target, source *ActivityLog_Event)

func (*ActivityLog_Event_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Event_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Event_FieldMask) SetRaw 

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

func (*ActivityLog_Event_FieldMask) Size 

func (fieldMask *ActivityLog_Event_FieldMask) Size() int

func (*ActivityLog_Event_FieldMask) String 

func (fieldMask *ActivityLog_Event_FieldMask) String() string

func (*ActivityLog_Event_FieldMask) Subtract 

func (fieldMask *ActivityLog_Event_FieldMask) Subtract(other *ActivityLog_Event_FieldMask) *ActivityLog_Event_FieldMask

func (*ActivityLog_Event_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Event_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Event_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Event_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Event_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Event_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Event_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Event_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_Event_RegionalExit 

type ActivityLog_Event_RegionalExit struct {
	// Server received exit code from another server (used for split & merge).
	// In case it contains error, its likely final exit will contain this too.
	RegionalExit *ActivityLog_Event_RegionalServerMsgEvent `protobuf:"bytes,5,opt,name=regional_exit,json=regionalExit,proto3,oneof" firestore:"regionalExit"`
}

type ActivityLog_Event_RegionalExitEvent 

type ActivityLog_Event_RegionalExitEvent struct {

	// Final status of a request for given region
	Status *rpc.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty" firestore:"status"`
	// Time when request finished
	Time *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty" firestore:"time"`
	// Region ID where status comes from
	RegionId string `protobuf:"bytes,3,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty" firestore:"regionId"`
	// contains filtered or unexported fields
}

Describes exit code received from server in specific region. This type is used only for requests, which receiving server decided to split across many regions. Each regional server sends own response and executing server is responsible for merging all partial results into one. IT does not contain status actually sent to the client. TODO: No use case for now, just placeholder, no server implementation

func (*ActivityLog_Event_RegionalExitEvent) Clone 

func (o *ActivityLog_Event_RegionalExitEvent) Clone() *ActivityLog_Event_RegionalExitEvent

func (*ActivityLog_Event_RegionalExitEvent) CloneRaw 

func (o *ActivityLog_Event_RegionalExitEvent) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Event_RegionalExitEvent) Descriptor 

func (*ActivityLog_Event_RegionalExitEvent) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Event_RegionalExitEvent.ProtoReflect.Descriptor instead.

func (*ActivityLog_Event_RegionalExitEvent) GetRegionId 

func (m *ActivityLog_Event_RegionalExitEvent) GetRegionId() string

func (*ActivityLog_Event_RegionalExitEvent) GetStatus 

func (m *ActivityLog_Event_RegionalExitEvent) GetStatus() *rpc.Status

func (*ActivityLog_Event_RegionalExitEvent) GetTime 

func (m *ActivityLog_Event_RegionalExitEvent) GetTime() *timestamppb.Timestamp

func (*ActivityLog_Event_RegionalExitEvent) GotenMessage 

func (*ActivityLog_Event_RegionalExitEvent) GotenMessage()

func (*ActivityLog_Event_RegionalExitEvent) GotenObjectExt 

func (o *ActivityLog_Event_RegionalExitEvent) GotenObjectExt()

func (*ActivityLog_Event_RegionalExitEvent) GotenValidate 

func (obj *ActivityLog_Event_RegionalExitEvent) GotenValidate() error

func (*ActivityLog_Event_RegionalExitEvent) MakeDiffFieldMask 

func (o *ActivityLog_Event_RegionalExitEvent) MakeDiffFieldMask(other *ActivityLog_Event_RegionalExitEvent) *ActivityLog_Event_RegionalExitEvent_FieldMask

func (*ActivityLog_Event_RegionalExitEvent) MakeFullFieldMask 

func (o *ActivityLog_Event_RegionalExitEvent) MakeFullFieldMask() *ActivityLog_Event_RegionalExitEvent_FieldMask

func (*ActivityLog_Event_RegionalExitEvent) MakeRawDiffFieldMask 

func (o *ActivityLog_Event_RegionalExitEvent) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Event_RegionalExitEvent) MakeRawFullFieldMask 

func (o *ActivityLog_Event_RegionalExitEvent) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Event_RegionalExitEvent) Marshal 

func (m *ActivityLog_Event_RegionalExitEvent) Marshal() ([]byte, error)

func (*ActivityLog_Event_RegionalExitEvent) MarshalJSON 

func (m *ActivityLog_Event_RegionalExitEvent) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_RegionalExitEvent) Merge 

func (o *ActivityLog_Event_RegionalExitEvent) Merge(source *ActivityLog_Event_RegionalExitEvent)

func (*ActivityLog_Event_RegionalExitEvent) MergeRaw 

func (o *ActivityLog_Event_RegionalExitEvent) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Event_RegionalExitEvent) ProtoMessage 

func (*ActivityLog_Event_RegionalExitEvent) ProtoMessage()

func (*ActivityLog_Event_RegionalExitEvent) ProtoReflect 

func (m *ActivityLog_Event_RegionalExitEvent) ProtoReflect() preflect.Message

func (*ActivityLog_Event_RegionalExitEvent) Reset 

func (m *ActivityLog_Event_RegionalExitEvent) Reset()

func (*ActivityLog_Event_RegionalExitEvent) SetRegionId 

func (m *ActivityLog_Event_RegionalExitEvent) SetRegionId(fv string)

func (*ActivityLog_Event_RegionalExitEvent) SetStatus 

func (m *ActivityLog_Event_RegionalExitEvent) SetStatus(fv *rpc.Status)

func (*ActivityLog_Event_RegionalExitEvent) SetTime 

func (m *ActivityLog_Event_RegionalExitEvent) SetTime(fv *timestamppb.Timestamp)

func (*ActivityLog_Event_RegionalExitEvent) String 

func (m *ActivityLog_Event_RegionalExitEvent) String() string

func (*ActivityLog_Event_RegionalExitEvent) Unmarshal 

func (m *ActivityLog_Event_RegionalExitEvent) Unmarshal(b []byte) error

func (*ActivityLog_Event_RegionalExitEvent) UnmarshalJSON 

func (m *ActivityLog_Event_RegionalExitEvent) UnmarshalJSON(data []byte) error

type ActivityLog_Event_RegionalExitEventPathSelectorRegionId 

type ActivityLog_Event_RegionalExitEventPathSelectorRegionId struct{}

func (ActivityLog_Event_RegionalExitEventPathSelectorRegionId) FieldPath 

func (ActivityLog_Event_RegionalExitEventPathSelectorRegionId) FieldPath() *ActivityLogEventRegionalExitEvent_FieldTerminalPath

func (ActivityLog_Event_RegionalExitEventPathSelectorRegionId) WithArrayOfValues 

func (s ActivityLog_Event_RegionalExitEventPathSelectorRegionId) WithArrayOfValues(values []string) *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_RegionalExitEventPathSelectorRegionId) WithValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorRegionId) WithValue(value string) *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue

type ActivityLog_Event_RegionalExitEventPathSelectorStatus 

type ActivityLog_Event_RegionalExitEventPathSelectorStatus struct{}

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) Code 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) Code() ActivityLog_Event_RegionalExitEventPathSelectorStatusCode

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) Details 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) Details() ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) FieldPath 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) FieldPath() *ActivityLogEventRegionalExitEvent_FieldTerminalPath

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) Message 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) Message() ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithArrayOfValues 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithArrayOfValues(values []*rpc.Status) *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubArrayItemValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubArrayItemValue(subPathArrayItemValue rpc.Status_FieldPathArrayItemValue) *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubArrayOfValues 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubArrayOfValues(subPathArrayOfValues rpc.Status_FieldPathArrayOfValues) *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubPath 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubPath(subPath rpc.Status_FieldPath) *ActivityLogEventRegionalExitEvent_FieldSubPath

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithSubValue(subPathValue rpc.Status_FieldPathValue) *ActivityLogEventRegionalExitEvent_FieldSubPathValue

func (ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatus) WithValue(value *rpc.Status) *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue

type ActivityLog_Event_RegionalExitEventPathSelectorStatusCode 

type ActivityLog_Event_RegionalExitEventPathSelectorStatusCode struct{}

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusCode) FieldPath 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusCode) FieldPath() *ActivityLogEventRegionalExitEvent_FieldSubPath

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusCode) WithArrayOfValues 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatusCode) WithArrayOfValues(values []int32) *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusCode) WithValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatusCode) WithValue(value int32) *ActivityLogEventRegionalExitEvent_FieldSubPathValue

type ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails 

type ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails struct{}

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) FieldPath 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) FieldPath() *ActivityLogEventRegionalExitEvent_FieldSubPath

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) WithArrayOfValues 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) WithArrayOfValues(values [][]*anypb.Any) *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) WithItemValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) WithItemValue(value *anypb.Any) *ActivityLogEventRegionalExitEvent_FieldSubPathArrayItemValue

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) WithValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatusDetails) WithValue(value []*anypb.Any) *ActivityLogEventRegionalExitEvent_FieldSubPathValue

type ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage 

type ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage struct{}

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage) FieldPath 

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage) FieldPath() *ActivityLogEventRegionalExitEvent_FieldSubPath

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage) WithArrayOfValues 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage) WithArrayOfValues(values []string) *ActivityLogEventRegionalExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage) WithValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorStatusMessage) WithValue(value string) *ActivityLogEventRegionalExitEvent_FieldSubPathValue

type ActivityLog_Event_RegionalExitEventPathSelectorTime 

type ActivityLog_Event_RegionalExitEventPathSelectorTime struct{}

func (ActivityLog_Event_RegionalExitEventPathSelectorTime) FieldPath 

func (ActivityLog_Event_RegionalExitEventPathSelectorTime) FieldPath() *ActivityLogEventRegionalExitEvent_FieldTerminalPath

func (ActivityLog_Event_RegionalExitEventPathSelectorTime) WithArrayOfValues 

func (s ActivityLog_Event_RegionalExitEventPathSelectorTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEventRegionalExitEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_RegionalExitEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_RegionalExitEventPathSelectorTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEventRegionalExitEvent_FieldTerminalPathValue

type ActivityLog_Event_RegionalExitEvent_FieldMask 

type ActivityLog_Event_RegionalExitEvent_FieldMask struct {
	Paths []ActivityLogEventRegionalExitEvent_FieldPath
}

func FullActivityLog_Event_RegionalExitEvent_FieldMask 

func FullActivityLog_Event_RegionalExitEvent_FieldMask() *ActivityLog_Event_RegionalExitEvent_FieldMask

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) AppendPath(path ActivityLogEventRegionalExitEvent_FieldPath)

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) FilterInputFields() *ActivityLog_Event_RegionalExitEvent_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) GetPaths() []ActivityLogEventRegionalExitEvent_FieldPath

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) IsFull 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) IsFull() bool

func (ActivityLog_Event_RegionalExitEvent_FieldMask) Marshal 

func (fieldMask ActivityLog_Event_RegionalExitEvent_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Event_RegionalExitEvent_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Event_RegionalExitEvent_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) PathsCount() int

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) Project 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) Project(source *ActivityLog_Event_RegionalExitEvent) *ActivityLog_Event_RegionalExitEvent

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) ProtoMessage()

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) Reset 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) Reset()

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) Set 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) Set(target, source *ActivityLog_Event_RegionalExitEvent)

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) SetRaw 

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

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) Size 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) Size() int

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) String 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) String() string

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) Subtract 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) Subtract(other *ActivityLog_Event_RegionalExitEvent_FieldMask) *ActivityLog_Event_RegionalExitEvent_FieldMask

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Event_RegionalExitEvent_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Event_RegionalExitEvent_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_Event_RegionalServerMessage 

type ActivityLog_Event_RegionalServerMessage struct {
	// Server received response from another server (used for split & merge)
	// which describes PARTIAL result to be sent to the client.
	RegionalServerMessage *ActivityLog_Event_RegionalServerMsgEvent `protobuf:"bytes,4,opt,name=regional_server_message,json=regionalServerMessage,proto3,oneof" firestore:"regionalServerMessage"`
}

type ActivityLog_Event_RegionalServerMsgEvent 

type ActivityLog_Event_RegionalServerMsgEvent struct {

	// Message contents
	Data *anypb.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" firestore:"data"`
	// Time of a message
	Time *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty" firestore:"time"`
	// Region ID where message comes from.
	RegionId string `protobuf:"bytes,3,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty" firestore:"regionId"`
	// contains filtered or unexported fields
}

Describes message received from server in specific region. This type is used only for requests, which receiving server decided to split across many regions. Each regional server sends own response and executing server is responsible for merging all partial results into one. This type does not show what was sent to the client. TODO: No use case for now, just placeholder, no server implementation

func (*ActivityLog_Event_RegionalServerMsgEvent) Clone 

func (o *ActivityLog_Event_RegionalServerMsgEvent) Clone() *ActivityLog_Event_RegionalServerMsgEvent

func (*ActivityLog_Event_RegionalServerMsgEvent) CloneRaw 

func (o *ActivityLog_Event_RegionalServerMsgEvent) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Event_RegionalServerMsgEvent) Descriptor 

func (*ActivityLog_Event_RegionalServerMsgEvent) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Event_RegionalServerMsgEvent.ProtoReflect.Descriptor instead.

func (*ActivityLog_Event_RegionalServerMsgEvent) GetData 

func (m *ActivityLog_Event_RegionalServerMsgEvent) GetData() *anypb.Any

func (*ActivityLog_Event_RegionalServerMsgEvent) GetRegionId 

func (m *ActivityLog_Event_RegionalServerMsgEvent) GetRegionId() string

func (*ActivityLog_Event_RegionalServerMsgEvent) GetTime 

func (m *ActivityLog_Event_RegionalServerMsgEvent) GetTime() *timestamppb.Timestamp

func (*ActivityLog_Event_RegionalServerMsgEvent) GotenMessage 

func (*ActivityLog_Event_RegionalServerMsgEvent) GotenMessage()

func (*ActivityLog_Event_RegionalServerMsgEvent) GotenObjectExt 

func (o *ActivityLog_Event_RegionalServerMsgEvent) GotenObjectExt()

func (*ActivityLog_Event_RegionalServerMsgEvent) GotenValidate 

func (obj *ActivityLog_Event_RegionalServerMsgEvent) GotenValidate() error

func (*ActivityLog_Event_RegionalServerMsgEvent) MakeDiffFieldMask 

func (o *ActivityLog_Event_RegionalServerMsgEvent) MakeDiffFieldMask(other *ActivityLog_Event_RegionalServerMsgEvent) *ActivityLog_Event_RegionalServerMsgEvent_FieldMask

func (*ActivityLog_Event_RegionalServerMsgEvent) MakeFullFieldMask 

func (o *ActivityLog_Event_RegionalServerMsgEvent) MakeFullFieldMask() *ActivityLog_Event_RegionalServerMsgEvent_FieldMask

func (*ActivityLog_Event_RegionalServerMsgEvent) MakeRawDiffFieldMask 

func (o *ActivityLog_Event_RegionalServerMsgEvent) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Event_RegionalServerMsgEvent) MakeRawFullFieldMask 

func (o *ActivityLog_Event_RegionalServerMsgEvent) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Event_RegionalServerMsgEvent) Marshal 

func (m *ActivityLog_Event_RegionalServerMsgEvent) Marshal() ([]byte, error)

func (*ActivityLog_Event_RegionalServerMsgEvent) MarshalJSON 

func (m *ActivityLog_Event_RegionalServerMsgEvent) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_RegionalServerMsgEvent) Merge 

func (o *ActivityLog_Event_RegionalServerMsgEvent) Merge(source *ActivityLog_Event_RegionalServerMsgEvent)

func (*ActivityLog_Event_RegionalServerMsgEvent) MergeRaw 

func (o *ActivityLog_Event_RegionalServerMsgEvent) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Event_RegionalServerMsgEvent) ProtoMessage 

func (*ActivityLog_Event_RegionalServerMsgEvent) ProtoMessage()

func (*ActivityLog_Event_RegionalServerMsgEvent) ProtoReflect 

func (m *ActivityLog_Event_RegionalServerMsgEvent) ProtoReflect() preflect.Message

func (*ActivityLog_Event_RegionalServerMsgEvent) Reset 

func (m *ActivityLog_Event_RegionalServerMsgEvent) Reset()

func (*ActivityLog_Event_RegionalServerMsgEvent) SetData 

func (m *ActivityLog_Event_RegionalServerMsgEvent) SetData(fv *anypb.Any)

func (*ActivityLog_Event_RegionalServerMsgEvent) SetRegionId 

func (m *ActivityLog_Event_RegionalServerMsgEvent) SetRegionId(fv string)

func (*ActivityLog_Event_RegionalServerMsgEvent) SetTime 

func (m *ActivityLog_Event_RegionalServerMsgEvent) SetTime(fv *timestamppb.Timestamp)

func (*ActivityLog_Event_RegionalServerMsgEvent) String 

func (m *ActivityLog_Event_RegionalServerMsgEvent) String() string

func (*ActivityLog_Event_RegionalServerMsgEvent) Unmarshal 

func (m *ActivityLog_Event_RegionalServerMsgEvent) Unmarshal(b []byte) error

func (*ActivityLog_Event_RegionalServerMsgEvent) UnmarshalJSON 

func (m *ActivityLog_Event_RegionalServerMsgEvent) UnmarshalJSON(data []byte) error

type ActivityLog_Event_RegionalServerMsgEventPathSelectorData 

type ActivityLog_Event_RegionalServerMsgEventPathSelectorData struct{}

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorData) FieldPath 

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorData) FieldPath() *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorData) WithArrayOfValues 

func (s ActivityLog_Event_RegionalServerMsgEventPathSelectorData) WithArrayOfValues(values []*anypb.Any) *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorData) WithValue 

func (s ActivityLog_Event_RegionalServerMsgEventPathSelectorData) WithValue(value *anypb.Any) *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue

type ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId 

type ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId struct{}

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId) FieldPath 

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId) FieldPath() *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId) WithArrayOfValues 

func (s ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId) WithArrayOfValues(values []string) *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId) WithValue 

func (s ActivityLog_Event_RegionalServerMsgEventPathSelectorRegionId) WithValue(value string) *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue

type ActivityLog_Event_RegionalServerMsgEventPathSelectorTime 

type ActivityLog_Event_RegionalServerMsgEventPathSelectorTime struct{}

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorTime) FieldPath 

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorTime) FieldPath() *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPath

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorTime) WithArrayOfValues 

func (s ActivityLog_Event_RegionalServerMsgEventPathSelectorTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_RegionalServerMsgEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_RegionalServerMsgEventPathSelectorTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEventRegionalServerMsgEvent_FieldTerminalPathValue

type ActivityLog_Event_RegionalServerMsgEvent_FieldMask 

type ActivityLog_Event_RegionalServerMsgEvent_FieldMask struct {
	Paths []ActivityLogEventRegionalServerMsgEvent_FieldPath
}

func FullActivityLog_Event_RegionalServerMsgEvent_FieldMask 

func FullActivityLog_Event_RegionalServerMsgEvent_FieldMask() *ActivityLog_Event_RegionalServerMsgEvent_FieldMask

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) AppendPath(path ActivityLogEventRegionalServerMsgEvent_FieldPath)

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) FilterInputFields() *ActivityLog_Event_RegionalServerMsgEvent_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) GetPaths() []ActivityLogEventRegionalServerMsgEvent_FieldPath

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) IsFull 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) IsFull() bool

func (ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Marshal 

func (fieldMask ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Event_RegionalServerMsgEvent_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Event_RegionalServerMsgEvent_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) PathsCount() int

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Project 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Project(source *ActivityLog_Event_RegionalServerMsgEvent) *ActivityLog_Event_RegionalServerMsgEvent

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ProtoMessage()

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Reset 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Reset()

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Set 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Set(target, source *ActivityLog_Event_RegionalServerMsgEvent)

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) SetRaw 

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

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Size 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Size() int

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) String 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) String() string

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Subtract 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Subtract(other *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) *ActivityLog_Event_RegionalServerMsgEvent_FieldMask

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Event_RegionalServerMsgEvent_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Event_RegionalServerMsgEvent_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_Event_ServerMessage 

type ActivityLog_Event_ServerMessage struct {
	// Server message sent event
	ServerMessage *ActivityLog_Event_ServerMsgEvent `protobuf:"bytes,2,opt,name=server_message,json=serverMessage,proto3,oneof" firestore:"serverMessage"`
}

type ActivityLog_Event_ServerMsgEvent 

type ActivityLog_Event_ServerMsgEvent struct {

	// Message contents
	Data *anypb.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" firestore:"data"`
	// Time of a message
	Time *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty" firestore:"time"`
	// contains filtered or unexported fields
}

Describes server message event

func (*ActivityLog_Event_ServerMsgEvent) Clone 

func (o *ActivityLog_Event_ServerMsgEvent) Clone() *ActivityLog_Event_ServerMsgEvent

func (*ActivityLog_Event_ServerMsgEvent) CloneRaw 

func (o *ActivityLog_Event_ServerMsgEvent) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Event_ServerMsgEvent) Descriptor 

func (*ActivityLog_Event_ServerMsgEvent) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Event_ServerMsgEvent.ProtoReflect.Descriptor instead.

func (*ActivityLog_Event_ServerMsgEvent) GetData 

func (m *ActivityLog_Event_ServerMsgEvent) GetData() *anypb.Any

func (*ActivityLog_Event_ServerMsgEvent) GetTime 

func (m *ActivityLog_Event_ServerMsgEvent) GetTime() *timestamppb.Timestamp

func (*ActivityLog_Event_ServerMsgEvent) GotenMessage 

func (*ActivityLog_Event_ServerMsgEvent) GotenMessage()

func (*ActivityLog_Event_ServerMsgEvent) GotenObjectExt 

func (o *ActivityLog_Event_ServerMsgEvent) GotenObjectExt()

func (*ActivityLog_Event_ServerMsgEvent) GotenValidate 

func (obj *ActivityLog_Event_ServerMsgEvent) GotenValidate() error

func (*ActivityLog_Event_ServerMsgEvent) MakeDiffFieldMask 

func (o *ActivityLog_Event_ServerMsgEvent) MakeDiffFieldMask(other *ActivityLog_Event_ServerMsgEvent) *ActivityLog_Event_ServerMsgEvent_FieldMask

func (*ActivityLog_Event_ServerMsgEvent) MakeFullFieldMask 

func (o *ActivityLog_Event_ServerMsgEvent) MakeFullFieldMask() *ActivityLog_Event_ServerMsgEvent_FieldMask

func (*ActivityLog_Event_ServerMsgEvent) MakeRawDiffFieldMask 

func (o *ActivityLog_Event_ServerMsgEvent) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Event_ServerMsgEvent) MakeRawFullFieldMask 

func (o *ActivityLog_Event_ServerMsgEvent) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Event_ServerMsgEvent) Marshal 

func (m *ActivityLog_Event_ServerMsgEvent) Marshal() ([]byte, error)

func (*ActivityLog_Event_ServerMsgEvent) MarshalJSON 

func (m *ActivityLog_Event_ServerMsgEvent) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_ServerMsgEvent) Merge 

func (o *ActivityLog_Event_ServerMsgEvent) Merge(source *ActivityLog_Event_ServerMsgEvent)

func (*ActivityLog_Event_ServerMsgEvent) MergeRaw 

func (o *ActivityLog_Event_ServerMsgEvent) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Event_ServerMsgEvent) ProtoMessage 

func (*ActivityLog_Event_ServerMsgEvent) ProtoMessage()

func (*ActivityLog_Event_ServerMsgEvent) ProtoReflect 

func (m *ActivityLog_Event_ServerMsgEvent) ProtoReflect() preflect.Message

func (*ActivityLog_Event_ServerMsgEvent) Reset 

func (m *ActivityLog_Event_ServerMsgEvent) Reset()

func (*ActivityLog_Event_ServerMsgEvent) SetData 

func (m *ActivityLog_Event_ServerMsgEvent) SetData(fv *anypb.Any)

func (*ActivityLog_Event_ServerMsgEvent) SetTime 

func (m *ActivityLog_Event_ServerMsgEvent) SetTime(fv *timestamppb.Timestamp)

func (*ActivityLog_Event_ServerMsgEvent) String 

func (m *ActivityLog_Event_ServerMsgEvent) String() string

func (*ActivityLog_Event_ServerMsgEvent) Unmarshal 

func (m *ActivityLog_Event_ServerMsgEvent) Unmarshal(b []byte) error

func (*ActivityLog_Event_ServerMsgEvent) UnmarshalJSON 

func (m *ActivityLog_Event_ServerMsgEvent) UnmarshalJSON(data []byte) error

type ActivityLog_Event_ServerMsgEventPathSelectorData 

type ActivityLog_Event_ServerMsgEventPathSelectorData struct{}

func (ActivityLog_Event_ServerMsgEventPathSelectorData) FieldPath 

func (ActivityLog_Event_ServerMsgEventPathSelectorData) FieldPath() *ActivityLogEventServerMsgEvent_FieldTerminalPath

func (ActivityLog_Event_ServerMsgEventPathSelectorData) WithArrayOfValues 

func (s ActivityLog_Event_ServerMsgEventPathSelectorData) WithArrayOfValues(values []*anypb.Any) *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ServerMsgEventPathSelectorData) WithValue 

func (s ActivityLog_Event_ServerMsgEventPathSelectorData) WithValue(value *anypb.Any) *ActivityLogEventServerMsgEvent_FieldTerminalPathValue

type ActivityLog_Event_ServerMsgEventPathSelectorTime 

type ActivityLog_Event_ServerMsgEventPathSelectorTime struct{}

func (ActivityLog_Event_ServerMsgEventPathSelectorTime) FieldPath 

func (ActivityLog_Event_ServerMsgEventPathSelectorTime) FieldPath() *ActivityLogEventServerMsgEvent_FieldTerminalPath

func (ActivityLog_Event_ServerMsgEventPathSelectorTime) WithArrayOfValues 

func (s ActivityLog_Event_ServerMsgEventPathSelectorTime) WithArrayOfValues(values []*timestamppb.Timestamp) *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ServerMsgEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_ServerMsgEventPathSelectorTime) WithValue(value *timestamppb.Timestamp) *ActivityLogEventServerMsgEvent_FieldTerminalPathValue

type ActivityLog_Event_ServerMsgEvent_FieldMask 

type ActivityLog_Event_ServerMsgEvent_FieldMask struct {
	Paths []ActivityLogEventServerMsgEvent_FieldPath
}

func FullActivityLog_Event_ServerMsgEvent_FieldMask 

func FullActivityLog_Event_ServerMsgEvent_FieldMask() *ActivityLog_Event_ServerMsgEvent_FieldMask

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) AppendPath(path ActivityLogEventServerMsgEvent_FieldPath)

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) FilterInputFields() *ActivityLog_Event_ServerMsgEvent_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) GetPaths() []ActivityLogEventServerMsgEvent_FieldPath

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) IsFull 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) IsFull() bool

func (ActivityLog_Event_ServerMsgEvent_FieldMask) Marshal 

func (fieldMask ActivityLog_Event_ServerMsgEvent_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Event_ServerMsgEvent_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Event_ServerMsgEvent_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) PathsCount() int

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) Project 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) Project(source *ActivityLog_Event_ServerMsgEvent) *ActivityLog_Event_ServerMsgEvent

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) ProtoMessage()

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) Reset 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) Reset()

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) Set 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) Set(target, source *ActivityLog_Event_ServerMsgEvent)

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) SetRaw 

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

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) Size 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) Size() int

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) String 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) String() string

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) Subtract 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) Subtract(other *ActivityLog_Event_ServerMsgEvent_FieldMask) *ActivityLog_Event_ServerMsgEvent_FieldMask

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Event_ServerMsgEvent_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Event_ServerMsgEvent_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_FieldMask 

type ActivityLog_FieldMask struct {
	Paths []ActivityLog_FieldPath
}

func FullActivityLog_FieldMask 

func FullActivityLog_FieldMask() *ActivityLog_FieldMask

func ResourceViewFieldMask 

func ResourceViewFieldMask(viewName view.View, extraMask *ActivityLog_FieldMask) *ActivityLog_FieldMask

func (*ActivityLog_FieldMask) AppendPath 

func (fieldMask *ActivityLog_FieldMask) AppendPath(path ActivityLog_FieldPath)

func (*ActivityLog_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_FieldMask) FilterInputFields() *ActivityLog_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_FieldMask) GetPaths 

func (fieldMask *ActivityLog_FieldMask) GetPaths() []ActivityLog_FieldPath

func (*ActivityLog_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_FieldMask) IsFull 

func (fieldMask *ActivityLog_FieldMask) IsFull() bool

func (ActivityLog_FieldMask) Marshal 

func (fieldMask ActivityLog_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_FieldMask) PathsCount 

func (fieldMask *ActivityLog_FieldMask) PathsCount() int

func (*ActivityLog_FieldMask) Project 

func (fieldMask *ActivityLog_FieldMask) Project(source *ActivityLog) *ActivityLog

func (*ActivityLog_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_FieldMask) ProtoMessage()

func (*ActivityLog_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_FieldMask) Reset 

func (fieldMask *ActivityLog_FieldMask) Reset()

func (*ActivityLog_FieldMask) Set 

func (fieldMask *ActivityLog_FieldMask) Set(target, source *ActivityLog)

func (*ActivityLog_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_FieldMask) SetRaw 

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

func (*ActivityLog_FieldMask) Size 

func (fieldMask *ActivityLog_FieldMask) Size() int

func (*ActivityLog_FieldMask) String 

func (fieldMask *ActivityLog_FieldMask) String() string

func (*ActivityLog_FieldMask) Subtract 

func (fieldMask *ActivityLog_FieldMask) Subtract(other *ActivityLog_FieldMask) *ActivityLog_FieldMask

func (*ActivityLog_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_FieldPath 

type ActivityLog_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLog_FieldPathSelector
	Get(source *ActivityLog) []interface{}
	GetSingle(source *ActivityLog) (interface{}, bool)
	ClearValue(item *ActivityLog)

	// Those methods build corresponding ActivityLog_FieldPathValue
	// (or array of values) and holds passed value. Panics if injected type is incorrect.
	WithIValue(value interface{}) ActivityLog_FieldPathValue
	WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues
	WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue
}

FieldPath provides implementation to handle https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto

func BuildActivityLog_FieldPath 

func BuildActivityLog_FieldPath(fp gotenobject.RawFieldPath) (ActivityLog_FieldPath, error)

func MustParseActivityLog_FieldPath 

func MustParseActivityLog_FieldPath(rawField string) ActivityLog_FieldPath

func ParseActivityLog_FieldPath 

func ParseActivityLog_FieldPath(rawField string) (ActivityLog_FieldPath, error)

type ActivityLog_FieldPathArrayItemValue 

type ActivityLog_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLog_FieldPath
	ContainsValue(*ActivityLog) bool
}

ActivityLog_FieldPathArrayItemValue allows storing single item in Path-specific values for ActivityLog according to their type Present only for array (repeated) types.

func MustParseActivityLog_FieldPathArrayItemValue 

func MustParseActivityLog_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLog_FieldPathArrayItemValue

func ParseActivityLog_FieldPathArrayItemValue 

func ParseActivityLog_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLog_FieldPathArrayItemValue, error)

ParseActivityLog_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLog_FieldPathArrayOfValues 

type ActivityLog_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLog_FieldPath
}

ActivityLog_FieldPathArrayOfValues allows storing slice of values for ActivityLog fields according to their type

func MustParseActivityLog_FieldPathArrayOfValues 

func MustParseActivityLog_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLog_FieldPathArrayOfValues

func ParseActivityLog_FieldPathArrayOfValues 

func ParseActivityLog_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLog_FieldPathArrayOfValues, error)

type ActivityLog_FieldPathMap 

type ActivityLog_FieldPathMap struct {
	// contains filtered or unexported fields
}

FieldPath for map type with additional Key information

func (*ActivityLog_FieldPathMap) ClearValue 

func (fpm *ActivityLog_FieldPathMap) ClearValue(item *ActivityLog)

func (*ActivityLog_FieldPathMap) ClearValueRaw 

func (fpm *ActivityLog_FieldPathMap) ClearValueRaw(item proto.Message)

func (*ActivityLog_FieldPathMap) Get 

func (fpm *ActivityLog_FieldPathMap) Get(source *ActivityLog) (values []interface{})

Get returns all values pointed by selected field map key from source ActivityLog

func (*ActivityLog_FieldPathMap) GetDefault 

func (fpm *ActivityLog_FieldPathMap) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLog_FieldPathMap) GetRaw 

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

func (*ActivityLog_FieldPathMap) GetSingle 

func (fpm *ActivityLog_FieldPathMap) GetSingle(source *ActivityLog) (interface{}, bool)

GetSingle returns value by selected field map key from source ActivityLog

func (*ActivityLog_FieldPathMap) GetSingleRaw 

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

func (*ActivityLog_FieldPathMap) IsLeaf 

func (fpm *ActivityLog_FieldPathMap) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLog_FieldPathMap) JSONString 

func (fpm *ActivityLog_FieldPathMap) JSONString() string

JSONString returns path representation is JSON convention. Note that map keys are not transformed

func (*ActivityLog_FieldPathMap) Key 

func (fpm *ActivityLog_FieldPathMap) Key() string

func (*ActivityLog_FieldPathMap) Selector 

func (fpm *ActivityLog_FieldPathMap) Selector() ActivityLog_FieldPathSelector

func (*ActivityLog_FieldPathMap) SplitIntoTerminalIPaths 

func (fpm *ActivityLog_FieldPathMap) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLog_FieldPathMap) String 

func (fpm *ActivityLog_FieldPathMap) String() string

String returns path representation in proto convention

func (*ActivityLog_FieldPathMap) WithIArrayItemValue 

func (fpm *ActivityLog_FieldPathMap) WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue

func (*ActivityLog_FieldPathMap) WithIArrayOfValues 

func (fpm *ActivityLog_FieldPathMap) WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues

func (*ActivityLog_FieldPathMap) WithIValue 

func (fpm *ActivityLog_FieldPathMap) WithIValue(value interface{}) ActivityLog_FieldPathValue

func (*ActivityLog_FieldPathMap) WithRawIArrayItemValue 

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

func (*ActivityLog_FieldPathMap) WithRawIArrayOfValues 

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

func (*ActivityLog_FieldPathMap) WithRawIValue 

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

type ActivityLog_FieldPathMapArrayOfValues 

type ActivityLog_FieldPathMapArrayOfValues struct {
	ActivityLog_FieldPathMap
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldPathMapArrayOfValues) AsLabelsArrayOfElementValues 

func (fpmaov *ActivityLog_FieldPathMapArrayOfValues) AsLabelsArrayOfElementValues() ([]string, bool)

func (*ActivityLog_FieldPathMapArrayOfValues) GetRawValues 

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

type ActivityLog_FieldPathMapValue 

type ActivityLog_FieldPathMapValue struct {
	ActivityLog_FieldPathMap
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldPathMapValue) AsLabelsElementValue 

func (fpmv *ActivityLog_FieldPathMapValue) AsLabelsElementValue() (string, bool)

func (*ActivityLog_FieldPathMapValue) CompareWith 

func (fpmv *ActivityLog_FieldPathMapValue) CompareWith(source *ActivityLog) (int, bool)

CompareWith compares value in the 'ActivityLog_FieldPathMapValue' with the value under path in 'ActivityLog'.

func (*ActivityLog_FieldPathMapValue) CompareWithRaw 

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

func (*ActivityLog_FieldPathMapValue) GetRawValue 

func (fpmv *ActivityLog_FieldPathMapValue) GetRawValue() interface{}

GetValue returns value stored under selected field in ActivityLog as interface{}

func (*ActivityLog_FieldPathMapValue) SetTo 

func (fpmv *ActivityLog_FieldPathMapValue) SetTo(target **ActivityLog)

SetTo stores value for selected field in ActivityLog

func (*ActivityLog_FieldPathMapValue) SetToRaw 

func (fpmv *ActivityLog_FieldPathMapValue) SetToRaw(target proto.Message)

type ActivityLog_FieldPathSelector 

type ActivityLog_FieldPathSelector int32
const (
	ActivityLog_FieldPathSelectorName            ActivityLog_FieldPathSelector = 0
	ActivityLog_FieldPathSelectorScope           ActivityLog_FieldPathSelector = 1
	ActivityLog_FieldPathSelectorRequestId       ActivityLog_FieldPathSelector = 2
	ActivityLog_FieldPathSelectorAuthentication  ActivityLog_FieldPathSelector = 3
	ActivityLog_FieldPathSelectorAuthorization   ActivityLog_FieldPathSelector = 4
	ActivityLog_FieldPathSelectorService         ActivityLog_FieldPathSelector = 5
	ActivityLog_FieldPathSelectorMethod          ActivityLog_FieldPathSelector = 6
	ActivityLog_FieldPathSelectorRequestMetadata ActivityLog_FieldPathSelector = 7
	ActivityLog_FieldPathSelectorRequestRouting  ActivityLog_FieldPathSelector = 8
	ActivityLog_FieldPathSelectorResource        ActivityLog_FieldPathSelector = 9
	ActivityLog_FieldPathSelectorCategory        ActivityLog_FieldPathSelector = 10
	ActivityLog_FieldPathSelectorLabels          ActivityLog_FieldPathSelector = 11
	ActivityLog_FieldPathSelectorEvents          ActivityLog_FieldPathSelector = 12
)

func (ActivityLog_FieldPathSelector) String 

func (s ActivityLog_FieldPathSelector) String() string

type ActivityLog_FieldPathValue 

type ActivityLog_FieldPathValue interface {
	ActivityLog_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog)
	CompareWith(*ActivityLog) (cmp int, comparable bool)
}

ActivityLog_FieldPathValue allows storing values for ActivityLog fields according to their type

func MustParseActivityLog_FieldPathValue 

func MustParseActivityLog_FieldPathValue(pathStr, valueStr string) ActivityLog_FieldPathValue

func ParseActivityLog_FieldPathValue 

func ParseActivityLog_FieldPathValue(pathStr, valueStr string) (ActivityLog_FieldPathValue, error)

type ActivityLog_FieldSubPath 

type ActivityLog_FieldSubPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldSubPath) AsAuthenticationSubPath 

func (fps *ActivityLog_FieldSubPath) AsAuthenticationSubPath() (common.Authentication_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsAuthorizationSubPath 

func (fps *ActivityLog_FieldSubPath) AsAuthorizationSubPath() (common.Authorization_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsEventsSubPath 

func (fps *ActivityLog_FieldSubPath) AsEventsSubPath() (ActivityLogEvent_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsMethodSubPath 

func (fps *ActivityLog_FieldSubPath) AsMethodSubPath() (ActivityLogMethod_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsRequestMetadataSubPath 

func (fps *ActivityLog_FieldSubPath) AsRequestMetadataSubPath() (ActivityLogRequestMetadata_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsRequestRoutingSubPath 

func (fps *ActivityLog_FieldSubPath) AsRequestRoutingSubPath() (ActivityLogRequestRouting_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsResourceSubPath 

func (fps *ActivityLog_FieldSubPath) AsResourceSubPath() (ActivityLogResource_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsServiceSubPath 

func (fps *ActivityLog_FieldSubPath) AsServiceSubPath() (common.ServiceData_FieldPath, bool)

func (*ActivityLog_FieldSubPath) ClearValue 

func (fps *ActivityLog_FieldSubPath) ClearValue(item *ActivityLog)

func (*ActivityLog_FieldSubPath) ClearValueRaw 

func (fps *ActivityLog_FieldSubPath) ClearValueRaw(item proto.Message)

func (*ActivityLog_FieldSubPath) Get 

func (fps *ActivityLog_FieldSubPath) Get(source *ActivityLog) (values []interface{})

Get returns all values pointed by selected field from source ActivityLog

func (*ActivityLog_FieldSubPath) GetDefault 

func (fps *ActivityLog_FieldSubPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLog_FieldSubPath) GetRaw 

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

func (*ActivityLog_FieldSubPath) GetSingle 

func (fps *ActivityLog_FieldSubPath) GetSingle(source *ActivityLog) (interface{}, bool)

GetSingle returns value of selected field from source ActivityLog

func (*ActivityLog_FieldSubPath) GetSingleRaw 

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

func (*ActivityLog_FieldSubPath) IsLeaf 

func (fps *ActivityLog_FieldSubPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLog_FieldSubPath) JSONString 

func (fps *ActivityLog_FieldSubPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLog_FieldSubPath) Selector 

func (fps *ActivityLog_FieldSubPath) Selector() ActivityLog_FieldPathSelector

func (*ActivityLog_FieldSubPath) SplitIntoTerminalIPaths 

func (fps *ActivityLog_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLog_FieldSubPath) String 

func (fps *ActivityLog_FieldSubPath) String() string

String returns path representation in proto convention

func (*ActivityLog_FieldSubPath) WithIArrayItemValue 

func (fps *ActivityLog_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue

func (*ActivityLog_FieldSubPath) WithIArrayOfValues 

func (fps *ActivityLog_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues

func (*ActivityLog_FieldSubPath) WithIValue 

func (fps *ActivityLog_FieldSubPath) WithIValue(value interface{}) ActivityLog_FieldPathValue

func (*ActivityLog_FieldSubPath) WithRawIArrayItemValue 

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

func (*ActivityLog_FieldSubPath) WithRawIArrayOfValues 

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

func (*ActivityLog_FieldSubPath) WithRawIValue 

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

type ActivityLog_FieldSubPathArrayItemValue 

type ActivityLog_FieldSubPathArrayItemValue struct {
	ActivityLog_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldSubPathArrayItemValue) AsAuthenticationPathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsAuthenticationPathItemValue() (common.Authentication_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsAuthorizationPathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsAuthorizationPathItemValue() (common.Authorization_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsEventsPathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsEventsPathItemValue() (ActivityLogEvent_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsMethodPathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsMethodPathItemValue() (ActivityLogMethod_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsRequestMetadataPathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsRequestMetadataPathItemValue() (ActivityLogRequestMetadata_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsRequestRoutingPathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsRequestRoutingPathItemValue() (ActivityLogRequestRouting_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsResourcePathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsResourcePathItemValue() (ActivityLogResource_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsServicePathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsServicePathItemValue() (common.ServiceData_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) ContainsValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog) bool

Contains returns a boolean indicating if value that is being held is present in given 'ActivityLog'

func (*ActivityLog_FieldSubPathArrayItemValue) GetRawItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored array item value

type ActivityLog_FieldSubPathArrayOfValues 

type ActivityLog_FieldSubPathArrayOfValues struct {
	ActivityLog_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldSubPathArrayOfValues) AsAuthenticationPathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsAuthenticationPathArrayOfValues() (common.Authentication_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsAuthorizationPathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsAuthorizationPathArrayOfValues() (common.Authorization_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsEventsPathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsEventsPathArrayOfValues() (ActivityLogEvent_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsMethodPathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsMethodPathArrayOfValues() (ActivityLogMethod_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsRequestMetadataPathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsRequestMetadataPathArrayOfValues() (ActivityLogRequestMetadata_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsRequestRoutingPathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsRequestRoutingPathArrayOfValues() (ActivityLogRequestRouting_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (ActivityLogResource_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsServicePathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsServicePathArrayOfValues() (common.ServiceData_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) GetRawValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) GetRawValues() []interface{}

type ActivityLog_FieldSubPathValue 

type ActivityLog_FieldSubPathValue struct {
	ActivityLog_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldSubPathValue) AsAuthenticationPathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsAuthenticationPathValue() (common.Authentication_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsAuthorizationPathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsAuthorizationPathValue() (common.Authorization_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsEventsPathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsEventsPathValue() (ActivityLogEvent_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsMethodPathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsMethodPathValue() (ActivityLogMethod_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsRequestMetadataPathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsRequestMetadataPathValue() (ActivityLogRequestMetadata_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsRequestRoutingPathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsRequestRoutingPathValue() (ActivityLogRequestRouting_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsResourcePathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsResourcePathValue() (ActivityLogResource_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsServicePathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsServicePathValue() (common.ServiceData_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) CompareWith 

func (fpvs *ActivityLog_FieldSubPathValue) CompareWith(source *ActivityLog) (int, bool)

func (*ActivityLog_FieldSubPathValue) CompareWithRaw 

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

func (*ActivityLog_FieldSubPathValue) GetRawValue 

func (fpvs *ActivityLog_FieldSubPathValue) GetRawValue() interface{}

func (*ActivityLog_FieldSubPathValue) SetTo 

func (fpvs *ActivityLog_FieldSubPathValue) SetTo(target **ActivityLog)

func (*ActivityLog_FieldSubPathValue) SetToRaw 

func (fpvs *ActivityLog_FieldSubPathValue) SetToRaw(target proto.Message)

type ActivityLog_FieldTerminalPath 

type ActivityLog_FieldTerminalPath struct {
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldTerminalPath) ClearValue 

func (fp *ActivityLog_FieldTerminalPath) ClearValue(item *ActivityLog)

func (*ActivityLog_FieldTerminalPath) ClearValueRaw 

func (fp *ActivityLog_FieldTerminalPath) ClearValueRaw(item proto.Message)

func (*ActivityLog_FieldTerminalPath) Get 

func (fp *ActivityLog_FieldTerminalPath) Get(source *ActivityLog) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog

func (*ActivityLog_FieldTerminalPath) GetDefault 

func (fp *ActivityLog_FieldTerminalPath) GetDefault() interface{}

GetDefault returns a default value of the field type

func (*ActivityLog_FieldTerminalPath) GetRaw 

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

func (*ActivityLog_FieldTerminalPath) GetSingle 

func (fp *ActivityLog_FieldTerminalPath) GetSingle(source *ActivityLog) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog

func (*ActivityLog_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLog_FieldTerminalPath) IsLeaf 

func (fp *ActivityLog_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLog_FieldTerminalPath) JSONString 

func (fp *ActivityLog_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLog_FieldTerminalPath) Selector 

func (fp *ActivityLog_FieldTerminalPath) Selector() ActivityLog_FieldPathSelector

func (*ActivityLog_FieldTerminalPath) SplitIntoTerminalIPaths 

func (fp *ActivityLog_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath

func (*ActivityLog_FieldTerminalPath) String 

func (fp *ActivityLog_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLog_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLog_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLog_FieldPathArrayItemValue

func (*ActivityLog_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLog_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLog_FieldPathArrayOfValues

func (*ActivityLog_FieldTerminalPath) WithIValue 

func (fp *ActivityLog_FieldTerminalPath) WithIValue(value interface{}) ActivityLog_FieldPathValue

func (*ActivityLog_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLog_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLog_FieldTerminalPath) WithRawIValue 

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

type ActivityLog_FieldTerminalPathArrayItemValue 

type ActivityLog_FieldTerminalPathArrayItemValue struct {
	ActivityLog_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldTerminalPathArrayItemValue) AsEventsItemValue 

func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) AsEventsItemValue() (*ActivityLog_Event, bool)

func (*ActivityLog_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog) bool

Contains returns a boolean indicating if value that is being held is present in given 'ActivityLog'

func (*ActivityLog_FieldTerminalPathArrayItemValue) GetRawItemValue 

func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{}

GetRawValue returns stored element value for array in object ActivityLog as interface{}

func (*ActivityLog_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLog_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog) (interface{}, bool)

func (*ActivityLog_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLog_FieldTerminalPathArrayOfValues 

type ActivityLog_FieldTerminalPathArrayOfValues struct {
	ActivityLog_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsAuthenticationArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsAuthenticationArrayOfValues() ([]*common.Authentication, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsAuthorizationArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsAuthorizationArrayOfValues() ([]*common.Authorization, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsCategoryArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsCategoryArrayOfValues() ([]ActivityLog_Category, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsEventsArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsEventsArrayOfValues() ([][]*ActivityLog_Event, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsLabelsArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsLabelsArrayOfValues() ([]map[string]string, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsMethodArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsMethodArrayOfValues() ([]*ActivityLog_Method, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsNameArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]*Name, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsRequestIdArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsRequestIdArrayOfValues() ([]uint64, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsRequestMetadataArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsRequestMetadataArrayOfValues() ([]*ActivityLog_RequestMetadata, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsRequestRoutingArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsRequestRoutingArrayOfValues() ([]*ActivityLog_RequestRouting, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*ActivityLog_Resource, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsScopeArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsScopeArrayOfValues() ([]string, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*common.ServiceData, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLog_FieldTerminalPathValue 

type ActivityLog_FieldTerminalPathValue struct {
	ActivityLog_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLog_FieldTerminalPathValue) AsAuthenticationValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsAuthenticationValue() (*common.Authentication, bool)

func (*ActivityLog_FieldTerminalPathValue) AsAuthorizationValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsAuthorizationValue() (*common.Authorization, bool)

func (*ActivityLog_FieldTerminalPathValue) AsCategoryValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsCategoryValue() (ActivityLog_Category, bool)

func (*ActivityLog_FieldTerminalPathValue) AsEventsValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsEventsValue() ([]*ActivityLog_Event, bool)

func (*ActivityLog_FieldTerminalPathValue) AsLabelsValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsLabelsValue() (map[string]string, bool)

func (*ActivityLog_FieldTerminalPathValue) AsMethodValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsMethodValue() (*ActivityLog_Method, bool)

func (*ActivityLog_FieldTerminalPathValue) AsNameValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsNameValue() (*Name, bool)

func (*ActivityLog_FieldTerminalPathValue) AsRequestIdValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsRequestIdValue() (uint64, bool)

func (*ActivityLog_FieldTerminalPathValue) AsRequestMetadataValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsRequestMetadataValue() (*ActivityLog_RequestMetadata, bool)

func (*ActivityLog_FieldTerminalPathValue) AsRequestRoutingValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsRequestRoutingValue() (*ActivityLog_RequestRouting, bool)

func (*ActivityLog_FieldTerminalPathValue) AsResourceValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsResourceValue() (*ActivityLog_Resource, bool)

func (*ActivityLog_FieldTerminalPathValue) AsScopeValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsScopeValue() (string, bool)

func (*ActivityLog_FieldTerminalPathValue) AsServiceValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsServiceValue() (*common.ServiceData, bool)

func (*ActivityLog_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLog_FieldTerminalPathValue) CompareWith(source *ActivityLog) (int, bool)

CompareWith compares value in the 'ActivityLog_FieldTerminalPathValue' with the value under path in 'ActivityLog'.

func (*ActivityLog_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLog_FieldTerminalPathValue) GetRawValue 

func (fpv *ActivityLog_FieldTerminalPathValue) GetRawValue() interface{}

GetRawValue returns raw value stored under selected path for 'ActivityLog' as interface{}

func (*ActivityLog_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLog_FieldTerminalPathValue) SetTo(target **ActivityLog)

SetTo stores value for selected field for object ActivityLog

func (*ActivityLog_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLog_FieldTerminalPathValue) SetToRaw(target proto.Message)

type ActivityLog_Method 

type ActivityLog_Method struct {

	// Type name of a method, for example "UpdateRoleBinding".
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty" firestore:"type"`
	// Version in which method was executed.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty" firestore:"version"`
	// contains filtered or unexported fields
}

Description of the executed method

func (*ActivityLog_Method) Clone 

func (o *ActivityLog_Method) Clone() *ActivityLog_Method

func (*ActivityLog_Method) CloneRaw 

func (o *ActivityLog_Method) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Method) Descriptor 

func (*ActivityLog_Method) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Method.ProtoReflect.Descriptor instead.

func (*ActivityLog_Method) GetType 

func (m *ActivityLog_Method) GetType() string

func (*ActivityLog_Method) GetVersion 

func (m *ActivityLog_Method) GetVersion() string

func (*ActivityLog_Method) GotenMessage 

func (*ActivityLog_Method) GotenMessage()

func (*ActivityLog_Method) GotenObjectExt 

func (o *ActivityLog_Method) GotenObjectExt()

func (*ActivityLog_Method) GotenValidate 

func (obj *ActivityLog_Method) GotenValidate() error

func (*ActivityLog_Method) MakeDiffFieldMask 

func (o *ActivityLog_Method) MakeDiffFieldMask(other *ActivityLog_Method) *ActivityLog_Method_FieldMask

func (*ActivityLog_Method) MakeFullFieldMask 

func (o *ActivityLog_Method) MakeFullFieldMask() *ActivityLog_Method_FieldMask

func (*ActivityLog_Method) MakeRawDiffFieldMask 

func (o *ActivityLog_Method) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Method) MakeRawFullFieldMask 

func (o *ActivityLog_Method) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Method) Marshal 

func (m *ActivityLog_Method) Marshal() ([]byte, error)

func (*ActivityLog_Method) MarshalJSON 

func (m *ActivityLog_Method) MarshalJSON() ([]byte, error)

func (*ActivityLog_Method) Merge 

func (o *ActivityLog_Method) Merge(source *ActivityLog_Method)

func (*ActivityLog_Method) MergeRaw 

func (o *ActivityLog_Method) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Method) ProtoMessage 

func (*ActivityLog_Method) ProtoMessage()

func (*ActivityLog_Method) ProtoReflect 

func (m *ActivityLog_Method) ProtoReflect() preflect.Message

func (*ActivityLog_Method) Reset 

func (m *ActivityLog_Method) Reset()

func (*ActivityLog_Method) SetType 

func (m *ActivityLog_Method) SetType(fv string)

func (*ActivityLog_Method) SetVersion 

func (m *ActivityLog_Method) SetVersion(fv string)

func (*ActivityLog_Method) String 

func (m *ActivityLog_Method) String() string

func (*ActivityLog_Method) Unmarshal 

func (m *ActivityLog_Method) Unmarshal(b []byte) error

func (*ActivityLog_Method) UnmarshalJSON 

func (m *ActivityLog_Method) UnmarshalJSON(data []byte) error

type ActivityLog_MethodPathSelectorType 

type ActivityLog_MethodPathSelectorType struct{}

func (ActivityLog_MethodPathSelectorType) FieldPath 

func (ActivityLog_MethodPathSelectorType) FieldPath() *ActivityLogMethod_FieldTerminalPath

func (ActivityLog_MethodPathSelectorType) WithArrayOfValues 

func (s ActivityLog_MethodPathSelectorType) WithArrayOfValues(values []string) *ActivityLogMethod_FieldTerminalPathArrayOfValues

func (ActivityLog_MethodPathSelectorType) WithValue 

func (s ActivityLog_MethodPathSelectorType) WithValue(value string) *ActivityLogMethod_FieldTerminalPathValue

type ActivityLog_MethodPathSelectorVersion 

type ActivityLog_MethodPathSelectorVersion struct{}

func (ActivityLog_MethodPathSelectorVersion) FieldPath 

func (ActivityLog_MethodPathSelectorVersion) FieldPath() *ActivityLogMethod_FieldTerminalPath

func (ActivityLog_MethodPathSelectorVersion) WithArrayOfValues 

func (s ActivityLog_MethodPathSelectorVersion) WithArrayOfValues(values []string) *ActivityLogMethod_FieldTerminalPathArrayOfValues

func (ActivityLog_MethodPathSelectorVersion) WithValue 

func (s ActivityLog_MethodPathSelectorVersion) WithValue(value string) *ActivityLogMethod_FieldTerminalPathValue

type ActivityLog_Method_FieldMask 

type ActivityLog_Method_FieldMask struct {
	Paths []ActivityLogMethod_FieldPath
}

func FullActivityLog_Method_FieldMask 

func FullActivityLog_Method_FieldMask() *ActivityLog_Method_FieldMask

func (*ActivityLog_Method_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Method_FieldMask) AppendPath(path ActivityLogMethod_FieldPath)

func (*ActivityLog_Method_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Method_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Method_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Method_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Method_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Method_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Method_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Method_FieldMask) FilterInputFields() *ActivityLog_Method_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Method_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Method_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Method_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Method_FieldMask) GetPaths() []ActivityLogMethod_FieldPath

func (*ActivityLog_Method_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Method_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Method_FieldMask) IsFull 

func (fieldMask *ActivityLog_Method_FieldMask) IsFull() bool

func (ActivityLog_Method_FieldMask) Marshal 

func (fieldMask ActivityLog_Method_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Method_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Method_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Method_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Method_FieldMask) PathsCount() int

func (*ActivityLog_Method_FieldMask) Project 

func (fieldMask *ActivityLog_Method_FieldMask) Project(source *ActivityLog_Method) *ActivityLog_Method

func (*ActivityLog_Method_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Method_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Method_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Method_FieldMask) ProtoMessage()

func (*ActivityLog_Method_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Method_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Method_FieldMask) Reset 

func (fieldMask *ActivityLog_Method_FieldMask) Reset()

func (*ActivityLog_Method_FieldMask) Set 

func (fieldMask *ActivityLog_Method_FieldMask) Set(target, source *ActivityLog_Method)

func (*ActivityLog_Method_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Method_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Method_FieldMask) SetRaw 

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

func (*ActivityLog_Method_FieldMask) Size 

func (fieldMask *ActivityLog_Method_FieldMask) Size() int

func (*ActivityLog_Method_FieldMask) String 

func (fieldMask *ActivityLog_Method_FieldMask) String() string

func (*ActivityLog_Method_FieldMask) Subtract 

func (fieldMask *ActivityLog_Method_FieldMask) Subtract(other *ActivityLog_Method_FieldMask) *ActivityLog_Method_FieldMask

func (*ActivityLog_Method_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Method_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Method_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Method_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Method_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Method_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Method_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Method_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_RequestMetadata 

type ActivityLog_RequestMetadata struct {

	// Source IP from where request came
	IpAddress string `protobuf:"bytes,1,opt,name=ip_address,json=ipAddress,proto3" json:"ip_address,omitempty" firestore:"ipAddress"`
	// Agent used by the request caller
	UserAgent string `protobuf:"bytes,2,opt,name=user_agent,json=userAgent,proto3" json:"user_agent,omitempty" firestore:"userAgent"`
	// contains filtered or unexported fields
}

Additional information about request caller

func (*ActivityLog_RequestMetadata) Clone 

func (o *ActivityLog_RequestMetadata) Clone() *ActivityLog_RequestMetadata

func (*ActivityLog_RequestMetadata) CloneRaw 

func (o *ActivityLog_RequestMetadata) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_RequestMetadata) Descriptor 

func (*ActivityLog_RequestMetadata) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_RequestMetadata.ProtoReflect.Descriptor instead.

func (*ActivityLog_RequestMetadata) GetIpAddress 

func (m *ActivityLog_RequestMetadata) GetIpAddress() string

func (*ActivityLog_RequestMetadata) GetUserAgent 

func (m *ActivityLog_RequestMetadata) GetUserAgent() string

func (*ActivityLog_RequestMetadata) GotenMessage 

func (*ActivityLog_RequestMetadata) GotenMessage()

func (*ActivityLog_RequestMetadata) GotenObjectExt 

func (o *ActivityLog_RequestMetadata) GotenObjectExt()

func (*ActivityLog_RequestMetadata) GotenValidate 

func (obj *ActivityLog_RequestMetadata) GotenValidate() error

func (*ActivityLog_RequestMetadata) MakeDiffFieldMask 

func (o *ActivityLog_RequestMetadata) MakeDiffFieldMask(other *ActivityLog_RequestMetadata) *ActivityLog_RequestMetadata_FieldMask

func (*ActivityLog_RequestMetadata) MakeFullFieldMask 

func (o *ActivityLog_RequestMetadata) MakeFullFieldMask() *ActivityLog_RequestMetadata_FieldMask

func (*ActivityLog_RequestMetadata) MakeRawDiffFieldMask 

func (o *ActivityLog_RequestMetadata) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_RequestMetadata) MakeRawFullFieldMask 

func (o *ActivityLog_RequestMetadata) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_RequestMetadata) Marshal 

func (m *ActivityLog_RequestMetadata) Marshal() ([]byte, error)

func (*ActivityLog_RequestMetadata) MarshalJSON 

func (m *ActivityLog_RequestMetadata) MarshalJSON() ([]byte, error)

func (*ActivityLog_RequestMetadata) Merge 

func (o *ActivityLog_RequestMetadata) Merge(source *ActivityLog_RequestMetadata)

func (*ActivityLog_RequestMetadata) MergeRaw 

func (o *ActivityLog_RequestMetadata) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_RequestMetadata) ProtoMessage 

func (*ActivityLog_RequestMetadata) ProtoMessage()

func (*ActivityLog_RequestMetadata) ProtoReflect 

func (m *ActivityLog_RequestMetadata) ProtoReflect() preflect.Message

func (*ActivityLog_RequestMetadata) Reset 

func (m *ActivityLog_RequestMetadata) Reset()

func (*ActivityLog_RequestMetadata) SetIpAddress 

func (m *ActivityLog_RequestMetadata) SetIpAddress(fv string)

func (*ActivityLog_RequestMetadata) SetUserAgent 

func (m *ActivityLog_RequestMetadata) SetUserAgent(fv string)

func (*ActivityLog_RequestMetadata) String 

func (m *ActivityLog_RequestMetadata) String() string

func (*ActivityLog_RequestMetadata) Unmarshal 

func (m *ActivityLog_RequestMetadata) Unmarshal(b []byte) error

func (*ActivityLog_RequestMetadata) UnmarshalJSON 

func (m *ActivityLog_RequestMetadata) UnmarshalJSON(data []byte) error

type ActivityLog_RequestMetadataPathSelectorIpAddress 

type ActivityLog_RequestMetadataPathSelectorIpAddress struct{}

func (ActivityLog_RequestMetadataPathSelectorIpAddress) FieldPath 

func (ActivityLog_RequestMetadataPathSelectorIpAddress) FieldPath() *ActivityLogRequestMetadata_FieldTerminalPath

func (ActivityLog_RequestMetadataPathSelectorIpAddress) WithArrayOfValues 

func (s ActivityLog_RequestMetadataPathSelectorIpAddress) WithArrayOfValues(values []string) *ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues

func (ActivityLog_RequestMetadataPathSelectorIpAddress) WithValue 

func (s ActivityLog_RequestMetadataPathSelectorIpAddress) WithValue(value string) *ActivityLogRequestMetadata_FieldTerminalPathValue

type ActivityLog_RequestMetadataPathSelectorUserAgent 

type ActivityLog_RequestMetadataPathSelectorUserAgent struct{}

func (ActivityLog_RequestMetadataPathSelectorUserAgent) FieldPath 

func (ActivityLog_RequestMetadataPathSelectorUserAgent) FieldPath() *ActivityLogRequestMetadata_FieldTerminalPath

func (ActivityLog_RequestMetadataPathSelectorUserAgent) WithArrayOfValues 

func (s ActivityLog_RequestMetadataPathSelectorUserAgent) WithArrayOfValues(values []string) *ActivityLogRequestMetadata_FieldTerminalPathArrayOfValues

func (ActivityLog_RequestMetadataPathSelectorUserAgent) WithValue 

func (s ActivityLog_RequestMetadataPathSelectorUserAgent) WithValue(value string) *ActivityLogRequestMetadata_FieldTerminalPathValue

type ActivityLog_RequestMetadata_FieldMask 

type ActivityLog_RequestMetadata_FieldMask struct {
	Paths []ActivityLogRequestMetadata_FieldPath
}

func FullActivityLog_RequestMetadata_FieldMask 

func FullActivityLog_RequestMetadata_FieldMask() *ActivityLog_RequestMetadata_FieldMask

func (*ActivityLog_RequestMetadata_FieldMask) AppendPath 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) AppendPath(path ActivityLogRequestMetadata_FieldPath)

func (*ActivityLog_RequestMetadata_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_RequestMetadata_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_RequestMetadata_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_RequestMetadata_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) FilterInputFields() *ActivityLog_RequestMetadata_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_RequestMetadata_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_RequestMetadata_FieldMask) GetPaths 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) GetPaths() []ActivityLogRequestMetadata_FieldPath

func (*ActivityLog_RequestMetadata_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_RequestMetadata_FieldMask) IsFull 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) IsFull() bool

func (ActivityLog_RequestMetadata_FieldMask) Marshal 

func (fieldMask ActivityLog_RequestMetadata_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_RequestMetadata_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_RequestMetadata_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_RequestMetadata_FieldMask) PathsCount 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) PathsCount() int

func (*ActivityLog_RequestMetadata_FieldMask) Project 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) Project(source *ActivityLog_RequestMetadata) *ActivityLog_RequestMetadata

func (*ActivityLog_RequestMetadata_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_RequestMetadata_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) ProtoMessage()

func (*ActivityLog_RequestMetadata_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_RequestMetadata_FieldMask) Reset 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) Reset()

func (*ActivityLog_RequestMetadata_FieldMask) Set 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) Set(target, source *ActivityLog_RequestMetadata)

func (*ActivityLog_RequestMetadata_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_RequestMetadata_FieldMask) SetRaw 

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

func (*ActivityLog_RequestMetadata_FieldMask) Size 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) Size() int

func (*ActivityLog_RequestMetadata_FieldMask) String 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) String() string

func (*ActivityLog_RequestMetadata_FieldMask) Subtract 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) Subtract(other *ActivityLog_RequestMetadata_FieldMask) *ActivityLog_RequestMetadata_FieldMask

func (*ActivityLog_RequestMetadata_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_RequestMetadata_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_RequestMetadata_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_RequestMetadata_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_RequestMetadata_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_RequestRouting 

type ActivityLog_RequestRouting struct {

	// ID of a region which originally received request, if redirection or split
	// & merge was required
	ViaRegion string `protobuf:"bytes,1,opt,name=via_region,json=viaRegion,proto3" json:"via_region,omitempty" firestore:"viaRegion"`
	// IDs of regions to which request was actually addressed.
	DestRegions []string `protobuf:"bytes,2,rep,name=dest_regions,json=destRegions,proto3" json:"dest_regions,omitempty" firestore:"destRegions"`
	// contains filtered or unexported fields
}

Additional information regarding request routing. Request can be: * Received and executed locally * Received and redirected to another region * Received, then split across multiple-regions. Responses are merged before sending back to client

func (*ActivityLog_RequestRouting) Clone 

func (o *ActivityLog_RequestRouting) Clone() *ActivityLog_RequestRouting

func (*ActivityLog_RequestRouting) CloneRaw 

func (o *ActivityLog_RequestRouting) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_RequestRouting) Descriptor 

func (*ActivityLog_RequestRouting) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_RequestRouting.ProtoReflect.Descriptor instead.

func (*ActivityLog_RequestRouting) GetDestRegions 

func (m *ActivityLog_RequestRouting) GetDestRegions() []string

func (*ActivityLog_RequestRouting) GetViaRegion 

func (m *ActivityLog_RequestRouting) GetViaRegion() string

func (*ActivityLog_RequestRouting) GotenMessage 

func (*ActivityLog_RequestRouting) GotenMessage()

func (*ActivityLog_RequestRouting) GotenObjectExt 

func (o *ActivityLog_RequestRouting) GotenObjectExt()

func (*ActivityLog_RequestRouting) GotenValidate 

func (obj *ActivityLog_RequestRouting) GotenValidate() error

func (*ActivityLog_RequestRouting) MakeDiffFieldMask 

func (o *ActivityLog_RequestRouting) MakeDiffFieldMask(other *ActivityLog_RequestRouting) *ActivityLog_RequestRouting_FieldMask

func (*ActivityLog_RequestRouting) MakeFullFieldMask 

func (o *ActivityLog_RequestRouting) MakeFullFieldMask() *ActivityLog_RequestRouting_FieldMask

func (*ActivityLog_RequestRouting) MakeRawDiffFieldMask 

func (o *ActivityLog_RequestRouting) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_RequestRouting) MakeRawFullFieldMask 

func (o *ActivityLog_RequestRouting) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_RequestRouting) Marshal 

func (m *ActivityLog_RequestRouting) Marshal() ([]byte, error)

func (*ActivityLog_RequestRouting) MarshalJSON 

func (m *ActivityLog_RequestRouting) MarshalJSON() ([]byte, error)

func (*ActivityLog_RequestRouting) Merge 

func (o *ActivityLog_RequestRouting) Merge(source *ActivityLog_RequestRouting)

func (*ActivityLog_RequestRouting) MergeRaw 

func (o *ActivityLog_RequestRouting) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_RequestRouting) ProtoMessage 

func (*ActivityLog_RequestRouting) ProtoMessage()

func (*ActivityLog_RequestRouting) ProtoReflect 

func (m *ActivityLog_RequestRouting) ProtoReflect() preflect.Message

func (*ActivityLog_RequestRouting) Reset 

func (m *ActivityLog_RequestRouting) Reset()

func (*ActivityLog_RequestRouting) SetDestRegions 

func (m *ActivityLog_RequestRouting) SetDestRegions(fv []string)

func (*ActivityLog_RequestRouting) SetViaRegion 

func (m *ActivityLog_RequestRouting) SetViaRegion(fv string)

func (*ActivityLog_RequestRouting) String 

func (m *ActivityLog_RequestRouting) String() string

func (*ActivityLog_RequestRouting) Unmarshal 

func (m *ActivityLog_RequestRouting) Unmarshal(b []byte) error

func (*ActivityLog_RequestRouting) UnmarshalJSON 

func (m *ActivityLog_RequestRouting) UnmarshalJSON(data []byte) error

type ActivityLog_RequestRoutingPathSelectorDestRegions 

type ActivityLog_RequestRoutingPathSelectorDestRegions struct{}

func (ActivityLog_RequestRoutingPathSelectorDestRegions) FieldPath 

func (ActivityLog_RequestRoutingPathSelectorDestRegions) FieldPath() *ActivityLogRequestRouting_FieldTerminalPath

func (ActivityLog_RequestRoutingPathSelectorDestRegions) WithArrayOfValues 

func (s ActivityLog_RequestRoutingPathSelectorDestRegions) WithArrayOfValues(values [][]string) *ActivityLogRequestRouting_FieldTerminalPathArrayOfValues

func (ActivityLog_RequestRoutingPathSelectorDestRegions) WithItemValue 

func (s ActivityLog_RequestRoutingPathSelectorDestRegions) WithItemValue(value string) *ActivityLogRequestRouting_FieldTerminalPathArrayItemValue

func (ActivityLog_RequestRoutingPathSelectorDestRegions) WithValue 

func (s ActivityLog_RequestRoutingPathSelectorDestRegions) WithValue(value []string) *ActivityLogRequestRouting_FieldTerminalPathValue

type ActivityLog_RequestRoutingPathSelectorViaRegion 

type ActivityLog_RequestRoutingPathSelectorViaRegion struct{}

func (ActivityLog_RequestRoutingPathSelectorViaRegion) FieldPath 

func (ActivityLog_RequestRoutingPathSelectorViaRegion) FieldPath() *ActivityLogRequestRouting_FieldTerminalPath

func (ActivityLog_RequestRoutingPathSelectorViaRegion) WithArrayOfValues 

func (s ActivityLog_RequestRoutingPathSelectorViaRegion) WithArrayOfValues(values []string) *ActivityLogRequestRouting_FieldTerminalPathArrayOfValues

func (ActivityLog_RequestRoutingPathSelectorViaRegion) WithValue 

func (s ActivityLog_RequestRoutingPathSelectorViaRegion) WithValue(value string) *ActivityLogRequestRouting_FieldTerminalPathValue

type ActivityLog_RequestRouting_FieldMask 

type ActivityLog_RequestRouting_FieldMask struct {
	Paths []ActivityLogRequestRouting_FieldPath
}

func FullActivityLog_RequestRouting_FieldMask 

func FullActivityLog_RequestRouting_FieldMask() *ActivityLog_RequestRouting_FieldMask

func (*ActivityLog_RequestRouting_FieldMask) AppendPath 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) AppendPath(path ActivityLogRequestRouting_FieldPath)

func (*ActivityLog_RequestRouting_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_RequestRouting_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_RequestRouting_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_RequestRouting_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) FilterInputFields() *ActivityLog_RequestRouting_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_RequestRouting_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_RequestRouting_FieldMask) GetPaths 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) GetPaths() []ActivityLogRequestRouting_FieldPath

func (*ActivityLog_RequestRouting_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_RequestRouting_FieldMask) IsFull 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) IsFull() bool

func (ActivityLog_RequestRouting_FieldMask) Marshal 

func (fieldMask ActivityLog_RequestRouting_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_RequestRouting_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_RequestRouting_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_RequestRouting_FieldMask) PathsCount 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) PathsCount() int

func (*ActivityLog_RequestRouting_FieldMask) Project 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) Project(source *ActivityLog_RequestRouting) *ActivityLog_RequestRouting

func (*ActivityLog_RequestRouting_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_RequestRouting_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) ProtoMessage()

func (*ActivityLog_RequestRouting_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_RequestRouting_FieldMask) Reset 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) Reset()

func (*ActivityLog_RequestRouting_FieldMask) Set 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) Set(target, source *ActivityLog_RequestRouting)

func (*ActivityLog_RequestRouting_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_RequestRouting_FieldMask) SetRaw 

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

func (*ActivityLog_RequestRouting_FieldMask) Size 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) Size() int

func (*ActivityLog_RequestRouting_FieldMask) String 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) String() string

func (*ActivityLog_RequestRouting_FieldMask) Subtract 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) Subtract(other *ActivityLog_RequestRouting_FieldMask) *ActivityLog_RequestRouting_FieldMask

func (*ActivityLog_RequestRouting_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_RequestRouting_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_RequestRouting_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_RequestRouting_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_RequestRouting_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_Resource 

type ActivityLog_Resource struct {

	// full name of the resource
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty" firestore:"name"`
	// difference contains update information of the resource.
	// Left empty if the request described by this activity log did not
	// update the resource.
	Difference *ActivityLog_Resource_Difference `protobuf:"bytes,2,opt,name=difference,proto3" json:"difference,omitempty" firestore:"difference"`
	// contains filtered or unexported fields
}

Description of the main resource activity refers to. For standard, goten-generated actions it's same as resource assigned to the the method. For custom actions, in some cases, developer may pick however different resource (it is customizable in proto audit spec).

func (*ActivityLog_Resource) Clone 

func (o *ActivityLog_Resource) Clone() *ActivityLog_Resource

func (*ActivityLog_Resource) CloneRaw 

func (o *ActivityLog_Resource) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Resource) Descriptor 

func (*ActivityLog_Resource) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Resource.ProtoReflect.Descriptor instead.

func (*ActivityLog_Resource) GetDifference 

func (m *ActivityLog_Resource) GetDifference() *ActivityLog_Resource_Difference

func (*ActivityLog_Resource) GetName 

func (m *ActivityLog_Resource) GetName() string

func (*ActivityLog_Resource) GotenMessage 

func (*ActivityLog_Resource) GotenMessage()

func (*ActivityLog_Resource) GotenObjectExt 

func (o *ActivityLog_Resource) GotenObjectExt()

func (*ActivityLog_Resource) GotenValidate 

func (obj *ActivityLog_Resource) GotenValidate() error

func (*ActivityLog_Resource) MakeDiffFieldMask 

func (o *ActivityLog_Resource) MakeDiffFieldMask(other *ActivityLog_Resource) *ActivityLog_Resource_FieldMask

func (*ActivityLog_Resource) MakeFullFieldMask 

func (o *ActivityLog_Resource) MakeFullFieldMask() *ActivityLog_Resource_FieldMask

func (*ActivityLog_Resource) MakeRawDiffFieldMask 

func (o *ActivityLog_Resource) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Resource) MakeRawFullFieldMask 

func (o *ActivityLog_Resource) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Resource) Marshal 

func (m *ActivityLog_Resource) Marshal() ([]byte, error)

func (*ActivityLog_Resource) MarshalJSON 

func (m *ActivityLog_Resource) MarshalJSON() ([]byte, error)

func (*ActivityLog_Resource) Merge 

func (o *ActivityLog_Resource) Merge(source *ActivityLog_Resource)

func (*ActivityLog_Resource) MergeRaw 

func (o *ActivityLog_Resource) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Resource) ProtoMessage 

func (*ActivityLog_Resource) ProtoMessage()

func (*ActivityLog_Resource) ProtoReflect 

func (m *ActivityLog_Resource) ProtoReflect() preflect.Message

func (*ActivityLog_Resource) Reset 

func (m *ActivityLog_Resource) Reset()

func (*ActivityLog_Resource) SetDifference 

func (m *ActivityLog_Resource) SetDifference(fv *ActivityLog_Resource_Difference)

func (*ActivityLog_Resource) SetName 

func (m *ActivityLog_Resource) SetName(fv string)

func (*ActivityLog_Resource) String 

func (m *ActivityLog_Resource) String() string

func (*ActivityLog_Resource) Unmarshal 

func (m *ActivityLog_Resource) Unmarshal(b []byte) error

func (*ActivityLog_Resource) UnmarshalJSON 

func (m *ActivityLog_Resource) UnmarshalJSON(data []byte) error

type ActivityLog_ResourcePathSelectorDifference 

type ActivityLog_ResourcePathSelectorDifference struct{}

func (ActivityLog_ResourcePathSelectorDifference) After 

func (ActivityLog_ResourcePathSelectorDifference) After() ActivityLog_ResourcePathSelectorDifferenceAfter

func (ActivityLog_ResourcePathSelectorDifference) Before 

func (ActivityLog_ResourcePathSelectorDifference) Before() ActivityLog_ResourcePathSelectorDifferenceBefore

func (ActivityLog_ResourcePathSelectorDifference) FieldPath 

func (ActivityLog_ResourcePathSelectorDifference) FieldPath() *ActivityLogResource_FieldTerminalPath

func (ActivityLog_ResourcePathSelectorDifference) Fields 

func (ActivityLog_ResourcePathSelectorDifference) Fields() ActivityLog_ResourcePathSelectorDifferenceFields

func (ActivityLog_ResourcePathSelectorDifference) WithArrayOfValues 

func (s ActivityLog_ResourcePathSelectorDifference) WithArrayOfValues(values []*ActivityLog_Resource_Difference) *ActivityLogResource_FieldTerminalPathArrayOfValues

func (ActivityLog_ResourcePathSelectorDifference) WithSubArrayItemValue 

func (s ActivityLog_ResourcePathSelectorDifference) WithSubArrayItemValue(subPathArrayItemValue ActivityLogResourceDifference_FieldPathArrayItemValue) *ActivityLogResource_FieldSubPathArrayItemValue

func (ActivityLog_ResourcePathSelectorDifference) WithSubArrayOfValues 

func (s ActivityLog_ResourcePathSelectorDifference) WithSubArrayOfValues(subPathArrayOfValues ActivityLogResourceDifference_FieldPathArrayOfValues) *ActivityLogResource_FieldSubPathArrayOfValues

func (ActivityLog_ResourcePathSelectorDifference) WithSubPath 

func (ActivityLog_ResourcePathSelectorDifference) WithSubPath(subPath ActivityLogResourceDifference_FieldPath) *ActivityLogResource_FieldSubPath

func (ActivityLog_ResourcePathSelectorDifference) WithSubValue 

func (s ActivityLog_ResourcePathSelectorDifference) WithSubValue(subPathValue ActivityLogResourceDifference_FieldPathValue) *ActivityLogResource_FieldSubPathValue

func (ActivityLog_ResourcePathSelectorDifference) WithValue 

func (s ActivityLog_ResourcePathSelectorDifference) WithValue(value *ActivityLog_Resource_Difference) *ActivityLogResource_FieldTerminalPathValue

type ActivityLog_ResourcePathSelectorDifferenceAfter 

type ActivityLog_ResourcePathSelectorDifferenceAfter struct{}

func (ActivityLog_ResourcePathSelectorDifferenceAfter) FieldPath 

func (ActivityLog_ResourcePathSelectorDifferenceAfter) FieldPath() *ActivityLogResource_FieldSubPath

func (ActivityLog_ResourcePathSelectorDifferenceAfter) WithArrayOfValues 

func (s ActivityLog_ResourcePathSelectorDifferenceAfter) WithArrayOfValues(values []*anypb.Any) *ActivityLogResource_FieldSubPathArrayOfValues

func (ActivityLog_ResourcePathSelectorDifferenceAfter) WithValue 

func (s ActivityLog_ResourcePathSelectorDifferenceAfter) WithValue(value *anypb.Any) *ActivityLogResource_FieldSubPathValue

type ActivityLog_ResourcePathSelectorDifferenceBefore 

type ActivityLog_ResourcePathSelectorDifferenceBefore struct{}

func (ActivityLog_ResourcePathSelectorDifferenceBefore) FieldPath 

func (ActivityLog_ResourcePathSelectorDifferenceBefore) FieldPath() *ActivityLogResource_FieldSubPath

func (ActivityLog_ResourcePathSelectorDifferenceBefore) WithArrayOfValues 

func (s ActivityLog_ResourcePathSelectorDifferenceBefore) WithArrayOfValues(values []*anypb.Any) *ActivityLogResource_FieldSubPathArrayOfValues

func (ActivityLog_ResourcePathSelectorDifferenceBefore) WithValue 

func (s ActivityLog_ResourcePathSelectorDifferenceBefore) WithValue(value *anypb.Any) *ActivityLogResource_FieldSubPathValue

type ActivityLog_ResourcePathSelectorDifferenceFields 

type ActivityLog_ResourcePathSelectorDifferenceFields struct{}

func (ActivityLog_ResourcePathSelectorDifferenceFields) FieldPath 

func (ActivityLog_ResourcePathSelectorDifferenceFields) FieldPath() *ActivityLogResource_FieldSubPath

func (ActivityLog_ResourcePathSelectorDifferenceFields) WithArrayOfValues 

func (s ActivityLog_ResourcePathSelectorDifferenceFields) WithArrayOfValues(values []*fieldmaskpb.FieldMask) *ActivityLogResource_FieldSubPathArrayOfValues

func (ActivityLog_ResourcePathSelectorDifferenceFields) WithValue 

func (s ActivityLog_ResourcePathSelectorDifferenceFields) WithValue(value *fieldmaskpb.FieldMask) *ActivityLogResource_FieldSubPathValue

type ActivityLog_ResourcePathSelectorName 

type ActivityLog_ResourcePathSelectorName struct{}

func (ActivityLog_ResourcePathSelectorName) FieldPath 

func (ActivityLog_ResourcePathSelectorName) FieldPath() *ActivityLogResource_FieldTerminalPath

func (ActivityLog_ResourcePathSelectorName) WithArrayOfValues 

func (s ActivityLog_ResourcePathSelectorName) WithArrayOfValues(values []string) *ActivityLogResource_FieldTerminalPathArrayOfValues

func (ActivityLog_ResourcePathSelectorName) WithValue 

func (s ActivityLog_ResourcePathSelectorName) WithValue(value string) *ActivityLogResource_FieldTerminalPathValue

type ActivityLog_Resource_Difference 

type ActivityLog_Resource_Difference struct {

	// List of updated field paths (which are either marked as a state or
	// spec fields). Proper, actual values are stored in "before" and "after"
	// fields. Populated only for updating requests.
	Fields *fieldmaskpb.FieldMask `protobuf:"bytes,1,opt,name=fields,proto3" json:"fields,omitempty" firestore:"fields"`
	// State of the resource before update.
	// Note that "before" object contains only values of fields present
	// in "fields". It does not contain whole resource as it was before
	// the update.
	Before *anypb.Any `protobuf:"bytes,2,opt,name=before,proto3" json:"before,omitempty" firestore:"before"`
	// State of the resource after update.
	// Note that "after" object contains only values of fields present
	// in "fields". It does not contain whole resource as it is after
	// the update.
	After *anypb.Any `protobuf:"bytes,3,opt,name=after,proto3" json:"after,omitempty" firestore:"after"`
	// contains filtered or unexported fields
}

Describes changes (in database) executed on the resource.

func (*ActivityLog_Resource_Difference) Clone 

func (o *ActivityLog_Resource_Difference) Clone() *ActivityLog_Resource_Difference

func (*ActivityLog_Resource_Difference) CloneRaw 

func (o *ActivityLog_Resource_Difference) CloneRaw() gotenobject.GotenObjectExt

func (*ActivityLog_Resource_Difference) Descriptor 

func (*ActivityLog_Resource_Difference) Descriptor() ([]byte, []int)

Deprecated, Use ActivityLog_Resource_Difference.ProtoReflect.Descriptor instead.

func (*ActivityLog_Resource_Difference) GetAfter 

func (m *ActivityLog_Resource_Difference) GetAfter() *anypb.Any

func (*ActivityLog_Resource_Difference) GetBefore 

func (m *ActivityLog_Resource_Difference) GetBefore() *anypb.Any

func (*ActivityLog_Resource_Difference) GetFields 

func (m *ActivityLog_Resource_Difference) GetFields() *fieldmaskpb.FieldMask

func (*ActivityLog_Resource_Difference) GotenMessage 

func (*ActivityLog_Resource_Difference) GotenMessage()

func (*ActivityLog_Resource_Difference) GotenObjectExt 

func (o *ActivityLog_Resource_Difference) GotenObjectExt()

func (*ActivityLog_Resource_Difference) GotenValidate 

func (obj *ActivityLog_Resource_Difference) GotenValidate() error

func (*ActivityLog_Resource_Difference) MakeDiffFieldMask 

func (o *ActivityLog_Resource_Difference) MakeDiffFieldMask(other *ActivityLog_Resource_Difference) *ActivityLog_Resource_Difference_FieldMask

func (*ActivityLog_Resource_Difference) MakeFullFieldMask 

func (o *ActivityLog_Resource_Difference) MakeFullFieldMask() *ActivityLog_Resource_Difference_FieldMask

func (*ActivityLog_Resource_Difference) MakeRawDiffFieldMask 

func (o *ActivityLog_Resource_Difference) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask

func (*ActivityLog_Resource_Difference) MakeRawFullFieldMask 

func (o *ActivityLog_Resource_Difference) MakeRawFullFieldMask() gotenobject.FieldMask

func (*ActivityLog_Resource_Difference) Marshal 

func (m *ActivityLog_Resource_Difference) Marshal() ([]byte, error)

func (*ActivityLog_Resource_Difference) MarshalJSON 

func (m *ActivityLog_Resource_Difference) MarshalJSON() ([]byte, error)

func (*ActivityLog_Resource_Difference) Merge 

func (o *ActivityLog_Resource_Difference) Merge(source *ActivityLog_Resource_Difference)

func (*ActivityLog_Resource_Difference) MergeRaw 

func (o *ActivityLog_Resource_Difference) MergeRaw(source gotenobject.GotenObjectExt)

func (*ActivityLog_Resource_Difference) ProtoMessage 

func (*ActivityLog_Resource_Difference) ProtoMessage()

func (*ActivityLog_Resource_Difference) ProtoReflect 

func (m *ActivityLog_Resource_Difference) ProtoReflect() preflect.Message

func (*ActivityLog_Resource_Difference) Reset 

func (m *ActivityLog_Resource_Difference) Reset()

func (*ActivityLog_Resource_Difference) SetAfter 

func (m *ActivityLog_Resource_Difference) SetAfter(fv *anypb.Any)

func (*ActivityLog_Resource_Difference) SetBefore 

func (m *ActivityLog_Resource_Difference) SetBefore(fv *anypb.Any)

func (*ActivityLog_Resource_Difference) SetFields 

func (m *ActivityLog_Resource_Difference) SetFields(fv *fieldmaskpb.FieldMask)

func (*ActivityLog_Resource_Difference) String 

func (m *ActivityLog_Resource_Difference) String() string

func (*ActivityLog_Resource_Difference) Unmarshal 

func (m *ActivityLog_Resource_Difference) Unmarshal(b []byte) error

func (*ActivityLog_Resource_Difference) UnmarshalJSON 

func (m *ActivityLog_Resource_Difference) UnmarshalJSON(data []byte) error

type ActivityLog_Resource_DifferencePathSelectorAfter 

type ActivityLog_Resource_DifferencePathSelectorAfter struct{}

func (ActivityLog_Resource_DifferencePathSelectorAfter) FieldPath 

func (ActivityLog_Resource_DifferencePathSelectorAfter) FieldPath() *ActivityLogResourceDifference_FieldTerminalPath

func (ActivityLog_Resource_DifferencePathSelectorAfter) WithArrayOfValues 

func (s ActivityLog_Resource_DifferencePathSelectorAfter) WithArrayOfValues(values []*anypb.Any) *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues

func (ActivityLog_Resource_DifferencePathSelectorAfter) WithValue 

func (s ActivityLog_Resource_DifferencePathSelectorAfter) WithValue(value *anypb.Any) *ActivityLogResourceDifference_FieldTerminalPathValue

type ActivityLog_Resource_DifferencePathSelectorBefore 

type ActivityLog_Resource_DifferencePathSelectorBefore struct{}

func (ActivityLog_Resource_DifferencePathSelectorBefore) FieldPath 

func (ActivityLog_Resource_DifferencePathSelectorBefore) FieldPath() *ActivityLogResourceDifference_FieldTerminalPath

func (ActivityLog_Resource_DifferencePathSelectorBefore) WithArrayOfValues 

func (s ActivityLog_Resource_DifferencePathSelectorBefore) WithArrayOfValues(values []*anypb.Any) *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues

func (ActivityLog_Resource_DifferencePathSelectorBefore) WithValue 

func (s ActivityLog_Resource_DifferencePathSelectorBefore) WithValue(value *anypb.Any) *ActivityLogResourceDifference_FieldTerminalPathValue

type ActivityLog_Resource_DifferencePathSelectorFields 

type ActivityLog_Resource_DifferencePathSelectorFields struct{}

func (ActivityLog_Resource_DifferencePathSelectorFields) FieldPath 

func (ActivityLog_Resource_DifferencePathSelectorFields) FieldPath() *ActivityLogResourceDifference_FieldTerminalPath

func (ActivityLog_Resource_DifferencePathSelectorFields) WithArrayOfValues 

func (s ActivityLog_Resource_DifferencePathSelectorFields) WithArrayOfValues(values []*fieldmaskpb.FieldMask) *ActivityLogResourceDifference_FieldTerminalPathArrayOfValues

func (ActivityLog_Resource_DifferencePathSelectorFields) WithValue 

func (s ActivityLog_Resource_DifferencePathSelectorFields) WithValue(value *fieldmaskpb.FieldMask) *ActivityLogResourceDifference_FieldTerminalPathValue

type ActivityLog_Resource_Difference_FieldMask 

type ActivityLog_Resource_Difference_FieldMask struct {
	Paths []ActivityLogResourceDifference_FieldPath
}

func FullActivityLog_Resource_Difference_FieldMask 

func FullActivityLog_Resource_Difference_FieldMask() *ActivityLog_Resource_Difference_FieldMask

func (*ActivityLog_Resource_Difference_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) AppendPath(path ActivityLogResourceDifference_FieldPath)

func (*ActivityLog_Resource_Difference_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Resource_Difference_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Resource_Difference_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Resource_Difference_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) FilterInputFields() *ActivityLog_Resource_Difference_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Resource_Difference_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Resource_Difference_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) GetPaths() []ActivityLogResourceDifference_FieldPath

func (*ActivityLog_Resource_Difference_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Resource_Difference_FieldMask) IsFull 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) IsFull() bool

func (ActivityLog_Resource_Difference_FieldMask) Marshal 

func (fieldMask ActivityLog_Resource_Difference_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Resource_Difference_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Resource_Difference_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Resource_Difference_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) PathsCount() int

func (*ActivityLog_Resource_Difference_FieldMask) Project 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) Project(source *ActivityLog_Resource_Difference) *ActivityLog_Resource_Difference

func (*ActivityLog_Resource_Difference_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Resource_Difference_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) ProtoMessage()

func (*ActivityLog_Resource_Difference_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Resource_Difference_FieldMask) Reset 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) Reset()

func (*ActivityLog_Resource_Difference_FieldMask) Set 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) Set(target, source *ActivityLog_Resource_Difference)

func (*ActivityLog_Resource_Difference_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Resource_Difference_FieldMask) SetRaw 

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

func (*ActivityLog_Resource_Difference_FieldMask) Size 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) Size() int

func (*ActivityLog_Resource_Difference_FieldMask) String 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) String() string

func (*ActivityLog_Resource_Difference_FieldMask) Subtract 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) Subtract(other *ActivityLog_Resource_Difference_FieldMask) *ActivityLog_Resource_Difference_FieldMask

func (*ActivityLog_Resource_Difference_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Resource_Difference_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Resource_Difference_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Resource_Difference_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Resource_Difference_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_Resource_FieldMask 

type ActivityLog_Resource_FieldMask struct {
	Paths []ActivityLogResource_FieldPath
}

func FullActivityLog_Resource_FieldMask 

func FullActivityLog_Resource_FieldMask() *ActivityLog_Resource_FieldMask

func (*ActivityLog_Resource_FieldMask) AppendPath 

func (fieldMask *ActivityLog_Resource_FieldMask) AppendPath(path ActivityLogResource_FieldPath)

func (*ActivityLog_Resource_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_Resource_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_Resource_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_Resource_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_Resource_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_Resource_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_Resource_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_Resource_FieldMask) FilterInputFields() *ActivityLog_Resource_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_Resource_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_Resource_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error

func (*ActivityLog_Resource_FieldMask) GetPaths 

func (fieldMask *ActivityLog_Resource_FieldMask) GetPaths() []ActivityLogResource_FieldPath

func (*ActivityLog_Resource_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_Resource_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_Resource_FieldMask) IsFull 

func (fieldMask *ActivityLog_Resource_FieldMask) IsFull() bool

func (ActivityLog_Resource_FieldMask) Marshal 

func (fieldMask ActivityLog_Resource_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_Resource_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_Resource_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_Resource_FieldMask) PathsCount 

func (fieldMask *ActivityLog_Resource_FieldMask) PathsCount() int

func (*ActivityLog_Resource_FieldMask) Project 

func (fieldMask *ActivityLog_Resource_FieldMask) Project(source *ActivityLog_Resource) *ActivityLog_Resource

func (*ActivityLog_Resource_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_Resource_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_Resource_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_Resource_FieldMask) ProtoMessage()

func (*ActivityLog_Resource_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_Resource_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_Resource_FieldMask) Reset 

func (fieldMask *ActivityLog_Resource_FieldMask) Reset()

func (*ActivityLog_Resource_FieldMask) Set 

func (fieldMask *ActivityLog_Resource_FieldMask) Set(target, source *ActivityLog_Resource)

func (*ActivityLog_Resource_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_Resource_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_Resource_FieldMask) SetRaw 

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

func (*ActivityLog_Resource_FieldMask) Size 

func (fieldMask *ActivityLog_Resource_FieldMask) Size() int

func (*ActivityLog_Resource_FieldMask) String 

func (fieldMask *ActivityLog_Resource_FieldMask) String() string

func (*ActivityLog_Resource_FieldMask) Subtract 

func (fieldMask *ActivityLog_Resource_FieldMask) Subtract(other *ActivityLog_Resource_FieldMask) *ActivityLog_Resource_FieldMask

func (*ActivityLog_Resource_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_Resource_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_Resource_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_Resource_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_Resource_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_Resource_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_Resource_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_Resource_FieldMask) UnmarshalJSON(data []byte) error

type Descriptor 

type Descriptor struct {
	// contains filtered or unexported fields
}

func GetDescriptor 

func GetDescriptor() *Descriptor

func (*Descriptor) CanBeParentless 

func (d *Descriptor) CanBeParentless() bool

func (*Descriptor) GetNameDescriptor 

func (d *Descriptor) GetNameDescriptor() *gotenresource.NameDescriptor

func (*Descriptor) GetParentResDescriptors 

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

func (*Descriptor) GetResourceTypeName 

func (d *Descriptor) GetResourceTypeName() *gotenresource.TypeName

func (*Descriptor) NewGetQuery 

func (d *Descriptor) NewGetQuery() gotenresource.GetQuery

func (*Descriptor) NewListQuery 

func (d *Descriptor) NewListQuery() gotenresource.ListQuery

func (*Descriptor) NewNameList 

func (d *Descriptor) NewNameList(size, reserved int) gotenresource.NameList

func (*Descriptor) NewParentNameList 

func (d *Descriptor) NewParentNameList(size, reserved int) gotenresource.ParentNameList

func (*Descriptor) NewParentReferenceList 

func (d *Descriptor) NewParentReferenceList(size, reserved int) gotenresource.ParentReferenceList

func (*Descriptor) NewQueryResultChange 

func (d *Descriptor) NewQueryResultChange() gotenresource.QueryResultChange

func (*Descriptor) NewQueryResultSnapshot 

func (d *Descriptor) NewQueryResultSnapshot() gotenresource.QueryResultSnapshot

func (*Descriptor) NewReferenceList 

func (d *Descriptor) NewReferenceList(size, reserved int) gotenresource.ReferenceList

func (*Descriptor) NewResource 

func (d *Descriptor) NewResource() gotenresource.Resource

func (*Descriptor) NewResourceChange 

func (d *Descriptor) NewResourceChange() gotenresource.ResourceChange

func (*Descriptor) NewResourceChangeList 

func (d *Descriptor) NewResourceChangeList(size, reserved int) gotenresource.ResourceChangeList

func (*Descriptor) NewResourceChangeMap 

func (d *Descriptor) NewResourceChangeMap(reserved int) gotenresource.ResourceChangeMap

func (*Descriptor) NewResourceCursor 

func (d *Descriptor) NewResourceCursor() gotenresource.Cursor

func (*Descriptor) NewResourceFieldMask 

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

func (*Descriptor) NewResourceFilter 

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

func (*Descriptor) NewResourceList 

func (d *Descriptor) NewResourceList(size, reserved int) gotenresource.ResourceList

func (*Descriptor) NewResourceMap 

func (d *Descriptor) NewResourceMap(reserved int) gotenresource.ResourceMap

func (*Descriptor) NewResourceName 

func (d *Descriptor) NewResourceName() gotenresource.Name

func (*Descriptor) NewResourceOrderBy 

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

func (*Descriptor) NewResourcePager 

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

func (*Descriptor) NewSearchQuery 

func (d *Descriptor) NewSearchQuery() gotenresource.SearchQuery

func (*Descriptor) NewWatchQuery 

func (d *Descriptor) NewWatchQuery() gotenresource.WatchQuery

func (*Descriptor) ParseFieldPath 

func (d *Descriptor) ParseFieldPath(raw string) (gotenobject.FieldPath, error)

func (*Descriptor) ParseResourceName 

func (d *Descriptor) ParseResourceName(nameStr string) (gotenresource.Name, error)

func (*Descriptor) SupportsMetadata 

func (d *Descriptor) SupportsMetadata() bool

type Filter 

type Filter struct {
	FilterCondition
}

func (*Filter) ConvertToNative 

func (filter *Filter) ConvertToNative(typeDesc reflect.Type) (interface{}, error)

func (*Filter) ConvertToType 

func (filter *Filter) ConvertToType(typeVal ref.Type) ref.Val

func (*Filter) DecodeFirestore 

func (filter *Filter) DecodeFirestore(fpbv *firestorepb.Value) error

func (*Filter) EncodeFirestore 

func (filter *Filter) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*Filter) Equal 

func (filter *Filter) Equal(other ref.Val) ref.Val

func (*Filter) Evaluate 

func (filter *Filter) Evaluate(res *ActivityLog) bool

Evaluate is a wrapper on FilterCondition, which also handles nil pointer

func (*Filter) EvaluateRaw 

func (filter *Filter) EvaluateRaw(res gotenresource.Resource) bool

func (*Filter) FilterSlice 

func (filter *Filter) FilterSlice(in []*ActivityLog) (out []*ActivityLog)

FilterSlice is a helper for filtering arrays

func (*Filter) GetCondition 

func (filter *Filter) GetCondition() FilterCondition

GetCondition is a getter of FilterCondition, which also handles nil pointer

func (*Filter) GetRawCondition 

func (filter *Filter) GetRawCondition() gotenresource.FilterCondition

func (*Filter) HasTrait 

func (filter *Filter) HasTrait(trait int) bool

func (*Filter) Match 

func (filter *Filter) Match(pattern ref.Val) ref.Val

func (*Filter) ParseProtoString 

func (filter *Filter) ParseProtoString(data string) error

func (*Filter) ProtoString 

func (filter *Filter) ProtoString() (string, error)

func (*Filter) Receive 

func (filter *Filter) Receive(function string, overload string, args []ref.Val) ref.Val

func (*Filter) SetFromCliFlag 

func (filter *Filter) SetFromCliFlag(raw string) error

func (*Filter) String 

func (filter *Filter) String() string

func (*Filter) Type 

func (filter *Filter) Type() ref.Type

func (*Filter) TypeName 

func (filter *Filter) TypeName() string

func (*Filter) Value 

func (filter *Filter) Value() interface{}

type FilterBuilder 

type FilterBuilder struct {
	// contains filtered or unexported fields
}

func NewAndFilterBuilder 

func NewAndFilterBuilder() *FilterBuilder

func NewFilterBuilder 

func NewFilterBuilder() *FilterBuilder

func NewOrFilterBuilder 

func NewOrFilterBuilder() *FilterBuilder

func (*FilterBuilder) Filter 

func (b *FilterBuilder) Filter() *Filter

func (*FilterBuilder) Where 

func (b *FilterBuilder) Where(opts ...gotenfilter.FilterConditionOption) *filterCndBuilder

func (*FilterBuilder) WherePath 

func (b *FilterBuilder) WherePath(fp ActivityLog_FieldPath, opts ...gotenfilter.FilterConditionOption) *filterCndBuilderAnyPath

func (*FilterBuilder) With 

func (b *FilterBuilder) With(condOrBuilder FilterBuilderOrCondition, opts ...gotenfilter.FilterConditionOption) *FilterBuilder

type FilterBuilderOrCondition 

type FilterBuilderOrCondition interface {
	// contains filtered or unexported methods
}

type FilterCondition 

type FilterCondition interface {
	gotenresource.FilterCondition

	And(...FilterCondition) FilterCondition
	Evaluate(res *ActivityLog) bool

	// Whether this condition is at least as specific as other.
	// When true, any ActivityLog that passes this condition will also pass other condition.
	Satisfies(other FilterCondition) bool

	// Checks whether condition specifies given field path
	// Useful for blacklisting protected paths in iam policy conditions
	SpecifiesFieldPath(fp ActivityLog_FieldPath) bool
	// contains filtered or unexported methods
}

func AndFilterConditions 

func AndFilterConditions(conds ...FilterCondition) FilterCondition

type FilterConditionCompare 

type FilterConditionCompare struct {
	Operator filterParser.CompareOperator
	ActivityLog_FieldPathValue
}

func (*FilterConditionCompare) And 

func (cond *FilterConditionCompare) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionCompare) ConditionCompare 

func (cond *FilterConditionCompare) ConditionCompare()

func (*FilterConditionCompare) Evaluate 

func (cond *FilterConditionCompare) Evaluate(res *ActivityLog) bool

func (*FilterConditionCompare) EvaluateRaw 

func (cond *FilterConditionCompare) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionCompare) GetOperator 

func (cond *FilterConditionCompare) GetOperator() filterParser.CompareOperator

func (*FilterConditionCompare) GetRawFieldPath 

func (cond *FilterConditionCompare) GetRawFieldPath() gotenobject.FieldPath

func (*FilterConditionCompare) GetRawFieldPathValue 

func (cond *FilterConditionCompare) GetRawFieldPathValue() gotenobject.FieldPathValue

func (*FilterConditionCompare) Satisfies 

func (cond *FilterConditionCompare) Satisfies(other FilterCondition) bool

func (*FilterConditionCompare) SatisfiesRaw 

func (cond *FilterConditionCompare) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionCompare) SpecifiesFieldPath 

func (cond *FilterConditionCompare) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionCompare) SpecifiesRawFieldPath 

func (cond *FilterConditionCompare) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionCompare) String 

func (cond *FilterConditionCompare) String() string

type FilterConditionComposite 

type FilterConditionComposite struct {
	Operator   filterParser.CompositeOperator
	Conditions []FilterCondition
}

func (*FilterConditionComposite) And 

func (cond *FilterConditionComposite) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionComposite) ConditionComposite 

func (cond *FilterConditionComposite) ConditionComposite()

func (*FilterConditionComposite) Evaluate 

func (cond *FilterConditionComposite) Evaluate(res *ActivityLog) bool

func (*FilterConditionComposite) EvaluateRaw 

func (cond *FilterConditionComposite) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionComposite) GetOperator 

func (cond *FilterConditionComposite) GetOperator() filterParser.CompositeOperator

func (*FilterConditionComposite) GetSubConditions 

func (cond *FilterConditionComposite) GetSubConditions() []gotenresource.FilterCondition

func (*FilterConditionComposite) Satisfies 

func (cond *FilterConditionComposite) Satisfies(other FilterCondition) bool

func (*FilterConditionComposite) SatisfiesRaw 

func (cond *FilterConditionComposite) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionComposite) SpecifiesFieldPath 

func (cond *FilterConditionComposite) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionComposite) SpecifiesRawFieldPath 

func (cond *FilterConditionComposite) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionComposite) String 

func (cond *FilterConditionComposite) String() string

type FilterConditionContains 

type FilterConditionContains struct {
	Type      gotenresource.ConditionContainsType
	FieldPath ActivityLog_FieldPath

	Value  ActivityLog_FieldPathArrayItemValue
	Values []ActivityLog_FieldPathArrayItemValue
}

func (*FilterConditionContains) And 

func (cond *FilterConditionContains) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionContains) ConditionContains 

func (cond *FilterConditionContains) ConditionContains()

func (*FilterConditionContains) ConditionContainsType 

func (cond *FilterConditionContains) ConditionContainsType() gotenresource.ConditionContainsType

func (*FilterConditionContains) Evaluate 

func (cond *FilterConditionContains) Evaluate(res *ActivityLog) bool

func (*FilterConditionContains) EvaluateRaw 

func (cond *FilterConditionContains) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionContains) GetFieldPath 

func (cond *FilterConditionContains) GetFieldPath() ActivityLog_FieldPath

func (*FilterConditionContains) GetRawFieldPath 

func (cond *FilterConditionContains) GetRawFieldPath() gotenobject.FieldPath

func (*FilterConditionContains) GetRawFieldPathItemValue 

func (cond *FilterConditionContains) GetRawFieldPathItemValue() gotenobject.FieldPathArrayItemValue

func (*FilterConditionContains) GetRawFieldPathItemValues 

func (cond *FilterConditionContains) GetRawFieldPathItemValues() (res []gotenobject.FieldPathArrayItemValue)

func (*FilterConditionContains) Satisfies 

func (cond *FilterConditionContains) Satisfies(other FilterCondition) bool

func (*FilterConditionContains) SatisfiesRaw 

func (cond *FilterConditionContains) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionContains) SpecifiesFieldPath 

func (cond *FilterConditionContains) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionContains) SpecifiesRawFieldPath 

func (cond *FilterConditionContains) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionContains) String 

func (cond *FilterConditionContains) String() string

type FilterConditionIn 

type FilterConditionIn struct {
	ActivityLog_FieldPathArrayOfValues
}

func (*FilterConditionIn) And 

func (cond *FilterConditionIn) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionIn) ConditionIn 

func (cond *FilterConditionIn) ConditionIn()

func (*FilterConditionIn) Evaluate 

func (cond *FilterConditionIn) Evaluate(res *ActivityLog) bool

func (*FilterConditionIn) EvaluateRaw 

func (cond *FilterConditionIn) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionIn) GetRawFieldPath 

func (cond *FilterConditionIn) GetRawFieldPath() gotenobject.FieldPath

func (*FilterConditionIn) GetRawFieldPathArrayOfValues 

func (cond *FilterConditionIn) GetRawFieldPathArrayOfValues() gotenobject.FieldPathArrayOfValues

func (*FilterConditionIn) Satisfies 

func (cond *FilterConditionIn) Satisfies(other FilterCondition) bool

func (*FilterConditionIn) SatisfiesRaw 

func (cond *FilterConditionIn) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionIn) SpecifiesFieldPath 

func (cond *FilterConditionIn) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionIn) SpecifiesRawFieldPath 

func (cond *FilterConditionIn) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionIn) String 

func (cond *FilterConditionIn) String() string

type FilterConditionIsNaN 

type FilterConditionIsNaN struct {
	Not       bool
	FieldPath ActivityLog_FieldPath
}

func (*FilterConditionIsNaN) And 

func (cond *FilterConditionIsNaN) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionIsNaN) ConditionIsNaN 

func (cond *FilterConditionIsNaN) ConditionIsNaN()

func (*FilterConditionIsNaN) Evaluate 

func (cond *FilterConditionIsNaN) Evaluate(res *ActivityLog) bool

func (*FilterConditionIsNaN) EvaluateRaw 

func (cond *FilterConditionIsNaN) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionIsNaN) GetRawFieldPath 

func (cond *FilterConditionIsNaN) GetRawFieldPath() gotenobject.FieldPath

func (*FilterConditionIsNaN) Satisfies 

func (cond *FilterConditionIsNaN) Satisfies(other FilterCondition) bool

func (*FilterConditionIsNaN) SatisfiesRaw 

func (cond *FilterConditionIsNaN) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionIsNaN) SpecifiesFieldPath 

func (cond *FilterConditionIsNaN) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionIsNaN) SpecifiesRawFieldPath 

func (cond *FilterConditionIsNaN) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionIsNaN) String 

func (cond *FilterConditionIsNaN) String() string

type FilterConditionIsNull 

type FilterConditionIsNull struct {
	Not       bool
	FieldPath ActivityLog_FieldPath
}

func (*FilterConditionIsNull) And 

func (cond *FilterConditionIsNull) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionIsNull) ConditionIsNull 

func (cond *FilterConditionIsNull) ConditionIsNull()

func (*FilterConditionIsNull) Evaluate 

func (cond *FilterConditionIsNull) Evaluate(res *ActivityLog) bool

func (*FilterConditionIsNull) EvaluateRaw 

func (cond *FilterConditionIsNull) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionIsNull) GetRawFieldPath 

func (cond *FilterConditionIsNull) GetRawFieldPath() gotenobject.FieldPath

func (*FilterConditionIsNull) NotNull 

func (cond *FilterConditionIsNull) NotNull() bool

func (*FilterConditionIsNull) Satisfies 

func (cond *FilterConditionIsNull) Satisfies(other FilterCondition) bool

func (*FilterConditionIsNull) SatisfiesRaw 

func (cond *FilterConditionIsNull) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionIsNull) SpecifiesFieldPath 

func (cond *FilterConditionIsNull) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionIsNull) SpecifiesRawFieldPath 

func (cond *FilterConditionIsNull) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionIsNull) String 

func (cond *FilterConditionIsNull) String() string

type FilterConditionNot 

type FilterConditionNot struct {
	FilterCondition
}

func (*FilterConditionNot) And 

func (cond *FilterConditionNot) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionNot) ConditionNot 

func (cond *FilterConditionNot) ConditionNot()

func (*FilterConditionNot) Evaluate 

func (cond *FilterConditionNot) Evaluate(res *ActivityLog) bool

func (*FilterConditionNot) EvaluateRaw 

func (cond *FilterConditionNot) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionNot) GetSubCondition 

func (cond *FilterConditionNot) GetSubCondition() gotenresource.FilterCondition

func (*FilterConditionNot) Satisfies 

func (cond *FilterConditionNot) Satisfies(other FilterCondition) bool

func (*FilterConditionNot) SatisfiesRaw 

func (cond *FilterConditionNot) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionNot) SpecifiesFieldPath 

func (cond *FilterConditionNot) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionNot) SpecifiesRawFieldPath 

func (cond *FilterConditionNot) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionNot) String 

func (cond *FilterConditionNot) String() string

type FilterConditionNotIn 

type FilterConditionNotIn struct {
	ActivityLog_FieldPathArrayOfValues
}

func (*FilterConditionNotIn) And 

func (cond *FilterConditionNotIn) And(conds ...FilterCondition) FilterCondition

func (*FilterConditionNotIn) ConditionNotIn 

func (cond *FilterConditionNotIn) ConditionNotIn()

func (*FilterConditionNotIn) Evaluate 

func (cond *FilterConditionNotIn) Evaluate(res *ActivityLog) bool

func (*FilterConditionNotIn) EvaluateRaw 

func (cond *FilterConditionNotIn) EvaluateRaw(res gotenresource.Resource) bool

func (*FilterConditionNotIn) GetRawFieldPath 

func (cond *FilterConditionNotIn) GetRawFieldPath() gotenobject.FieldPath

func (*FilterConditionNotIn) GetRawFieldPathArrayOfValues 

func (cond *FilterConditionNotIn) GetRawFieldPathArrayOfValues() gotenobject.FieldPathArrayOfValues

func (*FilterConditionNotIn) Satisfies 

func (cond *FilterConditionNotIn) Satisfies(other FilterCondition) bool

func (*FilterConditionNotIn) SatisfiesRaw 

func (cond *FilterConditionNotIn) SatisfiesRaw(other gotenresource.FilterCondition) bool

func (*FilterConditionNotIn) SpecifiesFieldPath 

func (cond *FilterConditionNotIn) SpecifiesFieldPath(fp ActivityLog_FieldPath) bool

func (*FilterConditionNotIn) SpecifiesRawFieldPath 

func (cond *FilterConditionNotIn) SpecifiesRawFieldPath(fp gotenobject.FieldPath) bool

func (*FilterConditionNotIn) String 

func (cond *FilterConditionNotIn) String() string

type Name 

type Name struct {
	ParentName
	ActivityLogId string `firestore:"activityLogId"`
}

func MustParseName 

func MustParseName(name string) *Name

func ParseName 

func ParseName(name string) (*Name, error)

func ParseNameOrId 

func ParseNameOrId(nameOrId string) (*Name, error)

func (*Name) AsRawReference 

func (name *Name) AsRawReference() gotenresource.Reference

func (*Name) AsReference 

func (name *Name) AsReference() *Reference

func (*Name) ConvertToNative 

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

func (*Name) ConvertToType 

func (name *Name) ConvertToType(typeVal ref.Type) ref.Val

func (*Name) Equal 

func (name *Name) Equal(other ref.Val) ref.Val

func (*Name) FullyQualifiedName 

func (name *Name) FullyQualifiedName() (string, error)

func (*Name) GetIParentName 

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

func (*Name) GetIUnderlyingParentName 

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

func (*Name) GetIdParts 

func (name *Name) GetIdParts() map[string]string

func (*Name) GetOrganizationName 

func (name *Name) GetOrganizationName() *iam_organization.Name

func (*Name) GetPattern 

func (name *Name) GetPattern() gotenresource.NamePattern

func (*Name) GetProjectName 

func (name *Name) GetProjectName() *iam_project.Name

func (*Name) GetResourceDescriptor 

func (name *Name) GetResourceDescriptor() gotenresource.Descriptor

func (*Name) GetSegments 

func (name *Name) GetSegments() gotenresource.NameSegments

func (*Name) GetServiceName 

func (name *Name) GetServiceName() *meta_service.Name

func (*Name) GotenEqual 

func (name *Name) GotenEqual(other interface{}) bool

GotenEqual returns true if other is of same type and paths are equal (implements goten.Equaler interface)

func (*Name) HasTrait 

func (name *Name) HasTrait(trait int) bool

func (*Name) IsFullyQualified 

func (name *Name) IsFullyQualified() bool

func (*Name) IsSpecified 

func (name *Name) IsSpecified() bool

func (*Name) Match 

func (name *Name) Match(pattern ref.Val) ref.Val

func (*Name) Matches 

func (name *Name) Matches(other interface{}) bool

Matches is same as GotenEqual, but also will accept "other" if name is wildcard.

func (*Name) ParseProtoString 

func (name *Name) ParseProtoString(data string) error

func (*Name) ProtoString 

func (name *Name) ProtoString() (string, error)

func (*Name) Receive 

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

func (*Name) SetFromCliFlag 

func (name *Name) SetFromCliFlag(raw string) error

implement CustomTypeCliValue method

func (*Name) SetFromSegments 

func (name *Name) SetFromSegments(segments gotenresource.NameSegments) error

func (*Name) String 

func (name *Name) String() string

func (*Name) Type 

func (name *Name) Type() ref.Type

func (*Name) TypeName 

func (name *Name) TypeName() string

func (*Name) Value 

func (name *Name) Value() interface{}

type NameBuilder 

type NameBuilder struct {
	// contains filtered or unexported fields
}

func NewNameBuilder 

func NewNameBuilder() *NameBuilder

func (*NameBuilder) Name 

func (b *NameBuilder) Name() *Name

func (*NameBuilder) Parent 

func (b *NameBuilder) Parent() *ParentName

func (*NameBuilder) ParentReference 

func (b *NameBuilder) ParentReference() *ParentReference

func (*NameBuilder) Reference 

func (b *NameBuilder) Reference() *Reference

func (*NameBuilder) SetId 

func (b *NameBuilder) SetId(id string) *NameBuilder

func (*NameBuilder) SetOrganization 

func (b *NameBuilder) SetOrganization(parent *iam_organization.Name) *NameBuilder

func (*NameBuilder) SetOrganizationId 

func (b *NameBuilder) SetOrganizationId(id string) *NameBuilder

func (*NameBuilder) SetProject 

func (b *NameBuilder) SetProject(parent *iam_project.Name) *NameBuilder

func (*NameBuilder) SetProjectId 

func (b *NameBuilder) SetProjectId(id string) *NameBuilder

func (*NameBuilder) SetService 

func (b *NameBuilder) SetService(parent *meta_service.Name) *NameBuilder

func (*NameBuilder) SetServiceId 

func (b *NameBuilder) SetServiceId(id string) *NameBuilder

type NamePattern 

type NamePattern struct {
	Pattern gotenresource.NamePattern `firestore:"pattern"`
}

type ParentName 

type ParentName struct {
	NamePattern
	ProjectId      string `firestore:"projectId"`
	OrganizationId string `firestore:"organizationId"`
	ServiceId      string `firestore:"serviceId"`
}

func MustParseParentName 

func MustParseParentName(name string) *ParentName

func ParseParentName 

func ParseParentName(name string) (*ParentName, error)

func (*ParentName) AsRawReference 

func (name *ParentName) AsRawReference() gotenresource.Reference

func (*ParentName) AsReference 

func (name *ParentName) AsReference() *ParentReference

func (*ParentName) ConvertToNative 

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

func (*ParentName) ConvertToType 

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

func (*ParentName) DescendsFrom 

func (name *ParentName) DescendsFrom(ancestor string) bool

func (*ParentName) Equal 

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

func (*ParentName) FullyQualifiedName 

func (name *ParentName) FullyQualifiedName() (string, error)

func (*ParentName) GetIParentName 

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

func (*ParentName) GetIUnderlyingParentName 

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

func (*ParentName) GetIdParts 

func (name *ParentName) GetIdParts() map[string]string

func (*ParentName) GetOrganizationName 

func (name *ParentName) GetOrganizationName() *iam_organization.Name

func (*ParentName) GetPattern 

func (name *ParentName) GetPattern() gotenresource.NamePattern

func (*ParentName) GetProjectName 

func (name *ParentName) GetProjectName() *iam_project.Name

func (*ParentName) GetResourceDescriptor 

func (name *ParentName) GetResourceDescriptor() gotenresource.Descriptor

func (*ParentName) GetSegments 

func (name *ParentName) GetSegments() gotenresource.NameSegments

func (*ParentName) GetServiceName 

func (name *ParentName) GetServiceName() *meta_service.Name

func (*ParentName) GotenEqual 

func (name *ParentName) GotenEqual(other interface{}) bool

GotenEqual returns true if other is of same type and paths are equal (implements goten.Equaler interface)

func (*ParentName) HasTrait 

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

func (*ParentName) IsFullyQualified 

func (name *ParentName) IsFullyQualified() bool

func (*ParentName) IsSpecified 

func (name *ParentName) IsSpecified() bool

func (*ParentName) Match 

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

func (*ParentName) Matches 

func (name *ParentName) Matches(other interface{}) bool

Matches is same as GotenEqual, but also will accept "other" if name is wildcard.

func (*ParentName) ParseProtoString 

func (name *ParentName) ParseProtoString(data string) error

func (*ParentName) ProtoString 

func (name *ParentName) ProtoString() (string, error)

func (*ParentName) Receive 

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

func (*ParentName) SetFromCliFlag 

func (name *ParentName) SetFromCliFlag(raw string) error

implement CustomTypeCliValue method

func (*ParentName) SetFromSegments 

func (name *ParentName) SetFromSegments(segments gotenresource.NameSegments) error

func (*ParentName) String 

func (name *ParentName) String() string

func (*ParentName) Type 

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

func (*ParentName) TypeName 

func (name *ParentName) TypeName() string

func (*ParentName) Value 

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

type ParentReference 

type ParentReference struct {
	ParentName
	// contains filtered or unexported fields
}

func MakeParentReference 

func MakeParentReference(name *ParentName) (*ParentReference, error)

func MustParseParentReference 

func MustParseParentReference(name string) *ParentReference

func ParseParentReference 

func ParseParentReference(name string) (*ParentReference, error)

func (*ParentReference) ClearCached 

func (ref *ParentReference) ClearCached()

func (*ParentReference) GetIParentName 

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

func (*ParentReference) GetIUnderlyingParentName 

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

func (*ParentReference) GetIdParts 

func (ref *ParentReference) GetIdParts() map[string]string

func (*ParentReference) GetOrganization 

func (ref *ParentReference) GetOrganization() *iam_organization.Organization

func (*ParentReference) GetOrganizationReference 

func (ref *ParentReference) GetOrganizationReference() *iam_organization.Reference

func (*ParentReference) GetPattern 

func (ref *ParentReference) GetPattern() gotenresource.NamePattern

func (*ParentReference) GetProject 

func (ref *ParentReference) GetProject() *iam_project.Project

func (*ParentReference) GetProjectReference 

func (ref *ParentReference) GetProjectReference() *iam_project.Reference

func (*ParentReference) GetRawResource 

func (ref *ParentReference) GetRawResource() gotenresource.Resource

func (*ParentReference) GetResourceDescriptor 

func (ref *ParentReference) GetResourceDescriptor() gotenresource.Descriptor

func (*ParentReference) GetSegments 

func (ref *ParentReference) GetSegments() gotenresource.NameSegments

func (*ParentReference) GetService 

func (ref *ParentReference) GetService() *meta_service.Service

func (*ParentReference) GetServiceReference 

func (ref *ParentReference) GetServiceReference() *meta_service.Reference

func (*ParentReference) GetUnderlyingReference 

func (ref *ParentReference) GetUnderlyingReference() gotenresource.Reference

func (*ParentReference) GotenEqual 

func (ref *ParentReference) GotenEqual(other interface{}) bool

GotenEqual returns true if other is of same type and paths are equal (implements goten.Equaler interface)

func (*ParentReference) IsFullyQualified 

func (ref *ParentReference) IsFullyQualified() bool

func (*ParentReference) IsSpecified 

func (ref *ParentReference) IsSpecified() bool

func (*ParentReference) Matches 

func (name *ParentReference) Matches(other interface{}) bool

Matches is same as GotenEqual, but also will accept "other" if name is wildcard.

func (*ParentReference) ParseProtoString 

func (ref *ParentReference) ParseProtoString(data string) error

func (*ParentReference) ProtoString 

func (ref *ParentReference) ProtoString() (string, error)

func (*ParentReference) ResolveRaw 

func (ref *ParentReference) ResolveRaw(res gotenresource.Resource) error

func (*ParentReference) Resolved 

func (ref *ParentReference) Resolved() bool

func (*ParentReference) SetFromCliFlag 

func (ref *ParentReference) SetFromCliFlag(raw string) error

implement CustomTypeCliValue method

func (*ParentReference) String 

func (ref *ParentReference) String() string

type Reference 

type Reference struct {
	Name
	// contains filtered or unexported fields
}

func MakeReference 

func MakeReference(name *Name, activityLog *ActivityLog) (*Reference, error)

func MustParseReference 

func MustParseReference(name string) *Reference

func ParseReference 

func ParseReference(name string) (*Reference, error)

func (*Reference) ClearCached 

func (ref *Reference) ClearCached()

func (*Reference) FullyQualifiedName 

func (ref *Reference) FullyQualifiedName() (string, error)

func (*Reference) GetActivityLog 

func (ref *Reference) GetActivityLog() *ActivityLog

func (*Reference) GetIParentName 

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

func (*Reference) GetIUnderlyingParentName 

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

func (*Reference) GetIdParts 

func (ref *Reference) GetIdParts() map[string]string

func (*Reference) GetPattern 

func (ref *Reference) GetPattern() gotenresource.NamePattern

func (*Reference) GetRawResource 

func (ref *Reference) GetRawResource() gotenresource.Resource

func (*Reference) GetResourceDescriptor 

func (ref *Reference) GetResourceDescriptor() gotenresource.Descriptor

func (*Reference) GetSegments 

func (ref *Reference) GetSegments() gotenresource.NameSegments

func (*Reference) GotenEqual 

func (ref *Reference) GotenEqual(other interface{}) bool

GotenEqual returns true if other is of same type and paths are equal (implements goten.Equaler interface)

func (*Reference) IsFullyQualified 

func (ref *Reference) IsFullyQualified() bool

func (*Reference) IsSpecified 

func (ref *Reference) IsSpecified() bool

func (*Reference) Matches 

func (name *Reference) Matches(other interface{}) bool

Matches is same as GotenEqual, but also will accept "other" if name is wildcard.

func (*Reference) ParseProtoString 

func (ref *Reference) ParseProtoString(data string) error

func (*Reference) ProtoString 

func (ref *Reference) ProtoString() (string, error)

func (*Reference) Resolve 

func (ref *Reference) Resolve(resolved *ActivityLog)

func (*Reference) ResolveRaw 

func (ref *Reference) ResolveRaw(res gotenresource.Resource) error

func (*Reference) Resolved 

func (ref *Reference) Resolved() bool

func (*Reference) SetFromCliFlag 

func (ref *Reference) SetFromCliFlag(raw string) error

implement CustomTypeCliValue method

func (*Reference) String 

func (ref *Reference) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.