package google.api.expr.v1beta1

Get desktop application:
View/edit binary Protocol Buffers messages

A declaration.

• int32 id = 1

  The id of the declaration.

• string name = 2

  The name of the declaration.

• string doc = 3

  The documentation string for the declaration.

• oneof kind

  The kind of declaration.

  • IdentDecl ident = 4

    An identifier declaration.

  • FunctionDecl function = 5

    A function declaration.

The declared type of a variable. Extends runtime type values with extra information used for type checking and dispatching.

Used in: FunctionDecl, IdentDecl

• int32 id = 1

  The expression id of the declared type, if applicable.

• string type = 2

  The type name, e.g. 'int', 'my.type.Type' or 'T'

• repeated DeclType type_params = 4

  An ordered list of type parameters, e.g. `<string, int>`. Only applies to a subset of types, e.g. `map`, `list`.

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.

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

• optional IdRef expr = 1

  The expression this result is for.

• int32 value = 2

  The index in `values` of the resulting value.

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.v1beta1.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.v1beta1.Expr.Select] expression, and the function declaration `startsWith`.

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

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

  • Literal literal_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 object 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 type = 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

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

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

A function declaration.

Used in: Decl

• repeated IdentDecl args = 1

  The function arguments.

• optional DeclType return_type = 2

  Optional declared return type.

• bool receiver_function = 3

  If the first argument of the function is the receiver.

A reference to an expression id.

Used in: EvalState.Result, UnknownSet

• int32 id = 1

  The expression id.

An identifier declaration.

Used in: Decl, FunctionDecl

• optional DeclType type = 3

  Optional type of the identifier.

• optional Expr value = 4

  Optional value of the identifier.

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.

Represents a primitive literal. This is similar to 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.v1beta1.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: Expr

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

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.

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

• optional Expr expr = 2

  The parsed expression.

• optional SourceInfo source_info = 3

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

• string syntax_version = 4

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

Source information collected at parse time.

Used in: ParsedExpr

• 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<int32, int32> positions = 4

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

A specific position in source.

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

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

Used in: ExprValue

• repeated IdRef 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: 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

    A Type value represented by the fully qualified name of the type.