package cel.expr

Get desktop application:
View/edit binary Protocol Buffers messages

A CEL expression which has been successfully type checked.

Used in: conformance.CheckResponse, conformance.EvalRequest, xds.type.v3.CelExpression

• map<int64, Reference> reference_map = 2

  A map from expression ids to resolved references. The following entries are in this table: - An Ident or Select expression is represented here if it resolves to a declaration. For instance, if `a.b.c` is represented by `select(select(id(a), b), c)`, and `a.b` resolves to a declaration, while `c` is a field selection, then the reference is attached to the nested select expression (but not to the id or or the outer select). In turn, if `a` resolves to a declaration and `b.c` are field selections, the reference is attached to the ident expression. - Every Call expression has an entry here, identifying the function being called. - Every CreateStruct expression for a message has an entry, identifying the message.

• map<int64, Type> type_map = 3

  A map from expression ids to types. Every expression node which has a type different than DYN has a mapping here. If an expression has type DYN, it is omitted from this map to save space.

• optional SourceInfo source_info = 5

  The source info derived from input that generated the parsed `expr` and any optimizations made during the type-checking pass.

• string expr_version = 6

  The expr version indicates the major / minor version number of the `expr` representation. The most common reason for a version change will be to indicate to the CEL runtimes that transformations have been performed on the expr during static analysis. In some cases, this will save the runtime the work of applying the same or similar transformations prior to evaluation.

• optional Expr expr = 4

  The checked expression. Semantically equivalent to the parsed `expr`, but may have structural differences.

Represents a primitive literal. Named 'Constant' here for backwards compatibility. This is similar as the primitives supported in the well-known type `google.protobuf.Value`, but richer so it can represent CEL's full range of primitives. Lists and structs are not included as constants as these aggregate types may contain [Expr][cel.expr.Expr] elements which require evaluation and are thus not constant. Examples of constants include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`, `true`, `null`.

Used in: Decl.IdentDecl, Expr, Reference

• oneof constant_kind

  Required. The valid constant kinds.

  • google.protobuf.NullValue null_value = 1

    null value.

  • bool bool_value = 2

    boolean value.

  • int64 int64_value = 3

    int64 value.

  • uint64 uint64_value = 4

    uint64 value.

  • double double_value = 5

    double value.

  • string string_value = 6

    string value.

  • bytes bytes_value = 7

    bytes value.

  • google.protobuf.Duration duration_value = 8

    protobuf.Duration value. Deprecated: duration is no longer considered a builtin cel type.

  • google.protobuf.Timestamp timestamp_value = 9

    protobuf.Timestamp value. Deprecated: timestamp is no longer considered a builtin cel type.

Represents a declaration of a named value or function. A declaration is part of the contract between the expression, the agent evaluating that expression, and the caller requesting evaluation.

Used in: conformance.CheckRequest, conformance.Environment, conformance.LibrarySubset, conformance.test.SimpleTest

• string name = 1

  The fully qualified name of the declaration. Declarations are organized in containers and this represents the full path to the declaration in its container, as in `cel.expr.Decl`. Declarations used as [FunctionDecl.Overload][cel.expr.Decl.FunctionDecl.Overload] parameters may or may not have a name depending on whether the overload is function declaration or a function definition containing a result [Expr][cel.expr.Expr].

• oneof decl_kind

  Required. The declaration kind.

  • Decl.IdentDecl ident = 2

    Identifier declaration.

  • Decl.FunctionDecl function = 3

    Function declaration.

Function declaration specifies one or more overloads which indicate the function's parameter types and return type. Functions have no observable side-effects (there may be side-effects like logging which are not observable from CEL).

Used in: Decl

• repeated FunctionDecl.Overload overloads = 1

  Required. List of function overloads, must contain at least one overload.

• string doc = 2

  Documentation string for the function that indicates the general purpose of the function and its behavior. Documentation strings for the function should be general purpose with specific examples provided in the overload doc string. Examples: The 'in' operator tests whether an item exists in a collection. The 'substring' function returns a substring of a target string.

An overload indicates a function's parameter types and return type, and may optionally include a function body described in terms of [Expr][cel.expr.Expr] values. Functions overloads are declared in either a function or method call-style. For methods, the `params[0]` is the expected type of the target receiver. Overloads must have non-overlapping argument types after erasure of all parameterized type variables (similar as type erasure in Java).

