package google.protobuf

Get desktop application:
View/edit binary Protocol Buffers messages

Wrapper message for `bool`. The JSON representation for `BoolValue` is JSON `true` and `false`.

bool value = 1
The bool value.

Wrapper message for `bytes`. The JSON representation for `BytesValue` is JSON string.

bytes value = 1
The bytes value.

Wrapper message for `double`. The JSON representation for `DoubleValue` is JSON number.

Used in: protos.Literal, protos.playbooks.TableResultRule, protos.playbooks.TimeseriesResult.LabeledMetricTimeseries.Datapoint, protos.playbooks.TimeseriesResultRule

double value = 1
The double value.

Wrapper message for `float`. The JSON representation for `FloatValue` is JSON number.

float value = 1
The float value.

Wrapper message for `int32`. The JSON representation for `Int32Value` is JSON number.

int32 value = 1
The int32 value.

Wrapper message for `int64`. The JSON representation for `Int64Value` is JSON string.

Used in: protos.Literal, protos.playbooks.ArgoCD.FetchDeploymentInfo, protos.playbooks.ArgoCD.FetchRevisionHistory

int64 value = 1
The int64 value.

`ListValue` is a wrapper around a repeated field of values. The JSON representation for `ListValue` is JSON array.

Used in: Value

repeated Value values = 1
Repeated field of dynamically typed values.

`NullValue` is a singleton enumeration to represent the null value for the `Value` type union. The JSON representation for `NullValue` is JSON `null`.

Used in: Value

NULL_VALUE = 0
Null value.

Wrapper message for `string`. The JSON representation for `StringValue` is JSON string.

string value = 1
The string value.

`Struct` represents a structured data value, consisting of fields which map to dynamically typed values. In some languages, `Struct` might be supported by a native representation. For example, in scripting languages like JS a struct is represented as an object. The details of that representation are described together with the proto support for the language. The JSON representation for `Struct` is JSON object.

Used in: SlackAlert, Value, protos.playbooks.ApiResponseResult, protos.playbooks.ApiTriggerWorkflowAction, protos.playbooks.DeprecatedPlaybook, protos.playbooks.DeprecatedPlaybookActionTaskDefinition, protos.playbooks.DeprecatedPlaybookDocumentationTaskExecutionResult.Result.MarkdownResult, protos.playbooks.DeprecatedPlaybookTaskDefinition, protos.playbooks.ExecutePlaybookRequest, protos.playbooks.Lambda.Function, protos.playbooks.MSTeams.SendMessageWebhook, protos.playbooks.PagerDuty.SendNote, protos.playbooks.Playbook, protos.playbooks.PlaybookExecution, protos.playbooks.PlaybookStepRelationExecutionLog, protos.playbooks.PlaybookTask, protos.playbooks.PlaybookTaskExecutionLog, protos.playbooks.PlaybookTaskResult, protos.playbooks.PlaybookTemplatesGetResponse, protos.playbooks.RunPlaybookTaskRequestV3, protos.playbooks.Slack.SendMessage, protos.playbooks.Slack.SendThreadReply, protos.playbooks.TestResultTransformerRequest, protos.playbooks.TestResultTransformerResponse, protos.playbooks.TestWorkflowTransformerRequest, protos.playbooks.TestWorkflowTransformerResponse, protos.playbooks.WorkflowConfiguration, protos.playbooks.WorkflowExecution.WorkflowExecutionMetadata, protos.playbooks.Zenduty.SendNote

map<string, Value> fields = 1
Unordered map of dynamically typed values.

A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # Examples Example 1: Compute Timestamp from POSIX `time()`. Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); Example 2: Compute Timestamp from POSIX `gettimeofday()`. struct timeval tv; gettimeofday(&tv, NULL); Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. long millis = System.currentTimeMillis(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); Example 5: Compute Timestamp from Java `Instant.now()`. Instant now = Instant.now(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(now.getEpochSecond()) .setNanos(now.getNano()).build(); Example 6: Compute Timestamp from current time in Python. timestamp = Timestamp() timestamp.GetCurrentTime() # JSON Mapping In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() ) to obtain a formatter capable of generating timestamps in this format.

Used in: protos.accounts.AccountApiToken

int64 seconds = 1
Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
int32 nanos = 2
Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.

Wrapper message for `uint32`. The JSON representation for `UInt32Value` is JSON number.

Used in: protos.Meta, protos.Page

uint32 value = 1
The uint32 value.

Wrapper message for `uint64`. The JSON representation for `UInt64Value` is JSON string.

uint64 value = 1
The uint64 value.

`Value` represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values. A producer of value is expected to set one of these variants. Absence of any variant indicates an error. The JSON representation for `Value` is JSON value.

Used in: ListValue, Struct

oneof kind
The kind of value.
- NullValue null_value = 1
  Represents a null value.
- double number_value = 2
  Represents a double value.
- string string_value = 3
  Represents a string value.
- bool bool_value = 4
  Represents a boolean value.
- Struct struct_value = 5
  Represents a structured value.
- ListValue list_value = 6
  Represents a repeated `Value`.

package google.protobuf

message BoolValue

bool value = 1

message BytesValue

bytes value = 1

message DoubleValue

double value = 1

message FloatValue

float value = 1

message Int32Value

int32 value = 1

message Int64Value

int64 value = 1

message ListValue

repeated Value values = 1

enum NullValue

NULL_VALUE = 0

message StringValue

string value = 1

message Struct

map<string, Value> fields = 1

message Timestamp

int64 seconds = 1

int32 nanos = 2

message UInt32Value

uint32 value = 1

message UInt64Value

uint64 value = 1

message Value

oneof kind

NullValue null_value = 1

double number_value = 2

string string_value = 3

bool bool_value = 4

Struct struct_value = 5

ListValue list_value = 6