@0xkaleab/sdk-js 0.2.7

package/dist/types/codegen/google/api/expr/v1alpha1/syntax.d.ts

@@ -0,0 +1,1642 @@
+import { NullValue } from "../../../protobuf/struct";
+import { Duration, DurationAmino } from "../../../protobuf/duration";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** CEL component specifier. */
+export declare enum SourceInfo_Extension_Component {
+    /** COMPONENT_UNSPECIFIED - Unspecified, default. */
+    COMPONENT_UNSPECIFIED = 0,
+    /** COMPONENT_PARSER - Parser. Converts a CEL string to an AST. */
+    COMPONENT_PARSER = 1,
+    /**
+     * COMPONENT_TYPE_CHECKER - Type checker. Checks that references in an AST are defined and types
+     * agree.
+     */
+    COMPONENT_TYPE_CHECKER = 2,
+    /**
+     * COMPONENT_RUNTIME - Runtime. Evaluates a parsed and optionally checked CEL AST against a
+     * context.
+     */
+    COMPONENT_RUNTIME = 3,
+    UNRECOGNIZED = -1
+}
+export declare const SourceInfo_Extension_ComponentAmino: typeof SourceInfo_Extension_Component;
+export declare function sourceInfo_Extension_ComponentFromJSON(object: any): SourceInfo_Extension_Component;
+export declare function sourceInfo_Extension_ComponentToJSON(object: SourceInfo_Extension_Component): string;
+/**
+ * An expression together with source information as returned by the parser.
+ * @name ParsedExpr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ParsedExpr
+ */
+export interface ParsedExpr {
+    /**
+     * The parsed expression.
+     */
+    expr?: Expr;
+    /**
+     * The source info derived from input that generated the parsed `expr`.
+     */
+    sourceInfo?: SourceInfo;
+}
+export interface ParsedExprProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.ParsedExpr";
+    value: Uint8Array;
+}
+/**
+ * An expression together with source information as returned by the parser.
+ * @name ParsedExprAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ParsedExpr
+ */
+export interface ParsedExprAmino {
+    /**
+     * The parsed expression.
+     */
+    expr?: ExprAmino;
+    /**
+     * The source info derived from input that generated the parsed `expr`.
+     */
+    source_info?: SourceInfoAmino;
+}
+export interface ParsedExprAminoMsg {
+    type: "/google.api.expr.v1alpha1.ParsedExpr";
+    value: ParsedExprAmino;
+}
+/**
+ * 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`.
+ * @name Expr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr
+ */
+export interface Expr {
+    /**
+     * 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.
+     */
+    id: bigint;
+    /**
+     * A literal expression.
+     */
+    constExpr?: Constant;
+    /**
+     * An identifier expression.
+     */
+    identExpr?: Expr_Ident;
+    /**
+     * A field selection expression, e.g. `request.auth`.
+     */
+    selectExpr?: Expr_Select;
+    /**
+     * A call expression, including calls to predefined functions and operators.
+     */
+    callExpr?: Expr_Call;
+    /**
+     * A list creation expression.
+     */
+    listExpr?: Expr_CreateList;
+    /**
+     * A map or message creation expression.
+     */
+    structExpr?: Expr_CreateStruct;
+    /**
+     * A comprehension expression.
+     */
+    comprehensionExpr?: Expr_Comprehension;
+}
+export interface ExprProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Expr";
+    value: Uint8Array;
+}
+/**
+ * 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`.
+ * @name ExprAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr
+ */
+export interface ExprAmino {
+    /**
+     * 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.
+     */
+    id: string;
+    /**
+     * A literal expression.
+     */
+    const_expr?: ConstantAmino;
+    /**
+     * An identifier expression.
+     */
+    ident_expr?: Expr_IdentAmino;
+    /**
+     * A field selection expression, e.g. `request.auth`.
+     */
+    select_expr?: Expr_SelectAmino;
+    /**
+     * A call expression, including calls to predefined functions and operators.
+     */
+    call_expr?: Expr_CallAmino;
+    /**
+     * A list creation expression.
+     */
+    list_expr?: Expr_CreateListAmino;
+    /**
+     * A map or message creation expression.
+     */
+    struct_expr?: Expr_CreateStructAmino;
+    /**
+     * A comprehension expression.
+     */
+    comprehension_expr?: Expr_ComprehensionAmino;
+}
+export interface ExprAminoMsg {
+    type: "/google.api.expr.v1alpha1.Expr";
+    value: ExprAmino;
+}
+/**
+ * An identifier expression. e.g. `request`.
+ * @name Expr_Ident
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Ident
+ */
+export interface Expr_Ident {
+    /**
+     * 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.
+     */
+    name: string;
+}
+export interface Expr_IdentProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Ident";
+    value: Uint8Array;
+}
+/**
+ * An identifier expression. e.g. `request`.
+ * @name Expr_IdentAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr_Ident
+ */
+export interface Expr_IdentAmino {
+    /**
+     * 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.
+     */
+    name: string;
+}
+export interface Expr_IdentAminoMsg {
+    type: "/google.api.expr.v1alpha1.Ident";
+    value: Expr_IdentAmino;
+}
+/**
+ * A field selection expression. e.g. `request.auth`.
+ * @name Expr_Select
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Select
+ */
+export interface Expr_Select {
+    /**
+     * Required. The target of the selection expression.
+     *
+     * For example, in the select expression `request.auth`, the `request`
+     * portion of the expression is the `operand`.
+     */
+    operand?: Expr;
+    /**
+     * 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`.
+     */
+    field: string;
+    /**
+     * Whether the select is to be interpreted as a field presence test.
+     *
+     * This results from the macro `has(request.auth)`.
+     */
+    testOnly: boolean;
+}
+export interface Expr_SelectProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Select";
+    value: Uint8Array;
+}
+/**
+ * A field selection expression. e.g. `request.auth`.
+ * @name Expr_SelectAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr_Select
+ */
+export interface Expr_SelectAmino {
+    /**
+     * Required. The target of the selection expression.
+     *
+     * For example, in the select expression `request.auth`, the `request`
+     * portion of the expression is the `operand`.
+     */
+    operand?: ExprAmino;
+    /**
+     * 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`.
+     */
+    field: string;
+    /**
+     * Whether the select is to be interpreted as a field presence test.
+     *
+     * This results from the macro `has(request.auth)`.
+     */
+    test_only: boolean;
+}
+export interface Expr_SelectAminoMsg {
+    type: "/google.api.expr.v1alpha1.Select";
+    value: Expr_SelectAmino;
+}
+/**
+ * A call expression, including calls to predefined functions and operators.
+ *
+ * For example, `value == 10`, `size(map_value)`.
+ * @name Expr_Call
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Call
+ */
+export interface Expr_Call {
+    /**
+     * The target of an method call-style expression. For example, `x` in
+     * `x.f()`.
+     */
+    target?: Expr;
+    /**
+     * Required. The name of the function or method being called.
+     */
+    function: string;
+    /**
+     * The arguments.
+     */
+    args: Expr[];
+}
+export interface Expr_CallProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Call";
+    value: Uint8Array;
+}
+/**
+ * A call expression, including calls to predefined functions and operators.
+ *
+ * For example, `value == 10`, `size(map_value)`.
+ * @name Expr_CallAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr_Call
+ */
+export interface Expr_CallAmino {
+    /**
+     * The target of an method call-style expression. For example, `x` in
+     * `x.f()`.
+     */
+    target?: ExprAmino;
+    /**
+     * Required. The name of the function or method being called.
+     */
+    function: string;
+    /**
+     * The arguments.
+     */
+    args: ExprAmino[];
+}
+export interface Expr_CallAminoMsg {
+    type: "/google.api.expr.v1alpha1.Call";
+    value: Expr_CallAmino;
+}
+/**
+ * A list creation expression.
+ *
+ * Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g.
+ * `dyn([1, 'hello', 2.0])`
+ * @name Expr_CreateList
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CreateList
+ */
+export interface Expr_CreateList {
+    /**
+     * The elements part of the list.
+     */
+    elements: Expr[];
+    /**
+     * 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.
+     */
+    optionalIndices: number[];
+}
+export interface Expr_CreateListProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.CreateList";
+    value: Uint8Array;
+}
+/**
+ * A list creation expression.
+ *
+ * Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g.
+ * `dyn([1, 'hello', 2.0])`
+ * @name Expr_CreateListAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr_CreateList
+ */
+export interface Expr_CreateListAmino {
+    /**
+     * The elements part of the list.
+     */
+    elements: ExprAmino[];
+    /**
+     * 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.
+     */
+    optional_indices: number[];
+}
+export interface Expr_CreateListAminoMsg {
+    type: "/google.api.expr.v1alpha1.CreateList";
+    value: Expr_CreateListAmino;
+}
+/**
+ * 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'}`.
+ * @name Expr_CreateStruct
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CreateStruct
+ */
+export interface Expr_CreateStruct {
+    /**
+     * The type name of the message to be created, empty when creating map
+     * literals.
+     */
+    messageName: string;
+    /**
+     * The entries in the creation expression.
+     */
+    entries: Expr_CreateStruct_Entry[];
+}
+export interface Expr_CreateStructProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.CreateStruct";
+    value: Uint8Array;
+}
+/**
+ * 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'}`.
+ * @name Expr_CreateStructAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr_CreateStruct
+ */
+export interface Expr_CreateStructAmino {
+    /**
+     * The type name of the message to be created, empty when creating map
+     * literals.
+     */
+    message_name: string;
+    /**
+     * The entries in the creation expression.
+     */
+    entries: Expr_CreateStruct_EntryAmino[];
+}
+export interface Expr_CreateStructAminoMsg {
+    type: "/google.api.expr.v1alpha1.CreateStruct";
+    value: Expr_CreateStructAmino;
+}
+/**
+ * Represents an entry.
+ * @name Expr_CreateStruct_Entry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Entry
+ */
+export interface Expr_CreateStruct_Entry {
+    /**
+     * 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.
+     */
+    id: bigint;
+    /**
+     * The field key for a message creator statement.
+     */
+    fieldKey?: string;
+    /**
+     * The key expression for a map creation statement.
+     */
+    mapKey?: Expr;
+    /**
+     * 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.
+     */
+    value?: Expr;
+    /**
+     * Whether the key-value pair is optional.
+     */
+    optionalEntry: boolean;
+}
+export interface Expr_CreateStruct_EntryProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Entry";
+    value: Uint8Array;
+}
+/**
+ * Represents an entry.
+ * @name Expr_CreateStruct_EntryAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr_CreateStruct_Entry
+ */
+export interface Expr_CreateStruct_EntryAmino {
+    /**
+     * 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.
+     */
+    id: string;
+    /**
+     * The field key for a message creator statement.
+     */
+    field_key?: string;
+    /**
+     * The key expression for a map creation statement.
+     */
+    map_key?: ExprAmino;
+    /**
+     * 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.
+     */
+    value?: ExprAmino;
+    /**
+     * Whether the key-value pair is optional.
+     */
+    optional_entry: boolean;
+}
+export interface Expr_CreateStruct_EntryAminoMsg {
+    type: "/google.api.expr.v1alpha1.Entry";
+    value: Expr_CreateStruct_EntryAmino;
+}
+/**
+ * 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`
+ * ```
+ * @name Expr_Comprehension
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Comprehension
+ */
+export interface Expr_Comprehension {
+    /**
+     * The name of the first iteration variable.
+     * When the iter_range is a list, this variable is the list element.
+     * When the iter_range is a map, this variable is the map entry key.
+     */
+    iterVar: string;
+    /**
+     * The name of the second iteration variable, empty if not set.
+     * When the iter_range is a list, this variable is the integer index.
+     * When the iter_range is a map, this variable is the map entry value.
+     * This field is only set for comprehension v2 macros.
+     */
+    iterVar2: string;
+    /**
+     * The range over which the comprehension iterates.
+     */
+    iterRange?: Expr;
+    /**
+     * The name of the variable used for accumulation of the result.
+     */
+    accuVar: string;
+    /**
+     * The initial value of the accumulator.
+     */
+    accuInit?: Expr;
+    /**
+     * 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.
+     */
+    loopCondition?: Expr;
+    /**
+     * An expression which can contain iter_var, iter_var2, and accu_var.
+     *
+     * Computes the next value of accu_var.
+     */
+    loopStep?: Expr;
+    /**
+     * An expression which can contain accu_var.
+     *
+     * Computes the result.
+     */
+    result?: Expr;
+}
+export interface Expr_ComprehensionProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Comprehension";
+    value: Uint8Array;
+}
+/**
+ * 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`
+ * ```
+ * @name Expr_ComprehensionAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr_Comprehension
+ */
+export interface Expr_ComprehensionAmino {
+    /**
+     * The name of the first iteration variable.
+     * When the iter_range is a list, this variable is the list element.
+     * When the iter_range is a map, this variable is the map entry key.
+     */
+    iter_var: string;
+    /**
+     * The name of the second iteration variable, empty if not set.
+     * When the iter_range is a list, this variable is the integer index.
+     * When the iter_range is a map, this variable is the map entry value.
+     * This field is only set for comprehension v2 macros.
+     */
+    iter_var2: string;
+    /**
+     * The range over which the comprehension iterates.
+     */
+    iter_range?: ExprAmino;
+    /**
+     * The name of the variable used for accumulation of the result.
+     */
+    accu_var: string;
+    /**
+     * The initial value of the accumulator.
+     */
+    accu_init?: ExprAmino;
+    /**
+     * 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.
+     */
+    loop_condition?: ExprAmino;
+    /**
+     * An expression which can contain iter_var, iter_var2, and accu_var.
+     *
+     * Computes the next value of accu_var.
+     */
+    loop_step?: ExprAmino;
+    /**
+     * An expression which can contain accu_var.
+     *
+     * Computes the result.
+     */
+    result?: ExprAmino;
+}
+export interface Expr_ComprehensionAminoMsg {
+    type: "/google.api.expr.v1alpha1.Comprehension";
+    value: Expr_ComprehensionAmino;
+}
+/**
+ * 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`.
+ * @name Constant
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Constant
+ */
+export interface Constant {
+    /**
+     * null value.
+     */
+    nullValue?: NullValue;
+    /**
+     * boolean value.
+     */
+    boolValue?: boolean;
+    /**
+     * int64 value.
+     */
+    int64Value?: bigint;
+    /**
+     * uint64 value.
+     */
+    uint64Value?: bigint;
+    /**
+     * number value.
+     */
+    doubleValue?: number;
+    /**
+     * string value.
+     */
+    stringValue?: string;
+    /**
+     * bytes value.
+     */
+    bytesValue?: Uint8Array;
+    /**
+     * protobuf.Duration value.
+     *
+     * Deprecated: duration is no longer considered a builtin cel type.
+     * @deprecated
+     */
+    durationValue?: Duration;
+    /**
+     * protobuf.Timestamp value.
+     *
+     * Deprecated: timestamp is no longer considered a builtin cel type.
+     * @deprecated
+     */
+    timestampValue?: Date;
+}
+export interface ConstantProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Constant";
+    value: Uint8Array;
+}
+/**
+ * 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`.
+ * @name ConstantAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Constant
+ */
+export interface ConstantAmino {
+    /**
+     * null value.
+     */
+    null_value?: NullValue;
+    /**
+     * boolean value.
+     */
+    bool_value?: boolean;
+    /**
+     * int64 value.
+     */
+    int64_value?: string;
+    /**
+     * uint64 value.
+     */
+    uint64_value?: string;
+    /**
+     * number value.
+     */
+    double_value?: number;
+    /**
+     * string value.
+     */
+    string_value?: string;
+    /**
+     * bytes value.
+     */
+    bytes_value?: string;
+    /**
+     * protobuf.Duration value.
+     *
+     * Deprecated: duration is no longer considered a builtin cel type.
+     * @deprecated
+     */
+    duration_value?: DurationAmino;
+    /**
+     * protobuf.Timestamp value.
+     *
+     * Deprecated: timestamp is no longer considered a builtin cel type.
+     * @deprecated
+     */
+    timestamp_value?: string;
+}
+export interface ConstantAminoMsg {
+    type: "/google.api.expr.v1alpha1.Constant";
+    value: ConstantAmino;
+}
+/**
+ * @name SourceInfo_PositionsEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export interface SourceInfo_PositionsEntry {
+    key: bigint;
+    value: number;
+}
+export interface SourceInfo_PositionsEntryProtoMsg {
+    typeUrl: string;
+    value: Uint8Array;
+}
+/**
+ * @name SourceInfo_PositionsEntryAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo_PositionsEntry
+ */
+export interface SourceInfo_PositionsEntryAmino {
+    key: string;
+    value: number;
+}
+export interface SourceInfo_PositionsEntryAminoMsg {
+    type: string;
+    value: SourceInfo_PositionsEntryAmino;
+}
+/**
+ * @name SourceInfo_MacroCallsEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export interface SourceInfo_MacroCallsEntry {
+    key: bigint;
+    value?: Expr;
+}
+export interface SourceInfo_MacroCallsEntryProtoMsg {
+    typeUrl: string;
+    value: Uint8Array;
+}
+/**
+ * @name SourceInfo_MacroCallsEntryAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo_MacroCallsEntry
+ */
+export interface SourceInfo_MacroCallsEntryAmino {
+    key: string;
+    value?: ExprAmino;
+}
+export interface SourceInfo_MacroCallsEntryAminoMsg {
+    type: string;
+    value: SourceInfo_MacroCallsEntryAmino;
+}
+/**
+ * Source information collected at parse time.
+ * @name SourceInfo
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo
+ */
+export interface SourceInfo {
+    /**
+     * The syntax version of the source, e.g. `cel1`.
+     */
+    syntaxVersion: string;
+    /**
+     * 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`.
+     */
+    location: string;
+    /**
+     * 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 derivd from `id_positions[id] - line_offsets[i]`.
+     */
+    lineOffsets: number[];
+    /**
+     * A map from the parse node id (e.g. `Expr.id`) to the code point offset
+     * within the source.
+     */
+    positions: {
+        [key: bigint]: number;
+    };
+    /**
+     * 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.
+     */
+    macroCalls: {
+        [key: bigint]: Expr;
+    };
+    /**
+     * 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.
+     */
+    extensions: SourceInfo_Extension[];
+}
+export interface SourceInfoProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.SourceInfo";
+    value: Uint8Array;
+}
+/**
+ * Source information collected at parse time.
+ * @name SourceInfoAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo
+ */
+export interface SourceInfoAmino {
+    /**
+     * The syntax version of the source, e.g. `cel1`.
+     */
+    syntax_version: string;
+    /**
+     * 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`.
+     */
+    location: string;
+    /**
+     * 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 derivd from `id_positions[id] - line_offsets[i]`.
+     */
+    line_offsets: number[];
+    /**
+     * A map from the parse node id (e.g. `Expr.id`) to the code point offset
+     * within the source.
+     */
+    positions: {
+        [key: string]: number;
+    };
+    /**
+     * 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.
+     */
+    macro_calls: {
+        [key: string]: ExprAmino;
+    };
+    /**
+     * 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.
+     */
+    extensions: SourceInfo_ExtensionAmino[];
+}
+export interface SourceInfoAminoMsg {
+    type: "/google.api.expr.v1alpha1.SourceInfo";
+    value: SourceInfoAmino;
+}
+/**
+ * An extension that was requested for the source expression.
+ * @name SourceInfo_Extension
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Extension
+ */
+export interface SourceInfo_Extension {
+    /**
+     * Identifier for the extension. Example: constant_folding
+     */
+    id: string;
+    /**
+     * 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.
+     */
+    affectedComponents: SourceInfo_Extension_Component[];
+    /**
+     * Version info. May be skipped if it isn't meaningful for the extension.
+     * (for example constant_folding might always be v0.0).
+     */
+    version?: SourceInfo_Extension_Version;
+}
+export interface SourceInfo_ExtensionProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Extension";
+    value: Uint8Array;
+}
+/**
+ * An extension that was requested for the source expression.
+ * @name SourceInfo_ExtensionAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo_Extension
+ */
+export interface SourceInfo_ExtensionAmino {
+    /**
+     * Identifier for the extension. Example: constant_folding
+     */
+    id: string;
+    /**
+     * 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.
+     */
+    affected_components: SourceInfo_Extension_Component[];
+    /**
+     * Version info. May be skipped if it isn't meaningful for the extension.
+     * (for example constant_folding might always be v0.0).
+     */
+    version?: SourceInfo_Extension_VersionAmino;
+}
+export interface SourceInfo_ExtensionAminoMsg {
+    type: "/google.api.expr.v1alpha1.Extension";
+    value: SourceInfo_ExtensionAmino;
+}
+/**
+ * Version
+ * @name SourceInfo_Extension_Version
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Version
+ */
+export interface SourceInfo_Extension_Version {
+    /**
+     * Major version changes indicate different required support level from
+     * the required components.
+     */
+    major: bigint;
+    /**
+     * Minor version changes must not change the observed behavior from
+     * existing implementations, but may be provided informationally.
+     */
+    minor: bigint;
+}
+export interface SourceInfo_Extension_VersionProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Version";
+    value: Uint8Array;
+}
+/**
+ * Version
+ * @name SourceInfo_Extension_VersionAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo_Extension_Version
+ */
+export interface SourceInfo_Extension_VersionAmino {
+    /**
+     * Major version changes indicate different required support level from
+     * the required components.
+     */
+    major: string;
+    /**
+     * Minor version changes must not change the observed behavior from
+     * existing implementations, but may be provided informationally.
+     */
+    minor: string;
+}
+export interface SourceInfo_Extension_VersionAminoMsg {
+    type: "/google.api.expr.v1alpha1.Version";
+    value: SourceInfo_Extension_VersionAmino;
+}
+/**
+ * A specific position in source.
+ * @name SourcePosition
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourcePosition
+ */
+export interface SourcePosition {
+    /**
+     * The soucre location name (e.g. file name).
+     */
+    location: string;
+    /**
+     * The UTF-8 code unit offset.
+     */
+    offset: number;
+    /**
+     * The 1-based index of the starting line in the source text
+     * where the issue occurs, or 0 if unknown.
+     */
+    line: number;
+    /**
+     * The 0-based index of the starting position within the line of source text
+     * where the issue occurs.  Only meaningful if line is nonzero.
+     */
+    column: number;
+}
+export interface SourcePositionProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.SourcePosition";
+    value: Uint8Array;
+}
+/**
+ * A specific position in source.
+ * @name SourcePositionAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourcePosition
+ */
+export interface SourcePositionAmino {
+    /**
+     * The soucre location name (e.g. file name).
+     */
+    location: string;
+    /**
+     * The UTF-8 code unit offset.
+     */
+    offset: number;
+    /**
+     * The 1-based index of the starting line in the source text
+     * where the issue occurs, or 0 if unknown.
+     */
+    line: number;
+    /**
+     * The 0-based index of the starting position within the line of source text
+     * where the issue occurs.  Only meaningful if line is nonzero.
+     */
+    column: number;
+}
+export interface SourcePositionAminoMsg {
+    type: "/google.api.expr.v1alpha1.SourcePosition";
+    value: SourcePositionAmino;
+}
+/**
+ * An expression together with source information as returned by the parser.
+ * @name ParsedExpr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ParsedExpr
+ */
+export declare const ParsedExpr: {
+    typeUrl: string;
+    is(o: any): o is ParsedExpr;
+    isAmino(o: any): o is ParsedExprAmino;
+    encode(message: ParsedExpr, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ParsedExpr;
+    fromPartial(object: DeepPartial<ParsedExpr>): ParsedExpr;
+    fromAmino(object: ParsedExprAmino): ParsedExpr;
+    toAmino(message: ParsedExpr): ParsedExprAmino;
+    fromAminoMsg(object: ParsedExprAminoMsg): ParsedExpr;
+    fromProtoMsg(message: ParsedExprProtoMsg): ParsedExpr;
+    toProto(message: ParsedExpr): Uint8Array;
+    toProtoMsg(message: ParsedExpr): ParsedExprProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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`.
+ * @name Expr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr
+ */
+export declare const Expr: {
+    typeUrl: string;
+    is(o: any): o is Expr;
+    isAmino(o: any): o is ExprAmino;
+    encode(message: Expr, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr;
+    fromPartial(object: DeepPartial<Expr>): Expr;
+    fromAmino(object: ExprAmino): Expr;
+    toAmino(message: Expr): ExprAmino;
+    fromAminoMsg(object: ExprAminoMsg): Expr;
+    fromProtoMsg(message: ExprProtoMsg): Expr;
+    toProto(message: Expr): Uint8Array;
+    toProtoMsg(message: Expr): ExprProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * An identifier expression. e.g. `request`.
+ * @name Expr_Ident
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Ident
+ */
+export declare const Expr_Ident: {
+    typeUrl: string;
+    is(o: any): o is Expr_Ident;
+    isAmino(o: any): o is Expr_IdentAmino;
+    encode(message: Expr_Ident, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr_Ident;
+    fromPartial(object: DeepPartial<Expr_Ident>): Expr_Ident;
+    fromAmino(object: Expr_IdentAmino): Expr_Ident;
+    toAmino(message: Expr_Ident): Expr_IdentAmino;
+    fromAminoMsg(object: Expr_IdentAminoMsg): Expr_Ident;
+    fromProtoMsg(message: Expr_IdentProtoMsg): Expr_Ident;
+    toProto(message: Expr_Ident): Uint8Array;
+    toProtoMsg(message: Expr_Ident): Expr_IdentProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * A field selection expression. e.g. `request.auth`.
+ * @name Expr_Select
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Select
+ */
+export declare const Expr_Select: {
+    typeUrl: string;
+    is(o: any): o is Expr_Select;
+    isAmino(o: any): o is Expr_SelectAmino;
+    encode(message: Expr_Select, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr_Select;
+    fromPartial(object: DeepPartial<Expr_Select>): Expr_Select;
+    fromAmino(object: Expr_SelectAmino): Expr_Select;
+    toAmino(message: Expr_Select): Expr_SelectAmino;
+    fromAminoMsg(object: Expr_SelectAminoMsg): Expr_Select;
+    fromProtoMsg(message: Expr_SelectProtoMsg): Expr_Select;
+    toProto(message: Expr_Select): Uint8Array;
+    toProtoMsg(message: Expr_Select): Expr_SelectProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * A call expression, including calls to predefined functions and operators.
+ *
+ * For example, `value == 10`, `size(map_value)`.
+ * @name Expr_Call
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Call
+ */
+export declare const Expr_Call: {
+    typeUrl: string;
+    is(o: any): o is Expr_Call;
+    isAmino(o: any): o is Expr_CallAmino;
+    encode(message: Expr_Call, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr_Call;
+    fromPartial(object: DeepPartial<Expr_Call>): Expr_Call;
+    fromAmino(object: Expr_CallAmino): Expr_Call;
+    toAmino(message: Expr_Call): Expr_CallAmino;
+    fromAminoMsg(object: Expr_CallAminoMsg): Expr_Call;
+    fromProtoMsg(message: Expr_CallProtoMsg): Expr_Call;
+    toProto(message: Expr_Call): Uint8Array;
+    toProtoMsg(message: Expr_Call): Expr_CallProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * A list creation expression.
+ *
+ * Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g.
+ * `dyn([1, 'hello', 2.0])`
+ * @name Expr_CreateList
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CreateList
+ */
+export declare const Expr_CreateList: {
+    typeUrl: string;
+    is(o: any): o is Expr_CreateList;
+    isAmino(o: any): o is Expr_CreateListAmino;
+    encode(message: Expr_CreateList, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr_CreateList;
+    fromPartial(object: DeepPartial<Expr_CreateList>): Expr_CreateList;
+    fromAmino(object: Expr_CreateListAmino): Expr_CreateList;
+    toAmino(message: Expr_CreateList): Expr_CreateListAmino;
+    fromAminoMsg(object: Expr_CreateListAminoMsg): Expr_CreateList;
+    fromProtoMsg(message: Expr_CreateListProtoMsg): Expr_CreateList;
+    toProto(message: Expr_CreateList): Uint8Array;
+    toProtoMsg(message: Expr_CreateList): Expr_CreateListProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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'}`.
+ * @name Expr_CreateStruct
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CreateStruct
+ */
+export declare const Expr_CreateStruct: {
+    typeUrl: string;
+    is(o: any): o is Expr_CreateStruct;
+    isAmino(o: any): o is Expr_CreateStructAmino;
+    encode(message: Expr_CreateStruct, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr_CreateStruct;
+    fromPartial(object: DeepPartial<Expr_CreateStruct>): Expr_CreateStruct;
+    fromAmino(object: Expr_CreateStructAmino): Expr_CreateStruct;
+    toAmino(message: Expr_CreateStruct): Expr_CreateStructAmino;
+    fromAminoMsg(object: Expr_CreateStructAminoMsg): Expr_CreateStruct;
+    fromProtoMsg(message: Expr_CreateStructProtoMsg): Expr_CreateStruct;
+    toProto(message: Expr_CreateStruct): Uint8Array;
+    toProtoMsg(message: Expr_CreateStruct): Expr_CreateStructProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Represents an entry.
+ * @name Expr_CreateStruct_Entry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Entry
+ */
+export declare const Expr_CreateStruct_Entry: {
+    typeUrl: string;
+    is(o: any): o is Expr_CreateStruct_Entry;
+    isAmino(o: any): o is Expr_CreateStruct_EntryAmino;
+    encode(message: Expr_CreateStruct_Entry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr_CreateStruct_Entry;
+    fromPartial(object: DeepPartial<Expr_CreateStruct_Entry>): Expr_CreateStruct_Entry;
+    fromAmino(object: Expr_CreateStruct_EntryAmino): Expr_CreateStruct_Entry;
+    toAmino(message: Expr_CreateStruct_Entry): Expr_CreateStruct_EntryAmino;
+    fromAminoMsg(object: Expr_CreateStruct_EntryAminoMsg): Expr_CreateStruct_Entry;
+    fromProtoMsg(message: Expr_CreateStruct_EntryProtoMsg): Expr_CreateStruct_Entry;
+    toProto(message: Expr_CreateStruct_Entry): Uint8Array;
+    toProtoMsg(message: Expr_CreateStruct_Entry): Expr_CreateStruct_EntryProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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`
+ * ```
+ * @name Expr_Comprehension
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Comprehension
+ */
+export declare const Expr_Comprehension: {
+    typeUrl: string;
+    is(o: any): o is Expr_Comprehension;
+    isAmino(o: any): o is Expr_ComprehensionAmino;
+    encode(message: Expr_Comprehension, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Expr_Comprehension;
+    fromPartial(object: DeepPartial<Expr_Comprehension>): Expr_Comprehension;
+    fromAmino(object: Expr_ComprehensionAmino): Expr_Comprehension;
+    toAmino(message: Expr_Comprehension): Expr_ComprehensionAmino;
+    fromAminoMsg(object: Expr_ComprehensionAminoMsg): Expr_Comprehension;
+    fromProtoMsg(message: Expr_ComprehensionProtoMsg): Expr_Comprehension;
+    toProto(message: Expr_Comprehension): Uint8Array;
+    toProtoMsg(message: Expr_Comprehension): Expr_ComprehensionProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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`.
+ * @name Constant
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Constant
+ */
+export declare const Constant: {
+    typeUrl: string;
+    is(o: any): o is Constant;
+    isAmino(o: any): o is ConstantAmino;
+    encode(message: Constant, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Constant;
+    fromPartial(object: DeepPartial<Constant>): Constant;
+    fromAmino(object: ConstantAmino): Constant;
+    toAmino(message: Constant): ConstantAmino;
+    fromAminoMsg(object: ConstantAminoMsg): Constant;
+    fromProtoMsg(message: ConstantProtoMsg): Constant;
+    toProto(message: Constant): Uint8Array;
+    toProtoMsg(message: Constant): ConstantProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * @name SourceInfo_PositionsEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export declare const SourceInfo_PositionsEntry: {
+    encode(message: SourceInfo_PositionsEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SourceInfo_PositionsEntry;
+    fromPartial(object: DeepPartial<SourceInfo_PositionsEntry>): SourceInfo_PositionsEntry;
+    fromAmino(object: SourceInfo_PositionsEntryAmino): SourceInfo_PositionsEntry;
+    toAmino(message: SourceInfo_PositionsEntry): SourceInfo_PositionsEntryAmino;
+    fromAminoMsg(object: SourceInfo_PositionsEntryAminoMsg): SourceInfo_PositionsEntry;
+    fromProtoMsg(message: SourceInfo_PositionsEntryProtoMsg): SourceInfo_PositionsEntry;
+    toProto(message: SourceInfo_PositionsEntry): Uint8Array;
+    registerTypeUrl(): void;
+};
+/**
+ * @name SourceInfo_MacroCallsEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export declare const SourceInfo_MacroCallsEntry: {
+    encode(message: SourceInfo_MacroCallsEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SourceInfo_MacroCallsEntry;
+    fromPartial(object: DeepPartial<SourceInfo_MacroCallsEntry>): SourceInfo_MacroCallsEntry;
+    fromAmino(object: SourceInfo_MacroCallsEntryAmino): SourceInfo_MacroCallsEntry;
+    toAmino(message: SourceInfo_MacroCallsEntry): SourceInfo_MacroCallsEntryAmino;
+    fromAminoMsg(object: SourceInfo_MacroCallsEntryAminoMsg): SourceInfo_MacroCallsEntry;
+    fromProtoMsg(message: SourceInfo_MacroCallsEntryProtoMsg): SourceInfo_MacroCallsEntry;
+    toProto(message: SourceInfo_MacroCallsEntry): Uint8Array;
+    registerTypeUrl(): void;
+};
+/**
+ * Source information collected at parse time.
+ * @name SourceInfo
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo
+ */
+export declare const SourceInfo: {
+    typeUrl: string;
+    is(o: any): o is SourceInfo;
+    isAmino(o: any): o is SourceInfoAmino;
+    encode(message: SourceInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SourceInfo;
+    fromPartial(object: DeepPartial<SourceInfo>): SourceInfo;
+    fromAmino(object: SourceInfoAmino): SourceInfo;
+    toAmino(message: SourceInfo): SourceInfoAmino;
+    fromAminoMsg(object: SourceInfoAminoMsg): SourceInfo;
+    fromProtoMsg(message: SourceInfoProtoMsg): SourceInfo;
+    toProto(message: SourceInfo): Uint8Array;
+    toProtoMsg(message: SourceInfo): SourceInfoProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * An extension that was requested for the source expression.
+ * @name SourceInfo_Extension
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Extension
+ */
+export declare const SourceInfo_Extension: {
+    typeUrl: string;
+    is(o: any): o is SourceInfo_Extension;
+    isAmino(o: any): o is SourceInfo_ExtensionAmino;
+    encode(message: SourceInfo_Extension, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SourceInfo_Extension;
+    fromPartial(object: DeepPartial<SourceInfo_Extension>): SourceInfo_Extension;
+    fromAmino(object: SourceInfo_ExtensionAmino): SourceInfo_Extension;
+    toAmino(message: SourceInfo_Extension): SourceInfo_ExtensionAmino;
+    fromAminoMsg(object: SourceInfo_ExtensionAminoMsg): SourceInfo_Extension;
+    fromProtoMsg(message: SourceInfo_ExtensionProtoMsg): SourceInfo_Extension;
+    toProto(message: SourceInfo_Extension): Uint8Array;
+    toProtoMsg(message: SourceInfo_Extension): SourceInfo_ExtensionProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Version
+ * @name SourceInfo_Extension_Version
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Version
+ */
+export declare const SourceInfo_Extension_Version: {
+    typeUrl: string;
+    is(o: any): o is SourceInfo_Extension_Version;
+    isAmino(o: any): o is SourceInfo_Extension_VersionAmino;
+    encode(message: SourceInfo_Extension_Version, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SourceInfo_Extension_Version;
+    fromPartial(object: DeepPartial<SourceInfo_Extension_Version>): SourceInfo_Extension_Version;
+    fromAmino(object: SourceInfo_Extension_VersionAmino): SourceInfo_Extension_Version;
+    toAmino(message: SourceInfo_Extension_Version): SourceInfo_Extension_VersionAmino;
+    fromAminoMsg(object: SourceInfo_Extension_VersionAminoMsg): SourceInfo_Extension_Version;
+    fromProtoMsg(message: SourceInfo_Extension_VersionProtoMsg): SourceInfo_Extension_Version;
+    toProto(message: SourceInfo_Extension_Version): Uint8Array;
+    toProtoMsg(message: SourceInfo_Extension_Version): SourceInfo_Extension_VersionProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * A specific position in source.
+ * @name SourcePosition
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourcePosition
+ */
+export declare const SourcePosition: {
+    typeUrl: string;
+    is(o: any): o is SourcePosition;
+    isAmino(o: any): o is SourcePositionAmino;
+    encode(message: SourcePosition, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SourcePosition;
+    fromPartial(object: DeepPartial<SourcePosition>): SourcePosition;
+    fromAmino(object: SourcePositionAmino): SourcePosition;
+    toAmino(message: SourcePosition): SourcePositionAmino;
+    fromAminoMsg(object: SourcePositionAminoMsg): SourcePosition;
+    fromProtoMsg(message: SourcePositionProtoMsg): SourcePosition;
+    toProto(message: SourcePosition): Uint8Array;
+    toProtoMsg(message: SourcePosition): SourcePositionProtoMsg;
+    registerTypeUrl(): void;
+};