activity_log

package
v0.4.15 Latest Latest
Warning

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

 Go to latest Published: Feb 16, 2022 License: Apache-2.0 Imports: 45 Imported by: 0

Documentation

Index

Constants

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

Variables

View Source 
var (
	ActivityLog_Category_name = map[int32]string{
		0:  "Undefined",
		1:  "Update",
		2:  "Operation",
		3:  "SpecUpdateOnly",
		4:  "StateUpdateOnly",
		5:  "InternalUpdate",
		6:  "OtherUpdate",
		7:  "Rejected",
		8:  "ClientError",
		9:  "ServerError",
		10: "Read",
	}

	ActivityLog_Category_value = map[string]int32{
		"Undefined":       0,
		"Update":          1,
		"Operation":       2,
		"SpecUpdateOnly":  3,
		"StateUpdateOnly": 4,
		"InternalUpdate":  5,
		"OtherUpdate":     6,
		"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
	//   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
	// - <system>
	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 *audit_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 *audit_common.Authorization `protobuf:"bytes,6,opt,name=authorization,proto3" json:"authorization,omitempty" firestore:"authorization"`
	// Information about the service
	Service *audit_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 */
	// Subject resource for this activity.
	Resource *ActivityLog_SubjectResource `protobuf:"bytes,11,opt,name=resource,proto3" json:"resource,omitempty" firestore:"resource"`
	// Category of the activity log.
	Category ActivityLog_Category `` /* 136-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) GetAuthentication 

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

func (*ActivityLog) GetAuthorization 

func (m *ActivityLog) GetAuthorization() *audit_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) 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) GetResource 

func (m *ActivityLog) GetResource() *ActivityLog_SubjectResource

func (*ActivityLog) GetResourceDescriptor 

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

func (*ActivityLog) GetScope 

func (m *ActivityLog) GetScope() string

func (*ActivityLog) GetService 

func (m *ActivityLog) GetService() *audit_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 *audit_common.Authentication)

func (*ActivityLog) SetAuthorization 

func (m *ActivityLog) SetAuthorization(fv *audit_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) SetResource 

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

func (*ActivityLog) SetScope 

func (m *ActivityLog) SetScope(fv string)

func (*ActivityLog) SetService 

func (m *ActivityLog) SetService(fv *audit_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) 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() ([]*any.Any, bool)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues 

func (fpaov *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamp.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() (*any.Any, bool)

func (*ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsTimeValue 

func (fpv *ActivityLogEventClientMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamp.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) 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) 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() ([]*timestamp.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() (*timestamp.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) ServerMessage 

func (ActivityLogEventFieldPathBuilder) ServerMessage() ActivityLog_EventPathSelectorServerMessage

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) 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() ([]*any.Any, bool)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues 

func (fpaov *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues) AsTimeArrayOfValues() ([]*timestamp.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() (*any.Any, bool)

func (*ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsTimeValue 

func (fpv *ActivityLogEventServerMsgEvent_FieldTerminalPathValue) AsTimeValue() (*timestamp.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
)

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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) WithArrayOfValues 

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

func (ActivityLogPathSelectorAuthentication) WithSubArrayItemValue 

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

func (ActivityLogPathSelectorAuthentication) WithSubArrayOfValues 

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

func (ActivityLogPathSelectorAuthentication) WithSubPath 

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

func (ActivityLogPathSelectorAuthentication) WithSubValue 

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

func (ActivityLogPathSelectorAuthentication) WithValue 

func (s ActivityLogPathSelectorAuthentication) WithValue(value *audit_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 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 []*audit_common.Authorization) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorAuthorization) WithSubArrayItemValue 

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

func (ActivityLogPathSelectorAuthorization) WithSubArrayOfValues 

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

func (ActivityLogPathSelectorAuthorization) WithSubPath 

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

func (ActivityLogPathSelectorAuthorization) WithSubValue 

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

func (ActivityLogPathSelectorAuthorization) WithValue 

func (s ActivityLogPathSelectorAuthorization) WithValue(value *audit_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) 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 []*any.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsClientMessageData) WithValue 

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

type ActivityLogPathSelectorEventsClientMessageTime 

type ActivityLogPathSelectorEventsClientMessageTime struct{}

func (ActivityLogPathSelectorEventsClientMessageTime) FieldPath 

func (ActivityLogPathSelectorEventsClientMessageTime) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsClientMessageTime) WithArrayOfValues 

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

func (ActivityLogPathSelectorEventsClientMessageTime) WithValue 

func (s ActivityLogPathSelectorEventsClientMessageTime) WithValue(value *timestamp.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 [][]*any.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExitStatusDetails) WithItemValue 

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

func (ActivityLogPathSelectorEventsExitStatusDetails) WithValue 

func (s ActivityLogPathSelectorEventsExitStatusDetails) WithValue(value []*any.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 []*timestamp.Timestamp) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsExitTime) WithValue 

func (s ActivityLogPathSelectorEventsExitTime) WithValue(value *timestamp.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 []*any.Any) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorEventsServerMessageData) WithValue 

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

type ActivityLogPathSelectorEventsServerMessageTime 

type ActivityLogPathSelectorEventsServerMessageTime struct{}

func (ActivityLogPathSelectorEventsServerMessageTime) FieldPath 

func (ActivityLogPathSelectorEventsServerMessageTime) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorEventsServerMessageTime) WithArrayOfValues 

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

func (ActivityLogPathSelectorEventsServerMessageTime) WithValue 

func (s ActivityLogPathSelectorEventsServerMessageTime) WithValue(value *timestamp.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 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_SubjectResource) *ActivityLog_FieldTerminalPathArrayOfValues

func (ActivityLogPathSelectorResource) WithSubArrayItemValue 

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

func (ActivityLogPathSelectorResource) WithSubArrayOfValues 

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

func (ActivityLogPathSelectorResource) WithSubPath 

func (ActivityLogPathSelectorResource) WithSubPath(subPath ActivityLogSubjectResource_FieldPath) *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResource) WithSubValue 

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

func (ActivityLogPathSelectorResource) WithValue 

func (s ActivityLogPathSelectorResource) WithValue(value *ActivityLog_SubjectResource) *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_SubjectResource_Difference) *ActivityLog_FieldSubPathArrayOfValues

func (ActivityLogPathSelectorResourceDifference) WithValue 

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

type ActivityLogPathSelectorResourceDifferenceAfter 

type ActivityLogPathSelectorResourceDifferenceAfter struct{}

func (ActivityLogPathSelectorResourceDifferenceAfter) FieldPath 

func (ActivityLogPathSelectorResourceDifferenceAfter) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceDifferenceAfter) WithArrayOfValues 

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

func (ActivityLogPathSelectorResourceDifferenceAfter) WithValue 

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

type ActivityLogPathSelectorResourceDifferenceBefore 

type ActivityLogPathSelectorResourceDifferenceBefore struct{}

func (ActivityLogPathSelectorResourceDifferenceBefore) FieldPath 

func (ActivityLogPathSelectorResourceDifferenceBefore) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceDifferenceBefore) WithArrayOfValues 

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

func (ActivityLogPathSelectorResourceDifferenceBefore) WithValue 

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

type ActivityLogPathSelectorResourceDifferenceFields 

type ActivityLogPathSelectorResourceDifferenceFields struct{}

func (ActivityLogPathSelectorResourceDifferenceFields) FieldPath 

func (ActivityLogPathSelectorResourceDifferenceFields) FieldPath() *ActivityLog_FieldSubPath

func (ActivityLogPathSelectorResourceDifferenceFields) WithArrayOfValues 

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

func (ActivityLogPathSelectorResourceDifferenceFields) WithValue 

func (s ActivityLogPathSelectorResourceDifferenceFields) WithValue(value *field_mask.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) WithArrayOfValues 

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

func (ActivityLogPathSelectorService) WithSubArrayItemValue 

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

func (ActivityLogPathSelectorService) WithSubArrayOfValues 

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

func (ActivityLogPathSelectorService) WithSubPath 

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

func (ActivityLogPathSelectorService) WithSubValue 

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

func (ActivityLogPathSelectorService) WithValue 

func (s ActivityLogPathSelectorService) WithValue(value *audit_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 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) 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 ActivityLogSubjectResourceDifferenceFieldPathBuilder 

type ActivityLogSubjectResourceDifferenceFieldPathBuilder struct{}

func NewActivityLogSubjectResourceDifferenceFieldPathBuilder 

func NewActivityLogSubjectResourceDifferenceFieldPathBuilder() ActivityLogSubjectResourceDifferenceFieldPathBuilder

func (ActivityLogSubjectResourceDifferenceFieldPathBuilder) After 

func (ActivityLogSubjectResourceDifferenceFieldPathBuilder) After() ActivityLog_SubjectResource_DifferencePathSelectorAfter

func (ActivityLogSubjectResourceDifferenceFieldPathBuilder) Before 

func (ActivityLogSubjectResourceDifferenceFieldPathBuilder) Before() ActivityLog_SubjectResource_DifferencePathSelectorBefore

func (ActivityLogSubjectResourceDifferenceFieldPathBuilder) Fields 

func (ActivityLogSubjectResourceDifferenceFieldPathBuilder) Fields() ActivityLog_SubjectResource_DifferencePathSelectorFields

type ActivityLogSubjectResourceDifference_FieldPath 

type ActivityLogSubjectResourceDifference_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogSubjectResourceDifference_FieldPathSelector
	Get(source *ActivityLog_SubjectResource_Difference) []interface{}
	GetSingle(source *ActivityLog_SubjectResource_Difference) (interface{}, bool)
	ClearValue(item *ActivityLog_SubjectResource_Difference)

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

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

func BuildActivityLogSubjectResourceDifference_FieldPath 

func BuildActivityLogSubjectResourceDifference_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogSubjectResourceDifference_FieldPath, error)

func MustParseActivityLogSubjectResourceDifference_FieldPath 

func MustParseActivityLogSubjectResourceDifference_FieldPath(rawField string) ActivityLogSubjectResourceDifference_FieldPath

func ParseActivityLogSubjectResourceDifference_FieldPath 

func ParseActivityLogSubjectResourceDifference_FieldPath(rawField string) (ActivityLogSubjectResourceDifference_FieldPath, error)

type ActivityLogSubjectResourceDifference_FieldPathArrayItemValue 

type ActivityLogSubjectResourceDifference_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogSubjectResourceDifference_FieldPath
	ContainsValue(*ActivityLog_SubjectResource_Difference) bool
}

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

func MustParseActivityLogSubjectResourceDifference_FieldPathArrayItemValue 

func MustParseActivityLogSubjectResourceDifference_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogSubjectResourceDifference_FieldPathArrayItemValue

func ParseActivityLogSubjectResourceDifference_FieldPathArrayItemValue 

func ParseActivityLogSubjectResourceDifference_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogSubjectResourceDifference_FieldPathArrayItemValue, error)

ParseActivityLogSubjectResourceDifference_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogSubjectResourceDifference_FieldPathArrayOfValues 

type ActivityLogSubjectResourceDifference_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogSubjectResourceDifference_FieldPath
}

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

func MustParseActivityLogSubjectResourceDifference_FieldPathArrayOfValues 

func MustParseActivityLogSubjectResourceDifference_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogSubjectResourceDifference_FieldPathArrayOfValues

func ParseActivityLogSubjectResourceDifference_FieldPathArrayOfValues 

func ParseActivityLogSubjectResourceDifference_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogSubjectResourceDifference_FieldPathArrayOfValues, error)

type ActivityLogSubjectResourceDifference_FieldPathSelector 

type ActivityLogSubjectResourceDifference_FieldPathSelector int32
const (
	ActivityLogSubjectResourceDifference_FieldPathSelectorFields ActivityLogSubjectResourceDifference_FieldPathSelector = 0
	ActivityLogSubjectResourceDifference_FieldPathSelectorBefore ActivityLogSubjectResourceDifference_FieldPathSelector = 1
	ActivityLogSubjectResourceDifference_FieldPathSelectorAfter  ActivityLogSubjectResourceDifference_FieldPathSelector = 2
)

func (ActivityLogSubjectResourceDifference_FieldPathSelector) String 

func (s ActivityLogSubjectResourceDifference_FieldPathSelector) String() string

type ActivityLogSubjectResourceDifference_FieldPathValue 

type ActivityLogSubjectResourceDifference_FieldPathValue interface {
	ActivityLogSubjectResourceDifference_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_SubjectResource_Difference)
	CompareWith(*ActivityLog_SubjectResource_Difference) (cmp int, comparable bool)
}

ActivityLogSubjectResourceDifference_FieldPathValue allows storing values for Difference fields according to their type

func MustParseActivityLogSubjectResourceDifference_FieldPathValue 

func MustParseActivityLogSubjectResourceDifference_FieldPathValue(pathStr, valueStr string) ActivityLogSubjectResourceDifference_FieldPathValue

func ParseActivityLogSubjectResourceDifference_FieldPathValue 

func ParseActivityLogSubjectResourceDifference_FieldPathValue(pathStr, valueStr string) (ActivityLogSubjectResourceDifference_FieldPathValue, error)

type ActivityLogSubjectResourceDifference_FieldTerminalPath 

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) ClearValue 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) ClearValue(item *ActivityLog_SubjectResource_Difference)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) ClearValueRaw 

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) Get 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) Get(source *ActivityLog_SubjectResource_Difference) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_SubjectResource_Difference

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) GetDefault 

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

GetDefault returns a default value of the field type

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) GetRaw 

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) GetSingle 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) GetSingle(source *ActivityLog_SubjectResource_Difference) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_SubjectResource_Difference

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) JSONString 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) Selector 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) Selector() ActivityLogSubjectResourceDifference_FieldPathSelector

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) String 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogSubjectResourceDifference_FieldPathArrayItemValue

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogSubjectResourceDifference_FieldPathArrayOfValues

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) WithIValue 

func (fp *ActivityLogSubjectResourceDifference_FieldTerminalPath) WithIValue(value interface{}) ActivityLogSubjectResourceDifference_FieldPathValue

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPath) WithRawIValue 

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

type ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue 

type ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue struct {
	ActivityLogSubjectResourceDifference_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_SubjectResource_Difference) bool

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue) GetRawItemValue 

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

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_SubjectResource_Difference) (interface{}, bool)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues 

type ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues struct {
	ActivityLogSubjectResourceDifference_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues) AsAfterArrayOfValues 

func (fpaov *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues) AsAfterArrayOfValues() ([]*any.Any, bool)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues) AsBeforeArrayOfValues 

func (fpaov *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues) AsBeforeArrayOfValues() ([]*any.Any, bool)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues) AsFieldsArrayOfValues 

func (fpaov *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues) AsFieldsArrayOfValues() ([]*field_mask.FieldMask, bool)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogSubjectResourceDifference_FieldTerminalPathValue 

type ActivityLogSubjectResourceDifference_FieldTerminalPathValue struct {
	ActivityLogSubjectResourceDifference_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) AsAfterValue 

func (fpv *ActivityLogSubjectResourceDifference_FieldTerminalPathValue) AsAfterValue() (*any.Any, bool)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) AsBeforeValue 

func (fpv *ActivityLogSubjectResourceDifference_FieldTerminalPathValue) AsBeforeValue() (*any.Any, bool)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) AsFieldsValue 

func (fpv *ActivityLogSubjectResourceDifference_FieldTerminalPathValue) AsFieldsValue() (*field_mask.FieldMask, bool)

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogSubjectResourceDifference_FieldTerminalPathValue) CompareWith(source *ActivityLog_SubjectResource_Difference) (int, bool)

CompareWith compares value in the 'ActivityLogSubjectResourceDifference_FieldTerminalPathValue' with the value under path in 'ActivityLog_SubjectResource_Difference'.

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) GetRawValue 

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

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

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogSubjectResourceDifference_FieldTerminalPathValue) SetTo(target **ActivityLog_SubjectResource_Difference)

SetTo stores value for selected field for object Difference

func (*ActivityLogSubjectResourceDifference_FieldTerminalPathValue) SetToRaw 

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

type ActivityLogSubjectResourceFieldPathBuilder 

type ActivityLogSubjectResourceFieldPathBuilder struct{}

func NewActivityLogSubjectResourceFieldPathBuilder 

func NewActivityLogSubjectResourceFieldPathBuilder() ActivityLogSubjectResourceFieldPathBuilder

func (ActivityLogSubjectResourceFieldPathBuilder) Difference 

func (ActivityLogSubjectResourceFieldPathBuilder) Difference() ActivityLog_SubjectResourcePathSelectorDifference

func (ActivityLogSubjectResourceFieldPathBuilder) Name 

func (ActivityLogSubjectResourceFieldPathBuilder) Name() ActivityLog_SubjectResourcePathSelectorName

type ActivityLogSubjectResource_FieldPath 

type ActivityLogSubjectResource_FieldPath interface {
	gotenobject.FieldPath
	Selector() ActivityLogSubjectResource_FieldPathSelector
	Get(source *ActivityLog_SubjectResource) []interface{}
	GetSingle(source *ActivityLog_SubjectResource) (interface{}, bool)
	ClearValue(item *ActivityLog_SubjectResource)

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

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

func BuildActivityLogSubjectResource_FieldPath 

func BuildActivityLogSubjectResource_FieldPath(fp gotenobject.RawFieldPath) (ActivityLogSubjectResource_FieldPath, error)

func MustParseActivityLogSubjectResource_FieldPath 

func MustParseActivityLogSubjectResource_FieldPath(rawField string) ActivityLogSubjectResource_FieldPath

func ParseActivityLogSubjectResource_FieldPath 

func ParseActivityLogSubjectResource_FieldPath(rawField string) (ActivityLogSubjectResource_FieldPath, error)

type ActivityLogSubjectResource_FieldPathArrayItemValue 

type ActivityLogSubjectResource_FieldPathArrayItemValue interface {
	gotenobject.FieldPathArrayItemValue
	ActivityLogSubjectResource_FieldPath
	ContainsValue(*ActivityLog_SubjectResource) bool
}

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

func MustParseActivityLogSubjectResource_FieldPathArrayItemValue 

func MustParseActivityLogSubjectResource_FieldPathArrayItemValue(pathStr, valueStr string) ActivityLogSubjectResource_FieldPathArrayItemValue

func ParseActivityLogSubjectResource_FieldPathArrayItemValue 

func ParseActivityLogSubjectResource_FieldPathArrayItemValue(pathStr, valueStr string) (ActivityLogSubjectResource_FieldPathArrayItemValue, error)

ParseActivityLogSubjectResource_FieldPathArrayItemValue parses string and JSON-encoded value to its Value

type ActivityLogSubjectResource_FieldPathArrayOfValues 

type ActivityLogSubjectResource_FieldPathArrayOfValues interface {
	gotenobject.FieldPathArrayOfValues
	ActivityLogSubjectResource_FieldPath
}

ActivityLogSubjectResource_FieldPathArrayOfValues allows storing slice of values for SubjectResource fields according to their type

func MustParseActivityLogSubjectResource_FieldPathArrayOfValues 

func MustParseActivityLogSubjectResource_FieldPathArrayOfValues(pathStr, valuesStr string) ActivityLogSubjectResource_FieldPathArrayOfValues

func ParseActivityLogSubjectResource_FieldPathArrayOfValues 

func ParseActivityLogSubjectResource_FieldPathArrayOfValues(pathStr, valuesStr string) (ActivityLogSubjectResource_FieldPathArrayOfValues, error)

type ActivityLogSubjectResource_FieldPathSelector 

type ActivityLogSubjectResource_FieldPathSelector int32
const (
	ActivityLogSubjectResource_FieldPathSelectorName       ActivityLogSubjectResource_FieldPathSelector = 0
	ActivityLogSubjectResource_FieldPathSelectorDifference ActivityLogSubjectResource_FieldPathSelector = 1
)

func (ActivityLogSubjectResource_FieldPathSelector) String 

func (s ActivityLogSubjectResource_FieldPathSelector) String() string

type ActivityLogSubjectResource_FieldPathValue 

type ActivityLogSubjectResource_FieldPathValue interface {
	ActivityLogSubjectResource_FieldPath
	gotenobject.FieldPathValue
	SetTo(target **ActivityLog_SubjectResource)
	CompareWith(*ActivityLog_SubjectResource) (cmp int, comparable bool)
}

ActivityLogSubjectResource_FieldPathValue allows storing values for SubjectResource fields according to their type

func MustParseActivityLogSubjectResource_FieldPathValue 

func MustParseActivityLogSubjectResource_FieldPathValue(pathStr, valueStr string) ActivityLogSubjectResource_FieldPathValue

func ParseActivityLogSubjectResource_FieldPathValue 

func ParseActivityLogSubjectResource_FieldPathValue(pathStr, valueStr string) (ActivityLogSubjectResource_FieldPathValue, error)

type ActivityLogSubjectResource_FieldSubPath 

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

func (*ActivityLogSubjectResource_FieldSubPath) AsDifferenceSubPath 

func (fps *ActivityLogSubjectResource_FieldSubPath) AsDifferenceSubPath() (ActivityLogSubjectResourceDifference_FieldPath, bool)

func (*ActivityLogSubjectResource_FieldSubPath) ClearValue 

func (fps *ActivityLogSubjectResource_FieldSubPath) ClearValue(item *ActivityLog_SubjectResource)

func (*ActivityLogSubjectResource_FieldSubPath) ClearValueRaw 

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

func (*ActivityLogSubjectResource_FieldSubPath) Get 

func (fps *ActivityLogSubjectResource_FieldSubPath) Get(source *ActivityLog_SubjectResource) (values []interface{})

Get returns all values pointed by selected field from source ActivityLog_SubjectResource

func (*ActivityLogSubjectResource_FieldSubPath) GetDefault 

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

GetDefault returns a default value of the field type

func (*ActivityLogSubjectResource_FieldSubPath) GetRaw 

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

func (*ActivityLogSubjectResource_FieldSubPath) GetSingle 

func (fps *ActivityLogSubjectResource_FieldSubPath) GetSingle(source *ActivityLog_SubjectResource) (interface{}, bool)

GetSingle returns value of selected field from source ActivityLog_SubjectResource

func (*ActivityLogSubjectResource_FieldSubPath) GetSingleRaw 

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

func (*ActivityLogSubjectResource_FieldSubPath) IsLeaf 

func (fps *ActivityLogSubjectResource_FieldSubPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogSubjectResource_FieldSubPath) JSONString 

func (fps *ActivityLogSubjectResource_FieldSubPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogSubjectResource_FieldSubPath) Selector 

func (fps *ActivityLogSubjectResource_FieldSubPath) Selector() ActivityLogSubjectResource_FieldPathSelector

func (*ActivityLogSubjectResource_FieldSubPath) String 

func (fps *ActivityLogSubjectResource_FieldSubPath) String() string

String returns path representation in proto convention

func (*ActivityLogSubjectResource_FieldSubPath) WithIArrayItemValue 

func (fps *ActivityLogSubjectResource_FieldSubPath) WithIArrayItemValue(value interface{}) ActivityLogSubjectResource_FieldPathArrayItemValue

func (*ActivityLogSubjectResource_FieldSubPath) WithIArrayOfValues 

func (fps *ActivityLogSubjectResource_FieldSubPath) WithIArrayOfValues(values interface{}) ActivityLogSubjectResource_FieldPathArrayOfValues

func (*ActivityLogSubjectResource_FieldSubPath) WithIValue 

func (fps *ActivityLogSubjectResource_FieldSubPath) WithIValue(value interface{}) ActivityLogSubjectResource_FieldPathValue

func (*ActivityLogSubjectResource_FieldSubPath) WithRawIArrayItemValue 

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

func (*ActivityLogSubjectResource_FieldSubPath) WithRawIArrayOfValues 

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

func (*ActivityLogSubjectResource_FieldSubPath) WithRawIValue 

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

type ActivityLogSubjectResource_FieldSubPathArrayItemValue 

type ActivityLogSubjectResource_FieldSubPathArrayItemValue struct {
	ActivityLogSubjectResource_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResource_FieldSubPathArrayItemValue) AsDifferencePathItemValue 

func (fpaivs *ActivityLogSubjectResource_FieldSubPathArrayItemValue) AsDifferencePathItemValue() (ActivityLogSubjectResourceDifference_FieldPathArrayItemValue, bool)

func (*ActivityLogSubjectResource_FieldSubPathArrayItemValue) ContainsValue 

func (fpaivs *ActivityLogSubjectResource_FieldSubPathArrayItemValue) ContainsValue(source *ActivityLog_SubjectResource) bool

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

func (*ActivityLogSubjectResource_FieldSubPathArrayItemValue) GetRawItemValue 

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

GetRawValue returns stored array item value

type ActivityLogSubjectResource_FieldSubPathArrayOfValues 

type ActivityLogSubjectResource_FieldSubPathArrayOfValues struct {
	ActivityLogSubjectResource_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResource_FieldSubPathArrayOfValues) AsDifferencePathArrayOfValues 

func (fpsaov *ActivityLogSubjectResource_FieldSubPathArrayOfValues) AsDifferencePathArrayOfValues() (ActivityLogSubjectResourceDifference_FieldPathArrayOfValues, bool)

func (*ActivityLogSubjectResource_FieldSubPathArrayOfValues) GetRawValues 

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

type ActivityLogSubjectResource_FieldSubPathValue 

type ActivityLogSubjectResource_FieldSubPathValue struct {
	ActivityLogSubjectResource_FieldPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResource_FieldSubPathValue) AsDifferencePathValue 

func (fpvs *ActivityLogSubjectResource_FieldSubPathValue) AsDifferencePathValue() (ActivityLogSubjectResourceDifference_FieldPathValue, bool)

func (*ActivityLogSubjectResource_FieldSubPathValue) CompareWith 

func (fpvs *ActivityLogSubjectResource_FieldSubPathValue) CompareWith(source *ActivityLog_SubjectResource) (int, bool)

func (*ActivityLogSubjectResource_FieldSubPathValue) CompareWithRaw 

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

func (*ActivityLogSubjectResource_FieldSubPathValue) GetRawValue 

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

func (*ActivityLogSubjectResource_FieldSubPathValue) SetTo 

func (fpvs *ActivityLogSubjectResource_FieldSubPathValue) SetTo(target **ActivityLog_SubjectResource)

func (*ActivityLogSubjectResource_FieldSubPathValue) SetToRaw 

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

type ActivityLogSubjectResource_FieldTerminalPath 

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

func (*ActivityLogSubjectResource_FieldTerminalPath) ClearValue 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) ClearValue(item *ActivityLog_SubjectResource)

func (*ActivityLogSubjectResource_FieldTerminalPath) ClearValueRaw 

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

func (*ActivityLogSubjectResource_FieldTerminalPath) Get 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) Get(source *ActivityLog_SubjectResource) (values []interface{})

Get returns all values pointed by specific field from source ActivityLog_SubjectResource

func (*ActivityLogSubjectResource_FieldTerminalPath) GetDefault 

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

GetDefault returns a default value of the field type

func (*ActivityLogSubjectResource_FieldTerminalPath) GetRaw 

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

func (*ActivityLogSubjectResource_FieldTerminalPath) GetSingle 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) GetSingle(source *ActivityLog_SubjectResource) (interface{}, bool)

GetSingle returns value pointed by specific field of from source ActivityLog_SubjectResource

func (*ActivityLogSubjectResource_FieldTerminalPath) GetSingleRaw 

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

func (*ActivityLogSubjectResource_FieldTerminalPath) IsLeaf 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) IsLeaf() bool

IsLeaf - whether field path is holds simple value

func (*ActivityLogSubjectResource_FieldTerminalPath) JSONString 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) JSONString() string

JSONString returns path representation is JSON convention

func (*ActivityLogSubjectResource_FieldTerminalPath) Selector 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) Selector() ActivityLogSubjectResource_FieldPathSelector

func (*ActivityLogSubjectResource_FieldTerminalPath) String 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) String() string

String returns path representation in proto convention

func (*ActivityLogSubjectResource_FieldTerminalPath) WithIArrayItemValue 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) WithIArrayItemValue(value interface{}) ActivityLogSubjectResource_FieldPathArrayItemValue

func (*ActivityLogSubjectResource_FieldTerminalPath) WithIArrayOfValues 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) WithIArrayOfValues(values interface{}) ActivityLogSubjectResource_FieldPathArrayOfValues

func (*ActivityLogSubjectResource_FieldTerminalPath) WithIValue 

func (fp *ActivityLogSubjectResource_FieldTerminalPath) WithIValue(value interface{}) ActivityLogSubjectResource_FieldPathValue

func (*ActivityLogSubjectResource_FieldTerminalPath) WithRawIArrayItemValue 

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

func (*ActivityLogSubjectResource_FieldTerminalPath) WithRawIArrayOfValues 

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

func (*ActivityLogSubjectResource_FieldTerminalPath) WithRawIValue 

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

type ActivityLogSubjectResource_FieldTerminalPathArrayItemValue 

type ActivityLogSubjectResource_FieldTerminalPathArrayItemValue struct {
	ActivityLogSubjectResource_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResource_FieldTerminalPathArrayItemValue) ContainsValue 

func (fpaiv *ActivityLogSubjectResource_FieldTerminalPathArrayItemValue) ContainsValue(source *ActivityLog_SubjectResource) bool

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

func (*ActivityLogSubjectResource_FieldTerminalPathArrayItemValue) GetRawItemValue 

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

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

func (*ActivityLogSubjectResource_FieldTerminalPathArrayItemValue) GetSingle 

func (fpaiv *ActivityLogSubjectResource_FieldTerminalPathArrayItemValue) GetSingle(source *ActivityLog_SubjectResource) (interface{}, bool)

func (*ActivityLogSubjectResource_FieldTerminalPathArrayItemValue) GetSingleRaw 

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

type ActivityLogSubjectResource_FieldTerminalPathArrayOfValues 

type ActivityLogSubjectResource_FieldTerminalPathArrayOfValues struct {
	ActivityLogSubjectResource_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResource_FieldTerminalPathArrayOfValues) AsDifferenceArrayOfValues 

func (fpaov *ActivityLogSubjectResource_FieldTerminalPathArrayOfValues) AsDifferenceArrayOfValues() ([]*ActivityLog_SubjectResource_Difference, bool)

func (*ActivityLogSubjectResource_FieldTerminalPathArrayOfValues) AsNameArrayOfValues 

func (fpaov *ActivityLogSubjectResource_FieldTerminalPathArrayOfValues) AsNameArrayOfValues() ([]string, bool)

func (*ActivityLogSubjectResource_FieldTerminalPathArrayOfValues) GetRawValues 

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

type ActivityLogSubjectResource_FieldTerminalPathValue 

type ActivityLogSubjectResource_FieldTerminalPathValue struct {
	ActivityLogSubjectResource_FieldTerminalPath
	// contains filtered or unexported fields
}

func (*ActivityLogSubjectResource_FieldTerminalPathValue) AsDifferenceValue 

func (fpv *ActivityLogSubjectResource_FieldTerminalPathValue) AsDifferenceValue() (*ActivityLog_SubjectResource_Difference, bool)

func (*ActivityLogSubjectResource_FieldTerminalPathValue) AsNameValue 

func (fpv *ActivityLogSubjectResource_FieldTerminalPathValue) AsNameValue() (string, bool)

func (*ActivityLogSubjectResource_FieldTerminalPathValue) CompareWith 

func (fpv *ActivityLogSubjectResource_FieldTerminalPathValue) CompareWith(source *ActivityLog_SubjectResource) (int, bool)

CompareWith compares value in the 'ActivityLogSubjectResource_FieldTerminalPathValue' with the value under path in 'ActivityLog_SubjectResource'.

func (*ActivityLogSubjectResource_FieldTerminalPathValue) CompareWithRaw 

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

func (*ActivityLogSubjectResource_FieldTerminalPathValue) GetRawValue 

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

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

func (*ActivityLogSubjectResource_FieldTerminalPathValue) SetTo 

func (fpv *ActivityLogSubjectResource_FieldTerminalPathValue) SetTo(target **ActivityLog_SubjectResource)

SetTo stores value for selected field for object SubjectResource

func (*ActivityLogSubjectResource_FieldTerminalPathValue) SetToRaw 

func (fpv *ActivityLogSubjectResource_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 any request making update on the system state.
	// Note this includes not just "Update<Res>" requests, but also
	// creations and deletions (create/delete is also some UPDATE
	// of the part of the system). However, note that there are other "Update"
	// types in this enumeration.
	// Basically, this "Update" type is for any CUD request EXCEPT those
	// classified as SpecUpdateOnly, StateUpdateOnly, InternalUpdate or
	// OtherUpdate.
	ActivityLog_Update ActivityLog_Category = 1
	// Describes any request executing some special operation on the
	// system. It is to be used by special requests like connecting to
	// device with SSH.
	// It's for requests that cannot obviously be classified clearly as
	// a read or update.
	ActivityLog_Operation ActivityLog_Category = 2
	// Describes any request updating only "spec" field paths
	// on the subject resource and not updating any "state" fields.
	// It may contain additionally updated meta fields.
	// It never describes create/delete operation.
	ActivityLog_SpecUpdateOnly ActivityLog_Category = 3
	// Describes any request updating only "state" field paths
	// on the subject resource and not updating any "spec" fields.
	// It may contain additionally updated meta fields.
	// It never describes create/delete operation.
	ActivityLog_StateUpdateOnly ActivityLog_Category = 4
	// Describes internal update of the system. This is for requests
	// executed internally by the system (like controller creating role
	// binding for each group member for each role assigned to group).
	ActivityLog_InternalUpdate ActivityLog_Category = 5
	// Describes any other non-significant update request (never create/delete).
	// This is for empty updates or modifying meta fields only.
	ActivityLog_OtherUpdate ActivityLog_Category = 6
	// 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
	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) 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) 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 []*any.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorClientMessageData) WithValue 

func (s ActivityLog_EventPathSelectorClientMessageData) WithValue(value *any.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 []*timestamp.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorClientMessageTime) WithValue 

func (s ActivityLog_EventPathSelectorClientMessageTime) WithValue(value *timestamp.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 [][]*any.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExitStatusDetails) WithItemValue 

func (s ActivityLog_EventPathSelectorExitStatusDetails) WithItemValue(value *any.Any) *ActivityLogEvent_FieldSubPathArrayItemValue

func (ActivityLog_EventPathSelectorExitStatusDetails) WithValue 

func (s ActivityLog_EventPathSelectorExitStatusDetails) WithValue(value []*any.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 []*timestamp.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorExitTime) WithValue 

func (s ActivityLog_EventPathSelectorExitTime) WithValue(value *timestamp.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 []*any.Any) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorServerMessageData) WithValue 

func (s ActivityLog_EventPathSelectorServerMessageData) WithValue(value *any.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 []*timestamp.Timestamp) *ActivityLogEvent_FieldSubPathArrayOfValues

func (ActivityLog_EventPathSelectorServerMessageTime) WithValue 

func (s ActivityLog_EventPathSelectorServerMessageTime) WithValue(value *timestamp.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 *any.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" firestore:"data"`
	// Time of a message
	Time *timestamp.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() *any.Any

func (*ActivityLog_Event_ClientMsgEvent) GetTime 

func (m *ActivityLog_Event_ClientMsgEvent) GetTime() *timestamp.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 *any.Any)

func (*ActivityLog_Event_ClientMsgEvent) SetTime 

func (m *ActivityLog_Event_ClientMsgEvent) SetTime(fv *timestamp.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 []*any.Any) *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ClientMsgEventPathSelectorData) WithValue 

func (s ActivityLog_Event_ClientMsgEventPathSelectorData) WithValue(value *any.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 []*timestamp.Timestamp) *ActivityLogEventClientMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ClientMsgEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_ClientMsgEventPathSelectorTime) WithValue(value *timestamp.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 *fieldmaskpb.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() *fieldmaskpb.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 *timestamp.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() *timestamp.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 *timestamp.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 [][]*any.Any) *ActivityLogEventExitEvent_FieldSubPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithItemValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithItemValue(value *any.Any) *ActivityLogEventExitEvent_FieldSubPathArrayItemValue

func (ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithValue 

func (s ActivityLog_Event_ExitEventPathSelectorStatusDetails) WithValue(value []*any.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 []*timestamp.Timestamp) *ActivityLogEventExitEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ExitEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_ExitEventPathSelectorTime) WithValue(value *timestamp.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 *fieldmaskpb.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() *fieldmaskpb.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 *fieldmaskpb.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() *fieldmaskpb.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_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 *any.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" firestore:"data"`
	// Time of a message
	Time *timestamp.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() *any.Any

func (*ActivityLog_Event_ServerMsgEvent) GetTime 

func (m *ActivityLog_Event_ServerMsgEvent) GetTime() *timestamp.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 *any.Any)

func (*ActivityLog_Event_ServerMsgEvent) SetTime 

func (m *ActivityLog_Event_ServerMsgEvent) SetTime(fv *timestamp.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 []*any.Any) *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ServerMsgEventPathSelectorData) WithValue 

func (s ActivityLog_Event_ServerMsgEventPathSelectorData) WithValue(value *any.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 []*timestamp.Timestamp) *ActivityLogEventServerMsgEvent_FieldTerminalPathArrayOfValues

func (ActivityLog_Event_ServerMsgEventPathSelectorTime) WithValue 

func (s ActivityLog_Event_ServerMsgEventPathSelectorTime) WithValue(value *timestamp.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 *fieldmaskpb.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() *fieldmaskpb.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 *fieldmaskpb.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() *fieldmaskpb.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) 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_FieldPathSelectorResource        ActivityLog_FieldPathSelector = 8
	ActivityLog_FieldPathSelectorCategory        ActivityLog_FieldPathSelector = 9
	ActivityLog_FieldPathSelectorLabels          ActivityLog_FieldPathSelector = 10
	ActivityLog_FieldPathSelectorEvents          ActivityLog_FieldPathSelector = 11
)

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() (audit_common.Authentication_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsAuthorizationSubPath 

func (fps *ActivityLog_FieldSubPath) AsAuthorizationSubPath() (audit_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) AsResourceSubPath 

func (fps *ActivityLog_FieldSubPath) AsResourceSubPath() (ActivityLogSubjectResource_FieldPath, bool)

func (*ActivityLog_FieldSubPath) AsServiceSubPath 

func (fps *ActivityLog_FieldSubPath) AsServiceSubPath() (audit_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) 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() (audit_common.Authentication_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsAuthorizationPathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsAuthorizationPathItemValue() (audit_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) AsResourcePathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsResourcePathItemValue() (ActivityLogSubjectResource_FieldPathArrayItemValue, bool)

func (*ActivityLog_FieldSubPathArrayItemValue) AsServicePathItemValue 

func (fpaivs *ActivityLog_FieldSubPathArrayItemValue) AsServicePathItemValue() (audit_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() (audit_common.Authentication_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsAuthorizationPathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsAuthorizationPathArrayOfValues() (audit_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) AsResourcePathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (ActivityLogSubjectResource_FieldPathArrayOfValues, bool)

func (*ActivityLog_FieldSubPathArrayOfValues) AsServicePathArrayOfValues 

func (fpsaov *ActivityLog_FieldSubPathArrayOfValues) AsServicePathArrayOfValues() (audit_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() (audit_common.Authentication_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsAuthorizationPathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsAuthorizationPathValue() (audit_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) AsResourcePathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsResourcePathValue() (ActivityLogSubjectResource_FieldPathValue, bool)

func (*ActivityLog_FieldSubPathValue) AsServicePathValue 

func (fpvs *ActivityLog_FieldSubPathValue) AsServicePathValue() (audit_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) 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() ([]*audit_common.Authentication, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsAuthorizationArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsAuthorizationArrayOfValues() ([]*audit_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) AsResourceArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*ActivityLog_SubjectResource, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsScopeArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsScopeArrayOfValues() ([]string, bool)

func (*ActivityLog_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues 

func (fpaov *ActivityLog_FieldTerminalPathArrayOfValues) AsServiceArrayOfValues() ([]*audit_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() (*audit_common.Authentication, bool)

func (*ActivityLog_FieldTerminalPathValue) AsAuthorizationValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsAuthorizationValue() (*audit_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) AsResourceValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsResourceValue() (*ActivityLog_SubjectResource, bool)

func (*ActivityLog_FieldTerminalPathValue) AsScopeValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsScopeValue() (string, bool)

func (*ActivityLog_FieldTerminalPathValue) AsServiceValue 

func (fpv *ActivityLog_FieldTerminalPathValue) AsServiceValue() (*audit_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 *fieldmaskpb.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() *fieldmaskpb.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 *fieldmaskpb.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() *fieldmaskpb.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_SubjectResource 

type ActivityLog_SubjectResource 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 subject resource.
	// Left empty if the request described by this activity log did not
	// update the resource.
	Difference *ActivityLog_SubjectResource_Difference `protobuf:"bytes,2,opt,name=difference,proto3" json:"difference,omitempty" firestore:"difference"`
	// contains filtered or unexported fields
}

Description of the main subject resource activity refers to. For standard, goten-generated actions it's same as subject resource of the method. For custom actions, in some cases, developer may pick however different resource (it is customizable in proto audit spec).

func (*ActivityLog_SubjectResource) Clone 

func (o *ActivityLog_SubjectResource) Clone() *ActivityLog_SubjectResource

func (*ActivityLog_SubjectResource) CloneRaw 

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

func (*ActivityLog_SubjectResource) Descriptor 

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

Deprecated, Use ActivityLog_SubjectResource.ProtoReflect.Descriptor instead.

func (*ActivityLog_SubjectResource) GetDifference 

func (m *ActivityLog_SubjectResource) GetDifference() *ActivityLog_SubjectResource_Difference

func (*ActivityLog_SubjectResource) GetName 

func (m *ActivityLog_SubjectResource) GetName() string

func (*ActivityLog_SubjectResource) GotenMessage 

func (*ActivityLog_SubjectResource) GotenMessage()

func (*ActivityLog_SubjectResource) GotenObjectExt 

func (o *ActivityLog_SubjectResource) GotenObjectExt()

func (*ActivityLog_SubjectResource) GotenValidate 

func (obj *ActivityLog_SubjectResource) GotenValidate() error

func (*ActivityLog_SubjectResource) MakeDiffFieldMask 

func (o *ActivityLog_SubjectResource) MakeDiffFieldMask(other *ActivityLog_SubjectResource) *ActivityLog_SubjectResource_FieldMask

func (*ActivityLog_SubjectResource) MakeFullFieldMask 

func (o *ActivityLog_SubjectResource) MakeFullFieldMask() *ActivityLog_SubjectResource_FieldMask

func (*ActivityLog_SubjectResource) MakeRawDiffFieldMask 

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

func (*ActivityLog_SubjectResource) MakeRawFullFieldMask 

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

func (*ActivityLog_SubjectResource) Marshal 

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

func (*ActivityLog_SubjectResource) MarshalJSON 

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

func (*ActivityLog_SubjectResource) Merge 

func (o *ActivityLog_SubjectResource) Merge(source *ActivityLog_SubjectResource)

func (*ActivityLog_SubjectResource) MergeRaw 

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

func (*ActivityLog_SubjectResource) ProtoMessage 

func (*ActivityLog_SubjectResource) ProtoMessage()

func (*ActivityLog_SubjectResource) ProtoReflect 

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

func (*ActivityLog_SubjectResource) Reset 

func (m *ActivityLog_SubjectResource) Reset()

func (*ActivityLog_SubjectResource) SetDifference 

func (m *ActivityLog_SubjectResource) SetDifference(fv *ActivityLog_SubjectResource_Difference)

func (*ActivityLog_SubjectResource) SetName 

func (m *ActivityLog_SubjectResource) SetName(fv string)

func (*ActivityLog_SubjectResource) String 

func (m *ActivityLog_SubjectResource) String() string

func (*ActivityLog_SubjectResource) Unmarshal 

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

func (*ActivityLog_SubjectResource) UnmarshalJSON 

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

type ActivityLog_SubjectResourcePathSelectorDifference 

type ActivityLog_SubjectResourcePathSelectorDifference struct{}

func (ActivityLog_SubjectResourcePathSelectorDifference) After 

func (ActivityLog_SubjectResourcePathSelectorDifference) After() ActivityLog_SubjectResourcePathSelectorDifferenceAfter

func (ActivityLog_SubjectResourcePathSelectorDifference) Before 

func (ActivityLog_SubjectResourcePathSelectorDifference) Before() ActivityLog_SubjectResourcePathSelectorDifferenceBefore

func (ActivityLog_SubjectResourcePathSelectorDifference) FieldPath 

func (ActivityLog_SubjectResourcePathSelectorDifference) FieldPath() *ActivityLogSubjectResource_FieldTerminalPath

func (ActivityLog_SubjectResourcePathSelectorDifference) Fields 

func (ActivityLog_SubjectResourcePathSelectorDifference) Fields() ActivityLog_SubjectResourcePathSelectorDifferenceFields

func (ActivityLog_SubjectResourcePathSelectorDifference) WithArrayOfValues 

func (s ActivityLog_SubjectResourcePathSelectorDifference) WithArrayOfValues(values []*ActivityLog_SubjectResource_Difference) *ActivityLogSubjectResource_FieldTerminalPathArrayOfValues

func (ActivityLog_SubjectResourcePathSelectorDifference) WithSubArrayItemValue 

func (s ActivityLog_SubjectResourcePathSelectorDifference) WithSubArrayItemValue(subPathArrayItemValue ActivityLogSubjectResourceDifference_FieldPathArrayItemValue) *ActivityLogSubjectResource_FieldSubPathArrayItemValue

func (ActivityLog_SubjectResourcePathSelectorDifference) WithSubArrayOfValues 

func (s ActivityLog_SubjectResourcePathSelectorDifference) WithSubArrayOfValues(subPathArrayOfValues ActivityLogSubjectResourceDifference_FieldPathArrayOfValues) *ActivityLogSubjectResource_FieldSubPathArrayOfValues

func (ActivityLog_SubjectResourcePathSelectorDifference) WithSubPath 

func (ActivityLog_SubjectResourcePathSelectorDifference) WithSubPath(subPath ActivityLogSubjectResourceDifference_FieldPath) *ActivityLogSubjectResource_FieldSubPath

func (ActivityLog_SubjectResourcePathSelectorDifference) WithSubValue 

func (s ActivityLog_SubjectResourcePathSelectorDifference) WithSubValue(subPathValue ActivityLogSubjectResourceDifference_FieldPathValue) *ActivityLogSubjectResource_FieldSubPathValue

func (ActivityLog_SubjectResourcePathSelectorDifference) WithValue 

func (s ActivityLog_SubjectResourcePathSelectorDifference) WithValue(value *ActivityLog_SubjectResource_Difference) *ActivityLogSubjectResource_FieldTerminalPathValue

type ActivityLog_SubjectResourcePathSelectorDifferenceAfter 

type ActivityLog_SubjectResourcePathSelectorDifferenceAfter struct{}

func (ActivityLog_SubjectResourcePathSelectorDifferenceAfter) FieldPath 

func (ActivityLog_SubjectResourcePathSelectorDifferenceAfter) FieldPath() *ActivityLogSubjectResource_FieldSubPath

func (ActivityLog_SubjectResourcePathSelectorDifferenceAfter) WithArrayOfValues 

func (s ActivityLog_SubjectResourcePathSelectorDifferenceAfter) WithArrayOfValues(values []*any.Any) *ActivityLogSubjectResource_FieldSubPathArrayOfValues

func (ActivityLog_SubjectResourcePathSelectorDifferenceAfter) WithValue 

func (s ActivityLog_SubjectResourcePathSelectorDifferenceAfter) WithValue(value *any.Any) *ActivityLogSubjectResource_FieldSubPathValue

type ActivityLog_SubjectResourcePathSelectorDifferenceBefore 

type ActivityLog_SubjectResourcePathSelectorDifferenceBefore struct{}

func (ActivityLog_SubjectResourcePathSelectorDifferenceBefore) FieldPath 

func (ActivityLog_SubjectResourcePathSelectorDifferenceBefore) FieldPath() *ActivityLogSubjectResource_FieldSubPath

func (ActivityLog_SubjectResourcePathSelectorDifferenceBefore) WithArrayOfValues 

func (s ActivityLog_SubjectResourcePathSelectorDifferenceBefore) WithArrayOfValues(values []*any.Any) *ActivityLogSubjectResource_FieldSubPathArrayOfValues

func (ActivityLog_SubjectResourcePathSelectorDifferenceBefore) WithValue 

func (s ActivityLog_SubjectResourcePathSelectorDifferenceBefore) WithValue(value *any.Any) *ActivityLogSubjectResource_FieldSubPathValue

type ActivityLog_SubjectResourcePathSelectorDifferenceFields 

type ActivityLog_SubjectResourcePathSelectorDifferenceFields struct{}

func (ActivityLog_SubjectResourcePathSelectorDifferenceFields) FieldPath 

func (ActivityLog_SubjectResourcePathSelectorDifferenceFields) FieldPath() *ActivityLogSubjectResource_FieldSubPath

func (ActivityLog_SubjectResourcePathSelectorDifferenceFields) WithArrayOfValues 

func (s ActivityLog_SubjectResourcePathSelectorDifferenceFields) WithArrayOfValues(values []*field_mask.FieldMask) *ActivityLogSubjectResource_FieldSubPathArrayOfValues

func (ActivityLog_SubjectResourcePathSelectorDifferenceFields) WithValue 

func (s ActivityLog_SubjectResourcePathSelectorDifferenceFields) WithValue(value *field_mask.FieldMask) *ActivityLogSubjectResource_FieldSubPathValue

type ActivityLog_SubjectResourcePathSelectorName 

type ActivityLog_SubjectResourcePathSelectorName struct{}

func (ActivityLog_SubjectResourcePathSelectorName) FieldPath 

func (ActivityLog_SubjectResourcePathSelectorName) FieldPath() *ActivityLogSubjectResource_FieldTerminalPath

func (ActivityLog_SubjectResourcePathSelectorName) WithArrayOfValues 

func (s ActivityLog_SubjectResourcePathSelectorName) WithArrayOfValues(values []string) *ActivityLogSubjectResource_FieldTerminalPathArrayOfValues

func (ActivityLog_SubjectResourcePathSelectorName) WithValue 

func (s ActivityLog_SubjectResourcePathSelectorName) WithValue(value string) *ActivityLogSubjectResource_FieldTerminalPathValue

type ActivityLog_SubjectResource_Difference 

type ActivityLog_SubjectResource_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 *field_mask.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 *any.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 *any.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_SubjectResource_Difference) Clone 

func (o *ActivityLog_SubjectResource_Difference) Clone() *ActivityLog_SubjectResource_Difference

func (*ActivityLog_SubjectResource_Difference) CloneRaw 

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

func (*ActivityLog_SubjectResource_Difference) Descriptor 

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

Deprecated, Use ActivityLog_SubjectResource_Difference.ProtoReflect.Descriptor instead.

func (*ActivityLog_SubjectResource_Difference) GetAfter 

func (m *ActivityLog_SubjectResource_Difference) GetAfter() *any.Any

func (*ActivityLog_SubjectResource_Difference) GetBefore 

func (m *ActivityLog_SubjectResource_Difference) GetBefore() *any.Any

func (*ActivityLog_SubjectResource_Difference) GetFields 

func (m *ActivityLog_SubjectResource_Difference) GetFields() *field_mask.FieldMask

func (*ActivityLog_SubjectResource_Difference) GotenMessage 

func (*ActivityLog_SubjectResource_Difference) GotenMessage()

func (*ActivityLog_SubjectResource_Difference) GotenObjectExt 

func (o *ActivityLog_SubjectResource_Difference) GotenObjectExt()

func (*ActivityLog_SubjectResource_Difference) GotenValidate 

func (obj *ActivityLog_SubjectResource_Difference) GotenValidate() error

func (*ActivityLog_SubjectResource_Difference) MakeDiffFieldMask 

func (o *ActivityLog_SubjectResource_Difference) MakeDiffFieldMask(other *ActivityLog_SubjectResource_Difference) *ActivityLog_SubjectResource_Difference_FieldMask

func (*ActivityLog_SubjectResource_Difference) MakeFullFieldMask 

func (o *ActivityLog_SubjectResource_Difference) MakeFullFieldMask() *ActivityLog_SubjectResource_Difference_FieldMask

func (*ActivityLog_SubjectResource_Difference) MakeRawDiffFieldMask 

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

func (*ActivityLog_SubjectResource_Difference) MakeRawFullFieldMask 

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

func (*ActivityLog_SubjectResource_Difference) Marshal 

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

func (*ActivityLog_SubjectResource_Difference) MarshalJSON 

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

func (*ActivityLog_SubjectResource_Difference) Merge 

func (o *ActivityLog_SubjectResource_Difference) Merge(source *ActivityLog_SubjectResource_Difference)

func (*ActivityLog_SubjectResource_Difference) MergeRaw 

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

func (*ActivityLog_SubjectResource_Difference) ProtoMessage 

func (*ActivityLog_SubjectResource_Difference) ProtoMessage()

func (*ActivityLog_SubjectResource_Difference) ProtoReflect 

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

func (*ActivityLog_SubjectResource_Difference) Reset 

func (m *ActivityLog_SubjectResource_Difference) Reset()

func (*ActivityLog_SubjectResource_Difference) SetAfter 

func (m *ActivityLog_SubjectResource_Difference) SetAfter(fv *any.Any)

func (*ActivityLog_SubjectResource_Difference) SetBefore 

func (m *ActivityLog_SubjectResource_Difference) SetBefore(fv *any.Any)

func (*ActivityLog_SubjectResource_Difference) SetFields 

func (m *ActivityLog_SubjectResource_Difference) SetFields(fv *field_mask.FieldMask)

func (*ActivityLog_SubjectResource_Difference) String 

func (m *ActivityLog_SubjectResource_Difference) String() string

func (*ActivityLog_SubjectResource_Difference) Unmarshal 

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

func (*ActivityLog_SubjectResource_Difference) UnmarshalJSON 

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

type ActivityLog_SubjectResource_DifferencePathSelectorAfter 

type ActivityLog_SubjectResource_DifferencePathSelectorAfter struct{}

func (ActivityLog_SubjectResource_DifferencePathSelectorAfter) FieldPath 

func (ActivityLog_SubjectResource_DifferencePathSelectorAfter) FieldPath() *ActivityLogSubjectResourceDifference_FieldTerminalPath

func (ActivityLog_SubjectResource_DifferencePathSelectorAfter) WithArrayOfValues 

func (s ActivityLog_SubjectResource_DifferencePathSelectorAfter) WithArrayOfValues(values []*any.Any) *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues

func (ActivityLog_SubjectResource_DifferencePathSelectorAfter) WithValue 

func (s ActivityLog_SubjectResource_DifferencePathSelectorAfter) WithValue(value *any.Any) *ActivityLogSubjectResourceDifference_FieldTerminalPathValue

type ActivityLog_SubjectResource_DifferencePathSelectorBefore 

type ActivityLog_SubjectResource_DifferencePathSelectorBefore struct{}

func (ActivityLog_SubjectResource_DifferencePathSelectorBefore) FieldPath 

func (ActivityLog_SubjectResource_DifferencePathSelectorBefore) FieldPath() *ActivityLogSubjectResourceDifference_FieldTerminalPath

func (ActivityLog_SubjectResource_DifferencePathSelectorBefore) WithArrayOfValues 

func (s ActivityLog_SubjectResource_DifferencePathSelectorBefore) WithArrayOfValues(values []*any.Any) *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues

func (ActivityLog_SubjectResource_DifferencePathSelectorBefore) WithValue 

func (s ActivityLog_SubjectResource_DifferencePathSelectorBefore) WithValue(value *any.Any) *ActivityLogSubjectResourceDifference_FieldTerminalPathValue

type ActivityLog_SubjectResource_DifferencePathSelectorFields 

type ActivityLog_SubjectResource_DifferencePathSelectorFields struct{}

func (ActivityLog_SubjectResource_DifferencePathSelectorFields) FieldPath 

func (ActivityLog_SubjectResource_DifferencePathSelectorFields) FieldPath() *ActivityLogSubjectResourceDifference_FieldTerminalPath

func (ActivityLog_SubjectResource_DifferencePathSelectorFields) WithArrayOfValues 

func (s ActivityLog_SubjectResource_DifferencePathSelectorFields) WithArrayOfValues(values []*field_mask.FieldMask) *ActivityLogSubjectResourceDifference_FieldTerminalPathArrayOfValues

func (ActivityLog_SubjectResource_DifferencePathSelectorFields) WithValue 

func (s ActivityLog_SubjectResource_DifferencePathSelectorFields) WithValue(value *field_mask.FieldMask) *ActivityLogSubjectResourceDifference_FieldTerminalPathValue

type ActivityLog_SubjectResource_Difference_FieldMask 

type ActivityLog_SubjectResource_Difference_FieldMask struct {
	Paths []ActivityLogSubjectResourceDifference_FieldPath
}

func FullActivityLog_SubjectResource_Difference_FieldMask 

func FullActivityLog_SubjectResource_Difference_FieldMask() *ActivityLog_SubjectResource_Difference_FieldMask

func (*ActivityLog_SubjectResource_Difference_FieldMask) AppendPath 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) AppendPath(path ActivityLogSubjectResourceDifference_FieldPath)

func (*ActivityLog_SubjectResource_Difference_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_SubjectResource_Difference_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_SubjectResource_Difference_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_SubjectResource_Difference_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) FilterInputFields() *ActivityLog_SubjectResource_Difference_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_SubjectResource_Difference_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

func (*ActivityLog_SubjectResource_Difference_FieldMask) GetPaths 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) GetPaths() []ActivityLogSubjectResourceDifference_FieldPath

func (*ActivityLog_SubjectResource_Difference_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_SubjectResource_Difference_FieldMask) IsFull 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) IsFull() bool

func (ActivityLog_SubjectResource_Difference_FieldMask) Marshal 

func (fieldMask ActivityLog_SubjectResource_Difference_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_SubjectResource_Difference_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_SubjectResource_Difference_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_SubjectResource_Difference_FieldMask) PathsCount 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) PathsCount() int

func (*ActivityLog_SubjectResource_Difference_FieldMask) Project 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) Project(source *ActivityLog_SubjectResource_Difference) *ActivityLog_SubjectResource_Difference

func (*ActivityLog_SubjectResource_Difference_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_SubjectResource_Difference_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) ProtoMessage()

func (*ActivityLog_SubjectResource_Difference_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_SubjectResource_Difference_FieldMask) Reset 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) Reset()

func (*ActivityLog_SubjectResource_Difference_FieldMask) Set 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) Set(target, source *ActivityLog_SubjectResource_Difference)

func (*ActivityLog_SubjectResource_Difference_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_SubjectResource_Difference_FieldMask) SetRaw 

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

func (*ActivityLog_SubjectResource_Difference_FieldMask) Size 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) Size() int

func (*ActivityLog_SubjectResource_Difference_FieldMask) String 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) String() string

func (*ActivityLog_SubjectResource_Difference_FieldMask) Subtract 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) Subtract(other *ActivityLog_SubjectResource_Difference_FieldMask) *ActivityLog_SubjectResource_Difference_FieldMask

func (*ActivityLog_SubjectResource_Difference_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_SubjectResource_Difference_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_SubjectResource_Difference_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_SubjectResource_Difference_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_SubjectResource_Difference_FieldMask) UnmarshalJSON(data []byte) error

type ActivityLog_SubjectResource_FieldMask 

type ActivityLog_SubjectResource_FieldMask struct {
	Paths []ActivityLogSubjectResource_FieldPath
}

func FullActivityLog_SubjectResource_FieldMask 

func FullActivityLog_SubjectResource_FieldMask() *ActivityLog_SubjectResource_FieldMask

func (*ActivityLog_SubjectResource_FieldMask) AppendPath 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) AppendPath(path ActivityLogSubjectResource_FieldPath)

func (*ActivityLog_SubjectResource_FieldMask) AppendRawPath 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) AppendRawPath(path gotenobject.FieldPath)

func (*ActivityLog_SubjectResource_FieldMask) DecodeFirestore 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) DecodeFirestore(fpbv *firestorepb.Value) error

func (*ActivityLog_SubjectResource_FieldMask) EncodeFirestore 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) EncodeFirestore() (*firestorepb.Value, error)

firestore encoding/decoding integration

func (*ActivityLog_SubjectResource_FieldMask) FilterInputFields 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) FilterInputFields() *ActivityLog_SubjectResource_FieldMask

FilterInputFields generates copy of field paths with output_only field paths removed

func (*ActivityLog_SubjectResource_FieldMask) FromProtoFieldMask 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) FromProtoFieldMask(protoFieldMask *fieldmaskpb.FieldMask) error

func (*ActivityLog_SubjectResource_FieldMask) GetPaths 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) GetPaths() []ActivityLogSubjectResource_FieldPath

func (*ActivityLog_SubjectResource_FieldMask) GetRawPaths 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) GetRawPaths() []gotenobject.FieldPath

func (*ActivityLog_SubjectResource_FieldMask) IsFull 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) IsFull() bool

func (ActivityLog_SubjectResource_FieldMask) Marshal 

func (fieldMask ActivityLog_SubjectResource_FieldMask) Marshal() ([]byte, error)

implement methods required by customType

func (ActivityLog_SubjectResource_FieldMask) MarshalJSON 

func (fieldMask ActivityLog_SubjectResource_FieldMask) MarshalJSON() ([]byte, error)

func (*ActivityLog_SubjectResource_FieldMask) PathsCount 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) PathsCount() int

func (*ActivityLog_SubjectResource_FieldMask) Project 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) Project(source *ActivityLog_SubjectResource) *ActivityLog_SubjectResource

func (*ActivityLog_SubjectResource_FieldMask) ProjectRaw 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt

func (*ActivityLog_SubjectResource_FieldMask) ProtoMessage 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) ProtoMessage()

func (*ActivityLog_SubjectResource_FieldMask) ProtoReflect 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) ProtoReflect() preflect.Message

func (*ActivityLog_SubjectResource_FieldMask) Reset 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) Reset()

func (*ActivityLog_SubjectResource_FieldMask) Set 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) Set(target, source *ActivityLog_SubjectResource)

func (*ActivityLog_SubjectResource_FieldMask) SetFromCliFlag 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) SetFromCliFlag(raw string) error

func (*ActivityLog_SubjectResource_FieldMask) SetRaw 

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

func (*ActivityLog_SubjectResource_FieldMask) Size 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) Size() int

func (*ActivityLog_SubjectResource_FieldMask) String 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) String() string

func (*ActivityLog_SubjectResource_FieldMask) Subtract 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) Subtract(other *ActivityLog_SubjectResource_FieldMask) *ActivityLog_SubjectResource_FieldMask

func (*ActivityLog_SubjectResource_FieldMask) SubtractRaw 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask

func (*ActivityLog_SubjectResource_FieldMask) ToProtoFieldMask 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) ToProtoFieldMask() *fieldmaskpb.FieldMask

ToFieldMask is used for proto conversions

func (*ActivityLog_SubjectResource_FieldMask) Unmarshal 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) Unmarshal(data []byte) error

func (*ActivityLog_SubjectResource_FieldMask) UnmarshalJSON 

func (fieldMask *ActivityLog_SubjectResource_FieldMask) UnmarshalJSON(data []byte) error

type Descriptor 

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

func GetDescriptor 

func GetDescriptor() *Descriptor

func (*Descriptor) GetNameDescriptor 

func (d *Descriptor) GetNameDescriptor() *gotenresource.NameDescriptor

func (*Descriptor) GetResourceTypeName 

func (d *Descriptor) GetResourceTypeName() *gotenresource.TypeName

func (*Descriptor) NewActivityLog 

func (d *Descriptor) NewActivityLog() *ActivityLog

func (*Descriptor) NewActivityLogList 

func (d *Descriptor) NewActivityLogList(size, reserved int) ActivityLogList

func (*Descriptor) NewActivityLogMap 

func (d *Descriptor) NewActivityLogMap(reserved int) ActivityLogMap

func (*Descriptor) NewActivityLogName 

func (d *Descriptor) NewActivityLogName() *Name

func (*Descriptor) NewActivityLogNameList 

func (d *Descriptor) NewActivityLogNameList(size, reserved int) ActivityLogNameList

func (*Descriptor) NewActivityLogParentNameList 

func (d *Descriptor) NewActivityLogParentNameList(size, reserved int) ActivityLogParentNameList

func (*Descriptor) NewActivityLogParentReferenceList 

func (d *Descriptor) NewActivityLogParentReferenceList(size, reserved int) ActivityLogParentReferenceList

func (*Descriptor) NewActivityLogReferenceList 

func (d *Descriptor) NewActivityLogReferenceList(size, reserved int) ActivityLogReferenceList

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) 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) NewSearchQuery 

func (d *Descriptor) NewSearchQuery() gotenresource.SearchQuery

func (*Descriptor) NewSearchQueryResultSnapshot 

func (d *Descriptor) NewSearchQueryResultSnapshot() gotenresource.SearchQueryResultSnapshot

func (*Descriptor) NewWatchQuery 

func (d *Descriptor) NewWatchQuery() gotenresource.WatchQuery

func (*Descriptor) ParseActivityLogName 

func (d *Descriptor) ParseActivityLogName(nameStr string) (*Name, error)

func (*Descriptor) ParseFieldPath 

func (d *Descriptor) ParseFieldPath(raw string) (gotenobject.FieldPath, error)

func (*Descriptor) ParseResourceName 

func (d *Descriptor) ParseResourceName(nameStr string) (gotenresource.Name, error)

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) 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) 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

type NamePattern 

type NamePattern struct {
	Pattern gotenresource.NamePattern `firestore:"pattern"`
}

type ParentName 

type ParentName struct {
	NamePattern
	ProjectId      string `firestore:"projectId"`
	OrganizationId string `firestore:"organizationId"`
}

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) DescendsFrom 

func (name *ParentName) DescendsFrom(ancestor string) bool

func (*ParentName) FullyQualifiedName 

func (name *ParentName) FullyQualifiedName() (string, error)

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) 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) IsFullyQualified 

func (name *ParentName) IsFullyQualified() bool

func (*ParentName) IsSpecified 

func (name *ParentName) IsSpecified() bool

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) 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

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) 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) 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) 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.