Used in: FunctionDecl

• string overload_id = 1

  Required. Globally unique overload name of the function which reflects the function name and argument types. This will be used by a [Reference][cel.expr.Reference] to indicate the `overload_id` that was resolved for the function `name`.

• repeated Type params = 2

  List of function parameter [Type][cel.expr.Type] values. Param types are disjoint after generic type parameters have been replaced with the type `DYN`. Since the `DYN` type is compatible with any other type, this means that if `A` is a type parameter, the function types `int<A>` and `int<int>` are not disjoint. Likewise, `map<string, string>` is not disjoint from `map<K, V>`. When the `result_type` of a function is a generic type param, the type param name also appears as the `type` of on at least one params.

• repeated string type_params = 3

  The type param names associated with the function declaration. For example, `function ex<K,V>(K key, map<K, V> map) : V` would yield the type params of `K, V`.

• optional Type result_type = 4

  Required. The result type of the function. For example, the operator `string.isEmpty()` would have `result_type` of `kind: BOOL`.

• bool is_instance_function = 5

  Whether the function is to be used in a method call-style `x.f(...)` of a function call-style `f(x, ...)`. For methods, the first parameter declaration, `params[0]` is the expected type of the target receiver.

• string doc = 6

  Documentation string for the overload. Provide examples of the overload behavior, preferring to use literal values as input with a comment on the return value. Examples: // Determine whether a value of type <V> exists within a list<V>. 2 in [1, 2, 3] // returns true // Determine whether a key of type <K> exists within a map<K,V>. 'hello' in {'hi': 'you', 'hello': 'there'} // returns true 'help' in {'hi': 'you', 'hello': 'there'} // returns false // Take the substring of a string starting at a specific character // offset (inclusive). "tacocat".substring(1) // returns "acocat" "tacocat".substring(20) // error // Take the substring of a string starting at a specific character // offset (inclusive) and ending at the given offset (exclusive). "tacocat".substring(1, 6) // returns "acoca"

Identifier declaration which specifies its type and optional `Expr` value. An identifier without a value is a declaration that must be provided at evaluation time. An identifier with a value should resolve to a constant, but may be used in conjunction with other identifiers bound at evaluation time.

Used in: Decl

• optional Type type = 1

  Required. The type of the identifier.

• optional Constant value = 2

  The constant value of the identifier. If not specified, the identifier must be supplied at evaluation time.

• string doc = 3

  Documentation string for the identifier. Provide a brief description of what the variable represents and whether there are any constraints on the formatting or supported value range. Examples: 'request.auth.principal' - string which uniquely identifies an authenticated principal. For JSON Web Tokens (JWTs), the principal is the combination of the issuer ('iss') and subject ('sub') token fields concatenated by a forward slash: iss + `/` + sub. 'min_cpus' - integer value indicates the minimum number of CPUs required for a compute cluster. The 'min_cpus' value must be greater than zero and less than 'max_cpus' or 64 whichever is less.

An enum value.

Used in: Value

• string type = 1

  The fully qualified name of the enum type.

• int32 value = 2

  The value of the enum.

A set of errors. The errors included depend on the context. See `ExprValue.error`.

Used in: ExprValue, conformance.test.ErrorSetMatcher, conformance.test.SimpleTest, conformance.test.TestOutput

• repeated google.rpc.Status errors = 1

The state of an evaluation. Can represent an initial, partial, or completed state of evaluation.

• repeated ExprValue values = 1

  The unique values referenced in this message.

• repeated EvalState.Result results = 3

  An ordered list of results. Tracks the flow of evaluation through the expression. May be sparse.

A single evaluation result.

Used in: EvalState

• int64 expr = 1

  The id of the expression this result if for.

• int64 value = 2

  The index in `values` of the resulting value.

Values of intermediate expressions produced when evaluating expression.

• repeated Value values = 1

  All of the observed values. The field value_index is an index in the values list. Separating values from steps is needed to remove redundant values.

• repeated Explain.ExprStep expr_steps = 2

  List of steps. Repeated evaluations of the same expression generate new ExprStep instances. The order of such ExprStep instances matches the order of elements returned by Comprehension.iter_range.

ID and value index of one step.

Used in: Explain

• int64 id = 1

  ID of corresponding Expr node.

