package google.api.expr.v1alpha1

Get desktop application:
View/edit binary Protocol Buffers messages

Access a CEL implementation from another process or machine. A CEL implementation is decomposed as a parser, a static checker, and an evaluator. Every CEL implementation is expected to provide a server for this API. The API will be used for conformance testing, utilities, and execution as a service.

• rpc Parse (ParseRequest, ParseResponse)

  cel_service.proto:35

  Transforms CEL source text into a parsed representation.

• rpc Check (CheckRequest, CheckResponse)

  cel_service.proto:39

  Runs static checks on a parsed CEL representation and return an annotated representation, or a set of issues.

• rpc Eval (EvalRequest, EvalResponse)

  cel_service.proto:43

  Evaluates a parsed or annotation CEL representation given values of external bindings.

Access a CEL implementation from another process or machine. A CEL implementation is decomposed as a parser, a static checker, and an evaluator. Every CEL implementation is expected to provide a server for this API. The API will be used for conformance testing and other utilities.

• rpc Parse (ParseRequest, ParseResponse)

  conformance_service.proto:42

  Transforms CEL source text into a parsed representation.

• rpc Check (CheckRequest, CheckResponse)

  conformance_service.proto:48

  Runs static checks on a parsed CEL representation and return an annotated representation, or a set of issues.

• rpc Eval (EvalRequest, EvalResponse)

  conformance_service.proto:54

  Evaluates a parsed or annotation CEL representation given values of external bindings.

Request message for the Check method.

Used as request type in: CelService.Check, ConformanceService.Check

• optional ParsedExpr parsed_expr = 1

  Required. The parsed representation of the CEL program.

• repeated Decl type_env = 2

  Declarations of types for external variables and functions. Required if program uses external variables or functions not in the default environment.

• string container = 3

  The protocol buffer context. See "Name Resolution" in the Language Definition.

• bool no_std_env = 4

  If true, use only the declarations in [type_env][google.api.expr.v1alpha1.CheckRequest.type_env]. If false (default), add declarations for the standard definitions to the type environment. See "Standard Definitions" in the Language Definition.

Response message for the Check method.

Used as response type in: CelService.Check, ConformanceService.Check

• optional CheckedExpr checked_expr = 1

  The annotated representation, or unset if checking failed.

• repeated rpc.Status issues = 2

  Any number of issues with [StatusDetails][] as the details.

A CEL expression which has been successfully type checked.

Used in: CheckResponse, EvalRequest

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

• 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][google.api.expr.v1alpha1.Expr] elements which require evaluation and are thus not constant. Examples of literals include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`, `true`, `null`.

Used in: Decl.IdentDecl, Expr, Reference

• oneof constant_kind

  Required. The valid constant kinds.

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

  • protobuf.Duration duration_value = 8

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

  • 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: CheckRequest

• 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 `google.api.expr.Decl`. Declarations used as [FunctionDecl.Overload][google.api.expr.v1alpha1.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][google.api.expr.v1alpha1.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, and may optionally specify a function definition in terms of CEL expressions. 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.

An overload indicates a function's parameter types and return type, and may optionally include a function body described in terms of [Expr][google.api.expr.v1alpha1.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][google.api.expr.v1alpha1.Reference] to indicate the `overload_id` that was resolved for the function `name`.

• repeated Type params = 2

  List of function parameter [Type][google.api.expr.v1alpha1.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.

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.

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

• repeated rpc.Status errors = 1

  The errors in the set.

Request message for the Eval method.

Used as request type in: CelService.Eval, ConformanceService.Eval

• oneof expr_kind

  Required. Either the parsed or annotated representation of the CEL program.

  • ParsedExpr parsed_expr = 1

    Evaluate based on the parsed representation.

  • CheckedExpr checked_expr = 2

    Evaluate based on the checked representation.

• map<string, ExprValue> bindings = 3

  Bindings for the external variables. The types SHOULD be compatible with the type environment in [CheckRequest][google.api.expr.v1alpha1.CheckRequest], if checked.

• string container = 4

  SHOULD be the same container as used in [CheckRequest][google.api.expr.v1alpha1.CheckRequest], if checked.

Response message for the Eval method.

Used as response type in: CelService.Eval, ConformanceService.Eval

• optional ExprValue result = 1

  The execution result, or unset if execution couldn't start.

• repeated rpc.Status issues = 2

  Any number of issues with [StatusDetails][] as the details. Note that CEL execution errors are reified into [ExprValue][google.api.expr.v1alpha1.ExprValue]. Nevertheless, we'll allow out-of-band issues to be raised, which also makes the replies more regular.

The state of an evaluation. Can represent an inital, 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 evalution 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. Deprecated, use `EvalState` instead.

• 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][google.api.expr.v1alpha1.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][google.api.expr.v1alpha1.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 literal 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`.

