package google.api.expr.v1alpha1

Get desktop application:
View/edit binary Protocol Buffers messages

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

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

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.

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

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.

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

Source information collected at parse time.

Used in: 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.

• 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 value. This is similar to `google.protobuf.Value`, but can represent CEL's full range of values.

Used in: 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.