• int32 value_index = 2

  Index of the value in the values list.

An abstract representation of a common expression. Expressions are abstractly represented as a collection of identifiers, select statements, function calls, literals, and comprehensions. All operators with the exception of the '.' operator are modelled as function calls. This makes it easy to represent new operators into the existing AST. All references within expressions must resolve to a [Decl][cel.expr.Decl] provided at type-check for an expression to be valid. A reference may either be a bare identifier `name` or a qualified identifier `google.api.name`. References may either refer to a value or a function declaration. For example, the expression `google.api.name.startsWith('expr')` references the declaration `google.api.name` within a [Expr.Select][cel.expr.Expr.Select] expression, and the function declaration `startsWith`.

Used in: CheckedExpr, Expr.Call, Expr.Comprehension, Expr.CreateList, Expr.CreateStruct.Entry, Expr.Select, ParsedExpr, SourceInfo

• int64 id = 2

  Required. An id assigned to this node by the parser which is unique in a given expression tree. This is used to associate type information and other attributes to a node in the parse tree.

• oneof expr_kind

  Required. Variants of expressions.

  • Constant const_expr = 3

    A constant expression.

  • Expr.Ident ident_expr = 4

    An identifier expression.

  • Expr.Select select_expr = 5

    A field selection expression, e.g. `request.auth`.

  • Expr.Call call_expr = 6

    A call expression, including calls to predefined functions and operators.

  • Expr.CreateList list_expr = 7

    A list creation expression.

  • Expr.CreateStruct struct_expr = 8

    A map or message creation expression.

  • Expr.Comprehension comprehension_expr = 9

    A comprehension expression.

A call expression, including calls to predefined functions and operators. For example, `value == 10`, `size(map_value)`.

Used in: Expr

• optional Expr target = 1

  The target of an method call-style expression. For example, `x` in `x.f()`.

• string function = 2

  Required. The name of the function or method being called.

• repeated Expr args = 3

  The arguments.

A comprehension expression applied to a list or map. Comprehensions are not part of the core syntax, but enabled with macros. A macro matches a specific call signature within a parsed AST and replaces the call with an alternate AST block. Macro expansion happens at parse time. The following macros are supported within CEL: Aggregate type macros may be applied to all elements in a list or all keys in a map: * `all`, `exists`, `exists_one` - test a predicate expression against the inputs and return `true` if the predicate is satisfied for all, any, or only one value `list.all(x, x < 10)`. * `filter` - test a predicate expression against the inputs and return the subset of elements which satisfy the predicate: `payments.filter(p, p > 1000)`. * `map` - apply an expression to all elements in the input and return the output aggregate type: `[1, 2, 3].map(i, i * i)`. The `has(m.x)` macro tests whether the property `x` is present in struct `m`. The semantics of this macro depend on the type of `m`. For proto2 messages `has(m.x)` is defined as 'defined, but not set`. For proto3, the macro tests whether the property is set to its default. For map and struct types, the macro tests whether the property `x` is defined on `m`. Comprehensions for the standard environment macros evaluation can be best visualized as the following pseudocode: ``` let `accu_var` = `accu_init` for (let `iter_var` in `iter_range`) { if (!`loop_condition`) { break } `accu_var` = `loop_step` } return `result` ``` Comprehensions for the optional V2 macros which support map-to-map translation differ slightly from the standard environment macros in that they expose both the key or index in addition to the value for each list or map entry: ``` let `accu_var` = `accu_init` for (let `iter_var`, `iter_var2` in `iter_range`) { if (!`loop_condition`) { break } `accu_var` = `loop_step` } return `result` ```

Used in: Expr

• string iter_var = 1

  The name of the first iteration variable. For the single iteration variable macros, when iter_range is a list, this variable is the list element and when the iter_range is a map, this variable is the map key.

• string iter_var2 = 8

  The name of the second iteration variable, empty if not set. This field is only set for comprehension v2 macros.

• optional Expr iter_range = 2

  The range over which the comprehension iterates.

• string accu_var = 3

  The name of the variable used for accumulation of the result.

• optional Expr accu_init = 4

  The initial value of the accumulator.

• optional Expr loop_condition = 5

  An expression which can contain iter_var, iter_var2, and accu_var. Returns false when the result has been computed and may be used as a hint to short-circuit the remainder of the comprehension.