Used in: Expr

• string iter_var = 1

  The name of the iteration variable.

• optional Expr iter_range = 2

  The range over which var 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 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 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 heterogenous, e.g. `dyn([1, 'hello', 2.0])`

Used in: Expr

• repeated Expr elements = 1

  The elements part of the list.

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.

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][google.api.expr.v1alpha1.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: EvalRequest, EvalResponse, EvalState

• oneof kind

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

  • Value value = 1

    A concrete value.

  • ErrorSet error = 2

    The set of errors in the critical path of evalution. 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 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 precidence over Error in cases where a `Value` can short circuit the result: <error> || <unknown> -> <unknown> <error> && <unknown> -> <unknown> Errors take precidence in all other cases: <unknown> + <error> -> <error> foo(<unknown>, <error>) -> <error>

Warnings or errors in service execution are represented by [google.rpc.Status][google.rpc.Status] messages, with the following message in the details field.

• IssueDetails.Severity severity = 1

  The severity of the issue.

• optional SourcePosition position = 2

  Position in the source, if known.

• int64 id = 3

  Expression ID from [Expr][google.api.expr.v1alpha1.Expr], 0 if unknown.

Severities of issues.

Used in: IssueDetails

• SEVERITY_UNSPECIFIED = 0

  An unspecified severity.

• DEPRECATION = 1

  Deprecation issue for statements and method that may no longer be supported or maintained.

• WARNING = 2

  Warnings such as: unused variables.

• ERROR = 3

  Errors such as: unmatched curly braces or variable redefinition.

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 represenation cannot be used.

An entry in the map.

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.

Request message for the Parse method.

Used as request type in: CelService.Parse, ConformanceService.Parse

• string cel_source = 1

  Required. Source text in CEL syntax.

• string syntax_version = 2

  Tag for version of CEL syntax, for future use.

• string source_location = 3

  File or resource for source text, used in [SourceInfo][google.api.expr.v1alpha1.SourceInfo].

• bool disable_macros = 4

  Prevent macro expansion. See "Macros" in Language Defiinition.

Response message for the Parse method.

Used as response type in: CelService.Parse, ConformanceService.Parse

• optional ParsedExpr parsed_expr = 1

  The parsed representation, or unset if parsing failed.

• repeated rpc.Status issues = 2

  Any number of issues with [StatusDetails][] as the details.

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

Used in: CheckRequest, EvalRequest, ParseResponse

• 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][google.api.expr.v1alpha1.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 character offsets where newlines 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 derivd 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 character offset within 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.

A specific position in source.

Used in: IssueDetails

• string location = 1

  The soucre location name (e.g. file name).

• int32 offset = 2

  The character offset.

• int32 line = 3

  The 1-based index of the starting line in the source text where the issue occurs, or 0 if unknown.

• int32 column = 4

  The 0-based index of the starting position within the line of source text where the issue occurs. Only meaningful if line is nonzero.

Represents a CEL type.

Used in: CheckedExpr, Decl.FunctionDecl.Overload, Decl.IdentDecl, Type.AbstractType, Type.FunctionType, Type.ListType, Type.MapType

• oneof type_kind

  The kind of type.

  • protobuf.Empty dyn = 1

    Dynamic type.

  • 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.plus.Profile`.

  • 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.INT`.

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

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. Proto-based integer values are widened to int64.

• UINT64 = 3

  Uint64 type. Proto-based unsigned integer values are widened to uint64.

• DOUBLE = 4

  Double type. Proto-based 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

• 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

• oneof kind

  Required. The valid kinds of values.

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

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