• optional Expr loop_step = 6

  An expression which can contain iter_var, iter_var2, and accu_var. Computes the next value of accu_var.

• optional Expr result = 7

  An expression which can contain accu_var. Computes the result.

A list creation expression. Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g. `dyn([1, 'hello', 2.0])`

Used in: Expr

• repeated Expr elements = 1

  The elements part of the list.

• repeated int32 optional_indices = 2

  The indices within the elements list which are marked as optional elements. When an optional-typed value is present, the value it contains is included in the list. If the optional-typed value is absent, the list element is omitted from the CreateList result.

A map or message creation expression. Maps are constructed as `{'key_name': 'value'}`. Message construction is similar, but prefixed with a type name and composed of field ids: `types.MyType{field_id: 'value'}`.

Used in: Expr

• string message_name = 1

  The type name of the message to be created, empty when creating map literals.

• repeated CreateStruct.Entry entries = 2

  The entries in the creation expression.

Represents an entry.

Used in: CreateStruct

• int64 id = 1

  Required. An id assigned to this node by the parser which is unique in a given expression tree. This is used to associate type information and other attributes to the node.

• oneof key_kind

  The `Entry` key kinds.

  • string field_key = 2

    The field key for a message creator statement.

  • Expr map_key = 3

    The key expression for a map creation statement.

• optional Expr value = 4

  Required. The value assigned to the key. If the optional_entry field is true, the expression must resolve to an optional-typed value. If the optional value is present, the key will be set; however, if the optional value is absent, the key will be unset.

• bool optional_entry = 5

  Whether the key-value pair is optional.

An identifier expression. e.g. `request`.

Used in: Expr

• string name = 1

  Required. Holds a single, unqualified identifier, possibly preceded by a '.'. Qualified names are represented by the [Expr.Select][cel.expr.Expr.Select] expression.

A field selection expression. e.g. `request.auth`.

Used in: Expr

• optional Expr operand = 1

  Required. The target of the selection expression. For example, in the select expression `request.auth`, the `request` portion of the expression is the `operand`.

• string field = 2

  Required. The name of the field to select. For example, in the select expression `request.auth`, the `auth` portion of the expression would be the `field`.

• bool test_only = 3

  Whether the select is to be interpreted as a field presence test. This results from the macro `has(request.auth)`.

The value of an evaluated expression.

Used in: EvalState, conformance.EvalRequest, conformance.EvalResponse, conformance.test.SimpleTest

• oneof kind

  An expression can resolve to a value, error or unknown.

  • Value value = 1

  • ErrorSet error = 2

    The set of errors in the critical path of evaluation. Only errors in the critical path are included. For example, `(<error1> || true) && <error2>` will only result in `<error2>`, while `<error1> || <error2>` will result in both `<error1>` and `<error2>`. Errors cause by the presence of other errors are not included in the set. For example `<error1>.foo`, `foo(<error1>)`, and `<error1> + 1` will only result in `<error1>`. Multiple errors *might* be included when evaluation could result in different errors. For example `<error1> + <error2>` and `foo(<error1>, <error2>)` may result in `<error1>`, `<error2>` or both. The exact subset of errors included for this case is unspecified and depends on the implementation details of the evaluator.

  • UnknownSet unknown = 3

    The set of unknowns in the critical path of evaluation. Unknown behaves identically to Error with regards to propagation. Specifically, only unknowns in the critical path are included, unknowns caused by the presence of other unknowns are not included, and multiple unknowns *might* be included when evaluation could result in different unknowns. For example: (<unknown[1]> || true) && <unknown[2]> -> <unknown[2]> <unknown[1]> || <unknown[2]> -> <unknown[1,2]> <unknown[1]>.foo -> <unknown[1]> foo(<unknown[1]>) -> <unknown[1]> <unknown[1]> + <unknown[2]> -> <unknown[1]> or <unknown[2[> Unknown takes precedence over Error in cases where a `Value` can short circuit the result: <error> || <unknown> -> <unknown> <error> && <unknown> -> <unknown> Errors take precedence in all other cases: <unknown> + <error> -> <error> foo(<unknown>, <error>) -> <error>

A list. Wrapped in a message so 'not set' and empty can be differentiated, which is required for use in a 'oneof'.

Used in: Value

• repeated Value values = 1

  The ordered values in the list.

A map. Wrapped in a message so 'not set' and empty can be differentiated, which is required for use in a 'oneof'.

Used in: Value

• repeated MapValue.Entry entries = 1

  The set of map entries. CEL has fewer restrictions on keys, so a protobuf map representation cannot be used.

Used in: MapValue

• optional Value key = 1

  The key. Must be unique with in the map. Currently only boolean, int, uint, and string values can be keys.

• optional Value value = 2

  The value.

An expression together with source information as returned by the parser.

Used in: conformance.CheckRequest, conformance.EvalRequest, conformance.ParseResponse, xds.type.v3.CelExpression

• optional Expr expr = 2

  The parsed expression.

• optional SourceInfo source_info = 3

  The source info derived from input that generated the parsed `expr`.

Describes a resolved reference to a declaration.

Used in: CheckedExpr

• string name = 1

  The fully qualified name of the declaration.

• repeated string overload_id = 3

  For references to functions, this is a list of `Overload.overload_id` values which match according to typing rules. If the list has more than one element, overload resolution among the presented candidates must happen at runtime because of dynamic types. The type checker attempts to narrow down this list as much as possible. Empty if this is not a reference to a [Decl.FunctionDecl][cel.expr.Decl.FunctionDecl].

• optional Constant value = 4

  For references to constants, this may contain the value of the constant if known at compile time.

Source information collected at parse time.

Used in: CheckedExpr, ParsedExpr

• string syntax_version = 1

  The syntax version of the source, e.g. `cel1`.

• string location = 2

  The location name. All position information attached to an expression is relative to this location. The location could be a file, UI element, or similar. For example, `acme/app/AnvilPolicy.cel`.

• repeated int32 line_offsets = 3

  Monotonically increasing list of code point offsets where newlines `\n` appear. The line number of a given position is the index `i` where for a given `id` the `line_offsets[i] < id_positions[id] < line_offsets[i+1]`. The column may be derived from `id_positions[id] - line_offsets[i]`.

• map<int64, int32> positions = 4

  A map from the parse node id (e.g. `Expr.id`) to the code point offset within the source.

• map<int64, Expr> macro_calls = 5

  A map from the parse node id where a macro replacement was made to the call `Expr` that resulted in a macro expansion. For example, `has(value.field)` is a function call that is replaced by a `test_only` field selection in the AST. Likewise, the call `list.exists(e, e > 10)` translates to a comprehension expression. The key in the map corresponds to the expression id of the expanded macro, and the value is the call `Expr` that was replaced.

• repeated SourceInfo.Extension extensions = 6

  A list of tags for extensions that were used while parsing or type checking the source expression. For example, optimizations that require special runtime support may be specified. These are used to check feature support between components in separate implementations. This can be used to either skip redundant work or report an error if the extension is unsupported.

An extension that was requested for the source expression.

Used in: SourceInfo

• string id = 1

  Identifier for the extension. Example: constant_folding

• repeated Extension.Component affected_components = 2

  If set, the listed components must understand the extension for the expression to evaluate correctly. This field has set semantics, repeated values should be deduplicated.

• optional Extension.Version version = 3

  Version info. May be skipped if it isn't meaningful for the extension. (for example constant_folding might always be v0.0).

CEL component specifier.

Used in: Extension

• COMPONENT_UNSPECIFIED = 0

  Unspecified, default.

• COMPONENT_PARSER = 1

  Parser. Converts a CEL string to an AST.

• COMPONENT_TYPE_CHECKER = 2

  Type checker. Checks that references in an AST are defined and types agree.

• COMPONENT_RUNTIME = 3

  Runtime. Evaluates a parsed and optionally checked CEL AST against a context.

Version

Used in: Extension

• int64 major = 1

  Major version changes indicate different required support level from the required components.

• int64 minor = 2

  Minor version changes must not change the observed behavior from existing implementations, but may be provided informationally.

Represents a CEL type.

Used in: CheckedExpr, Decl.FunctionDecl.Overload, Decl.IdentDecl, Type.AbstractType, Type.FunctionType, Type.ListType, Type.MapType, conformance.test.TestCase, conformance.test.TypedResult

• oneof type_kind

  The kind of type.

  • google.protobuf.Empty dyn = 1

    Dynamic type.

  • google.protobuf.NullValue null = 2

    Null value.

  • Type.PrimitiveType primitive = 3

    Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.

  • Type.PrimitiveType wrapper = 4

    Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.

  • Type.WellKnownType well_known = 5

    Well-known protobuf type such as `google.protobuf.Timestamp`.

  • Type.ListType list_type = 6

    Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.

  • Type.MapType map_type = 7

    Parameterized map with typed keys and values.

  • Type.FunctionType function = 8

    Function type.

  • string message_type = 9

    Protocol buffer message type. The `message_type` string specifies the qualified message type name. For example, `google.type.PhoneNumber`.

  • string type_param = 10

    Type param type. The `type_param` string specifies the type parameter name, e.g. `list<E>` would be a `list_type` whose element type was a `type_param` type named `E`.

  • Type type = 11

    Type type. The `type` value specifies the target type. e.g. int is type with a target type of `Primitive.INT64`.

  • google.protobuf.Empty error = 12

    Error type. During type-checking if an expression is an error, its type is propagated as the `ERROR` type. This permits the type-checker to discover other errors present in the expression.

  • Type.AbstractType abstract_type = 14

    Abstract, application defined type. An abstract type has no accessible field names, and it can only be inspected via helper / member functions.

Application defined abstract type.

Used in: Type

• string name = 1

  The fully qualified name of this abstract type.

• repeated Type parameter_types = 2

  Parameter types for this abstract type.

Function type with result and arg types.

Used in: Type

• optional Type result_type = 1

  Result type of the function.

• repeated Type arg_types = 2

  Argument types of the function.

List type with typed elements, e.g. `list<example.proto.MyMessage>`.

Used in: Type

• optional Type elem_type = 1

  The element type.

Map type with parameterized key and value types, e.g. `map<string, int>`.

Used in: Type

• optional Type key_type = 1

  The type of the key.

• optional Type value_type = 2

  The type of the value.

CEL primitive types.

Used in: Type

• PRIMITIVE_TYPE_UNSPECIFIED = 0

  Unspecified type.

• BOOL = 1

  Boolean type.

• INT64 = 2

  Int64 type. 32-bit integer values are widened to int64.

• UINT64 = 3

  Uint64 type. 32-bit unsigned integer values are widened to uint64.

• DOUBLE = 4

  Double type. 32-bit float values are widened to double values.

• STRING = 5

  String type.

• BYTES = 6

  Bytes type.

Well-known protobuf types treated with first-class support in CEL.

Used in: Type

• WELL_KNOWN_TYPE_UNSPECIFIED = 0

  Unspecified type.

• ANY = 1

  Well-known protobuf.Any type. Any types are a polymorphic message type. During type-checking they are treated like `DYN` types, but at runtime they are resolved to a specific message type specified at evaluation time.

• TIMESTAMP = 2

  Well-known protobuf.Timestamp type, internally referenced as `timestamp`.

• DURATION = 3

  Well-known protobuf.Duration type, internally referenced as `duration`.

A set of expressions for which the value is unknown. The unknowns included depend on the context. See `ExprValue.unknown`.

Used in: ExprValue, conformance.test.SimpleTest, conformance.test.TestOutput, conformance.test.UnknownSetMatcher

• repeated int64 exprs = 1

  The ids of the expressions with unknown values.

Represents a CEL value. This is similar to `google.protobuf.Value`, but can represent CEL's full range of values.

Used in: Explain, ExprValue, ListValue, MapValue.Entry, conformance.test.InputValue, conformance.test.SimpleTest, conformance.test.TestOutput, conformance.test.TypedResult

• oneof kind

  Required. The valid kinds of values.

  • google.protobuf.NullValue null_value = 1

    Null value.

  • bool bool_value = 2

    Boolean value.

  • int64 int64_value = 3

    Signed integer value.

  • uint64 uint64_value = 4

    Unsigned integer value.

  • double double_value = 5

    Floating point value.

  • string string_value = 6

    UTF-8 string value.

  • bytes bytes_value = 7

    Byte string value.

  • EnumValue enum_value = 9

    An enum value.

  • google.protobuf.Any object_value = 10

    The proto message backing an object value.

  • MapValue map_value = 11

    Map value.

  • ListValue list_value = 12

    List value.

  • string type_value = 15

    Type value.