@0xkaleab/sdk-js 0.2.7

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

@@ -0,0 +1,1201 @@
+import { SourceInfo, SourceInfoAmino, Expr, ExprAmino, Constant, ConstantAmino } from "./syntax";
+import { Empty, EmptyAmino } from "../../../protobuf/empty";
+import { NullValue } from "../../../protobuf/struct";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** CEL primitive types. */
+export declare enum Type_PrimitiveType {
+    /** PRIMITIVE_TYPE_UNSPECIFIED - Unspecified type. */
+    PRIMITIVE_TYPE_UNSPECIFIED = 0,
+    /** BOOL - Boolean type. */
+    BOOL = 1,
+    /**
+     * INT64 - Int64 type.
+     *
+     * Proto-based integer values are widened to int64.
+     */
+    INT64 = 2,
+    /**
+     * UINT64 - Uint64 type.
+     *
+     * Proto-based unsigned integer values are widened to uint64.
+     */
+    UINT64 = 3,
+    /**
+     * DOUBLE - Double type.
+     *
+     * Proto-based float values are widened to number values.
+     */
+    DOUBLE = 4,
+    /** STRING - String type. */
+    STRING = 5,
+    /** BYTES - Bytes type. */
+    BYTES = 6,
+    UNRECOGNIZED = -1
+}
+export declare const Type_PrimitiveTypeAmino: typeof Type_PrimitiveType;
+export declare function type_PrimitiveTypeFromJSON(object: any): Type_PrimitiveType;
+export declare function type_PrimitiveTypeToJSON(object: Type_PrimitiveType): string;
+/** Well-known protobuf types treated with first-class support in CEL. */
+export declare enum Type_WellKnownType {
+    /** WELL_KNOWN_TYPE_UNSPECIFIED - Unspecified type. */
+    WELL_KNOWN_TYPE_UNSPECIFIED = 0,
+    /**
+     * ANY - 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.
+     */
+    ANY = 1,
+    /** TIMESTAMP - Well-known protobuf.Timestamp type, internally referenced as `timestamp`. */
+    TIMESTAMP = 2,
+    /** DURATION - Well-known protobuf.Duration type, internally referenced as `duration`. */
+    DURATION = 3,
+    UNRECOGNIZED = -1
+}
+export declare const Type_WellKnownTypeAmino: typeof Type_WellKnownType;
+export declare function type_WellKnownTypeFromJSON(object: any): Type_WellKnownType;
+export declare function type_WellKnownTypeToJSON(object: Type_WellKnownType): string;
+/**
+ * @name CheckedExpr_ReferenceMapEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export interface CheckedExpr_ReferenceMapEntry {
+    key: bigint;
+    value?: Reference;
+}
+export interface CheckedExpr_ReferenceMapEntryProtoMsg {
+    typeUrl: string;
+    value: Uint8Array;
+}
+/**
+ * @name CheckedExpr_ReferenceMapEntryAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CheckedExpr_ReferenceMapEntry
+ */
+export interface CheckedExpr_ReferenceMapEntryAmino {
+    key: string;
+    value?: ReferenceAmino;
+}
+export interface CheckedExpr_ReferenceMapEntryAminoMsg {
+    type: string;
+    value: CheckedExpr_ReferenceMapEntryAmino;
+}
+/**
+ * @name CheckedExpr_TypeMapEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export interface CheckedExpr_TypeMapEntry {
+    key: bigint;
+    value?: Type;
+}
+export interface CheckedExpr_TypeMapEntryProtoMsg {
+    typeUrl: string;
+    value: Uint8Array;
+}
+/**
+ * @name CheckedExpr_TypeMapEntryAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CheckedExpr_TypeMapEntry
+ */
+export interface CheckedExpr_TypeMapEntryAmino {
+    key: string;
+    value?: TypeAmino;
+}
+export interface CheckedExpr_TypeMapEntryAminoMsg {
+    type: string;
+    value: CheckedExpr_TypeMapEntryAmino;
+}
+/**
+ * A CEL expression which has been successfully type checked.
+ * @name CheckedExpr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CheckedExpr
+ */
+export interface CheckedExpr {
+    /**
+     * 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.
+     */
+    referenceMap: {
+        [key: bigint]: Reference;
+    };
+    /**
+     * 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.
+     */
+    typeMap: {
+        [key: bigint]: Type;
+    };
+    /**
+     * The source info derived from input that generated the parsed `expr` and
+     * any optimizations made during the type-checking pass.
+     */
+    sourceInfo?: SourceInfo;
+    /**
+     * The expr version indicates the major / minor version number of the `expr`
+     * representation.
+     *
+     * The most common reason for a version change will be to indicate to the CEL
+     * runtimes that transformations have been performed on the expr during static
+     * analysis. In some cases, this will save the runtime the work of applying
+     * the same or similar transformations prior to evaluation.
+     */
+    exprVersion: string;
+    /**
+     * The checked expression. Semantically equivalent to the parsed `expr`, but
+     * may have structural differences.
+     */
+    expr?: Expr;
+}
+export interface CheckedExprProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.CheckedExpr";
+    value: Uint8Array;
+}
+/**
+ * A CEL expression which has been successfully type checked.
+ * @name CheckedExprAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CheckedExpr
+ */
+export interface CheckedExprAmino {
+    /**
+     * 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.
+     */
+    reference_map: {
+        [key: string]: ReferenceAmino;
+    };
+    /**
+     * 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.
+     */
+    type_map: {
+        [key: string]: TypeAmino;
+    };
+    /**
+     * The source info derived from input that generated the parsed `expr` and
+     * any optimizations made during the type-checking pass.
+     */
+    source_info?: SourceInfoAmino;
+    /**
+     * The expr version indicates the major / minor version number of the `expr`
+     * representation.
+     *
+     * The most common reason for a version change will be to indicate to the CEL
+     * runtimes that transformations have been performed on the expr during static
+     * analysis. In some cases, this will save the runtime the work of applying
+     * the same or similar transformations prior to evaluation.
+     */
+    expr_version: string;
+    /**
+     * The checked expression. Semantically equivalent to the parsed `expr`, but
+     * may have structural differences.
+     */
+    expr?: ExprAmino;
+}
+export interface CheckedExprAminoMsg {
+    type: "/google.api.expr.v1alpha1.CheckedExpr";
+    value: CheckedExprAmino;
+}
+/**
+ * Represents a CEL type.
+ * @name Type
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type
+ */
+export interface Type {
+    /**
+     * Dynamic type.
+     */
+    dyn?: Empty;
+    /**
+     * Null value.
+     */
+    null?: NullValue;
+    /**
+     * Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.
+     */
+    primitive?: Type_PrimitiveType;
+    /**
+     * Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.
+     */
+    wrapper?: Type_PrimitiveType;
+    /**
+     * Well-known protobuf type such as `google.protobuf.Timestamp`.
+     */
+    wellKnown?: Type_WellKnownType;
+    /**
+     * Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.
+     */
+    listType?: Type_ListType;
+    /**
+     * Parameterized map with typed keys and values.
+     */
+    mapType?: Type_MapType;
+    /**
+     * Function type.
+     */
+    function?: Type_FunctionType;
+    /**
+     * Protocol buffer message type.
+     *
+     * The `message_type` string specifies the qualified message type name. For
+     * example, `google.plus.Profile`.
+     */
+    messageType?: string;
+    /**
+     * 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`.
+     */
+    typeParam?: string;
+    /**
+     * Type type.
+     *
+     * The `type` value specifies the target type. e.g. int is type with a
+     * target type of `Primitive.INT`.
+     */
+    type?: Type;
+    /**
+     * 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.
+     */
+    error?: Empty;
+    /**
+     * Abstract, application defined type.
+     */
+    abstractType?: Type_AbstractType;
+}
+export interface TypeProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Type";
+    value: Uint8Array;
+}
+/**
+ * Represents a CEL type.
+ * @name TypeAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type
+ */
+export interface TypeAmino {
+    /**
+     * Dynamic type.
+     */
+    dyn?: EmptyAmino;
+    /**
+     * Null value.
+     */
+    null?: NullValue;
+    /**
+     * Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.
+     */
+    primitive?: Type_PrimitiveType;
+    /**
+     * Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.
+     */
+    wrapper?: Type_PrimitiveType;
+    /**
+     * Well-known protobuf type such as `google.protobuf.Timestamp`.
+     */
+    well_known?: Type_WellKnownType;
+    /**
+     * Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.
+     */
+    list_type?: Type_ListTypeAmino;
+    /**
+     * Parameterized map with typed keys and values.
+     */
+    map_type?: Type_MapTypeAmino;
+    /**
+     * Function type.
+     */
+    function?: Type_FunctionTypeAmino;
+    /**
+     * Protocol buffer message type.
+     *
+     * The `message_type` string specifies the qualified message type name. For
+     * example, `google.plus.Profile`.
+     */
+    message_type?: string;
+    /**
+     * 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_param?: string;
+    /**
+     * Type type.
+     *
+     * The `type` value specifies the target type. e.g. int is type with a
+     * target type of `Primitive.INT`.
+     */
+    type?: TypeAmino;
+    /**
+     * 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.
+     */
+    error?: EmptyAmino;
+    /**
+     * Abstract, application defined type.
+     */
+    abstract_type?: Type_AbstractTypeAmino;
+}
+export interface TypeAminoMsg {
+    type: "/google.api.expr.v1alpha1.Type";
+    value: TypeAmino;
+}
+/**
+ * List type with typed elements, e.g. `list<example.proto.MyMessage>`.
+ * @name Type_ListType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ListType
+ */
+export interface Type_ListType {
+    /**
+     * The element type.
+     */
+    elemType?: Type;
+}
+export interface Type_ListTypeProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.ListType";
+    value: Uint8Array;
+}
+/**
+ * List type with typed elements, e.g. `list<example.proto.MyMessage>`.
+ * @name Type_ListTypeAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type_ListType
+ */
+export interface Type_ListTypeAmino {
+    /**
+     * The element type.
+     */
+    elem_type?: TypeAmino;
+}
+export interface Type_ListTypeAminoMsg {
+    type: "/google.api.expr.v1alpha1.ListType";
+    value: Type_ListTypeAmino;
+}
+/**
+ * Map type with parameterized key and value types, e.g. `map<string, int>`.
+ * @name Type_MapType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.MapType
+ */
+export interface Type_MapType {
+    /**
+     * The type of the key.
+     */
+    keyType?: Type;
+    /**
+     * The type of the value.
+     */
+    valueType?: Type;
+}
+export interface Type_MapTypeProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.MapType";
+    value: Uint8Array;
+}
+/**
+ * Map type with parameterized key and value types, e.g. `map<string, int>`.
+ * @name Type_MapTypeAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type_MapType
+ */
+export interface Type_MapTypeAmino {
+    /**
+     * The type of the key.
+     */
+    key_type?: TypeAmino;
+    /**
+     * The type of the value.
+     */
+    value_type?: TypeAmino;
+}
+export interface Type_MapTypeAminoMsg {
+    type: "/google.api.expr.v1alpha1.MapType";
+    value: Type_MapTypeAmino;
+}
+/**
+ * Function type with result and arg types.
+ * @name Type_FunctionType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.FunctionType
+ */
+export interface Type_FunctionType {
+    /**
+     * Result type of the function.
+     */
+    resultType?: Type;
+    /**
+     * Argument types of the function.
+     */
+    argTypes: Type[];
+}
+export interface Type_FunctionTypeProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.FunctionType";
+    value: Uint8Array;
+}
+/**
+ * Function type with result and arg types.
+ * @name Type_FunctionTypeAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type_FunctionType
+ */
+export interface Type_FunctionTypeAmino {
+    /**
+     * Result type of the function.
+     */
+    result_type?: TypeAmino;
+    /**
+     * Argument types of the function.
+     */
+    arg_types: TypeAmino[];
+}
+export interface Type_FunctionTypeAminoMsg {
+    type: "/google.api.expr.v1alpha1.FunctionType";
+    value: Type_FunctionTypeAmino;
+}
+/**
+ * Application defined abstract type.
+ * @name Type_AbstractType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.AbstractType
+ */
+export interface Type_AbstractType {
+    /**
+     * The fully qualified name of this abstract type.
+     */
+    name: string;
+    /**
+     * Parameter types for this abstract type.
+     */
+    parameterTypes: Type[];
+}
+export interface Type_AbstractTypeProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.AbstractType";
+    value: Uint8Array;
+}
+/**
+ * Application defined abstract type.
+ * @name Type_AbstractTypeAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type_AbstractType
+ */
+export interface Type_AbstractTypeAmino {
+    /**
+     * The fully qualified name of this abstract type.
+     */
+    name: string;
+    /**
+     * Parameter types for this abstract type.
+     */
+    parameter_types: TypeAmino[];
+}
+export interface Type_AbstractTypeAminoMsg {
+    type: "/google.api.expr.v1alpha1.AbstractType";
+    value: Type_AbstractTypeAmino;
+}
+/**
+ * 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.
+ * @name Decl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Decl
+ */
+export interface Decl {
+    /**
+     * 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].
+     */
+    name: string;
+    /**
+     * Identifier declaration.
+     */
+    ident?: Decl_IdentDecl;
+    /**
+     * Function declaration.
+     */
+    function?: Decl_FunctionDecl;
+}
+export interface DeclProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Decl";
+    value: Uint8Array;
+}
+/**
+ * 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.
+ * @name DeclAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Decl
+ */
+export interface DeclAmino {
+    /**
+     * 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].
+     */
+    name: string;
+    /**
+     * Identifier declaration.
+     */
+    ident?: Decl_IdentDeclAmino;
+    /**
+     * Function declaration.
+     */
+    function?: Decl_FunctionDeclAmino;
+}
+export interface DeclAminoMsg {
+    type: "/google.api.expr.v1alpha1.Decl";
+    value: DeclAmino;
+}
+/**
+ * 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.
+ * @name Decl_IdentDecl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.IdentDecl
+ */
+export interface Decl_IdentDecl {
+    /**
+     * Required. The type of the identifier.
+     */
+    type?: Type;
+    /**
+     * The constant value of the identifier. If not specified, the identifier
+     * must be supplied at evaluation time.
+     */
+    value?: Constant;
+    /**
+     * Documentation string for the identifier.
+     */
+    doc: string;
+}
+export interface Decl_IdentDeclProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.IdentDecl";
+    value: Uint8Array;
+}
+/**
+ * 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.
+ * @name Decl_IdentDeclAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Decl_IdentDecl
+ */
+export interface Decl_IdentDeclAmino {
+    /**
+     * Required. The type of the identifier.
+     */
+    type?: TypeAmino;
+    /**
+     * The constant value of the identifier. If not specified, the identifier
+     * must be supplied at evaluation time.
+     */
+    value?: ConstantAmino;
+    /**
+     * Documentation string for the identifier.
+     */
+    doc: string;
+}
+export interface Decl_IdentDeclAminoMsg {
+    type: "/google.api.expr.v1alpha1.IdentDecl";
+    value: Decl_IdentDeclAmino;
+}
+/**
+ * Function declaration specifies one or more overloads which indicate the
+ * function's parameter types and return type.
+ *
+ * Functions have no observable side-effects (there may be side-effects like
+ * logging which are not observable from CEL).
+ * @name Decl_FunctionDecl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.FunctionDecl
+ */
+export interface Decl_FunctionDecl {
+    /**
+     * Required. List of function overloads, must contain at least one overload.
+     */
+    overloads: Decl_FunctionDecl_Overload[];
+}
+export interface Decl_FunctionDeclProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.FunctionDecl";
+    value: Uint8Array;
+}
+/**
+ * Function declaration specifies one or more overloads which indicate the
+ * function's parameter types and return type.
+ *
+ * Functions have no observable side-effects (there may be side-effects like
+ * logging which are not observable from CEL).
+ * @name Decl_FunctionDeclAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Decl_FunctionDecl
+ */
+export interface Decl_FunctionDeclAmino {
+    /**
+     * Required. List of function overloads, must contain at least one overload.
+     */
+    overloads: Decl_FunctionDecl_OverloadAmino[];
+}
+export interface Decl_FunctionDeclAminoMsg {
+    type: "/google.api.expr.v1alpha1.FunctionDecl";
+    value: Decl_FunctionDeclAmino;
+}
+/**
+ * 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).
+ * @name Decl_FunctionDecl_Overload
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Overload
+ */
+export interface Decl_FunctionDecl_Overload {
+    /**
+     * 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`.
+     */
+    overloadId: string;
+    /**
+     * 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.
+     */
+    params: Type[];
+    /**
+     * 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`.
+     */
+    typeParams: string[];
+    /**
+     * Required. The result type of the function. For example, the operator
+     * `string.isEmpty()` would have `result_type` of `kind: BOOL`.
+     */
+    resultType?: Type;
+    /**
+     * Whether the function is to be used in a method call-style `x.f(...)`
+     * or a function call-style `f(x, ...)`.
+     *
+     * For methods, the first parameter declaration, `params[0]` is the
+     * expected type of the target receiver.
+     */
+    isInstanceFunction: boolean;
+    /**
+     * Documentation string for the overload.
+     */
+    doc: string;
+}
+export interface Decl_FunctionDecl_OverloadProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Overload";
+    value: Uint8Array;
+}
+/**
+ * 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).
+ * @name Decl_FunctionDecl_OverloadAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Decl_FunctionDecl_Overload
+ */
+export interface Decl_FunctionDecl_OverloadAmino {
+    /**
+     * 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`.
+     */
+    overload_id: string;
+    /**
+     * 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.
+     */
+    params: TypeAmino[];
+    /**
+     * 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`.
+     */
+    type_params: string[];
+    /**
+     * Required. The result type of the function. For example, the operator
+     * `string.isEmpty()` would have `result_type` of `kind: BOOL`.
+     */
+    result_type?: TypeAmino;
+    /**
+     * Whether the function is to be used in a method call-style `x.f(...)`
+     * or a function call-style `f(x, ...)`.
+     *
+     * For methods, the first parameter declaration, `params[0]` is the
+     * expected type of the target receiver.
+     */
+    is_instance_function: boolean;
+    /**
+     * Documentation string for the overload.
+     */
+    doc: string;
+}
+export interface Decl_FunctionDecl_OverloadAminoMsg {
+    type: "/google.api.expr.v1alpha1.Overload";
+    value: Decl_FunctionDecl_OverloadAmino;
+}
+/**
+ * Describes a resolved reference to a declaration.
+ * @name Reference
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Reference
+ */
+export interface Reference {
+    /**
+     * The fully qualified name of the declaration.
+     */
+    name: string;
+    /**
+     * 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].
+     */
+    overloadId: string[];
+    /**
+     * For references to constants, this may contain the value of the
+     * constant if known at compile time.
+     */
+    value?: Constant;
+}
+export interface ReferenceProtoMsg {
+    typeUrl: "/google.api.expr.v1alpha1.Reference";
+    value: Uint8Array;
+}
+/**
+ * Describes a resolved reference to a declaration.
+ * @name ReferenceAmino
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Reference
+ */
+export interface ReferenceAmino {
+    /**
+     * The fully qualified name of the declaration.
+     */
+    name: string;
+    /**
+     * 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].
+     */
+    overload_id: string[];
+    /**
+     * For references to constants, this may contain the value of the
+     * constant if known at compile time.
+     */
+    value?: ConstantAmino;
+}
+export interface ReferenceAminoMsg {
+    type: "/google.api.expr.v1alpha1.Reference";
+    value: ReferenceAmino;
+}
+/**
+ * @name CheckedExpr_ReferenceMapEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export declare const CheckedExpr_ReferenceMapEntry: {
+    encode(message: CheckedExpr_ReferenceMapEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CheckedExpr_ReferenceMapEntry;
+    fromPartial(object: DeepPartial<CheckedExpr_ReferenceMapEntry>): CheckedExpr_ReferenceMapEntry;
+    fromAmino(object: CheckedExpr_ReferenceMapEntryAmino): CheckedExpr_ReferenceMapEntry;
+    toAmino(message: CheckedExpr_ReferenceMapEntry): CheckedExpr_ReferenceMapEntryAmino;
+    fromAminoMsg(object: CheckedExpr_ReferenceMapEntryAminoMsg): CheckedExpr_ReferenceMapEntry;
+    fromProtoMsg(message: CheckedExpr_ReferenceMapEntryProtoMsg): CheckedExpr_ReferenceMapEntry;
+    toProto(message: CheckedExpr_ReferenceMapEntry): Uint8Array;
+    registerTypeUrl(): void;
+};
+/**
+ * @name CheckedExpr_TypeMapEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export declare const CheckedExpr_TypeMapEntry: {
+    encode(message: CheckedExpr_TypeMapEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CheckedExpr_TypeMapEntry;
+    fromPartial(object: DeepPartial<CheckedExpr_TypeMapEntry>): CheckedExpr_TypeMapEntry;
+    fromAmino(object: CheckedExpr_TypeMapEntryAmino): CheckedExpr_TypeMapEntry;
+    toAmino(message: CheckedExpr_TypeMapEntry): CheckedExpr_TypeMapEntryAmino;
+    fromAminoMsg(object: CheckedExpr_TypeMapEntryAminoMsg): CheckedExpr_TypeMapEntry;
+    fromProtoMsg(message: CheckedExpr_TypeMapEntryProtoMsg): CheckedExpr_TypeMapEntry;
+    toProto(message: CheckedExpr_TypeMapEntry): Uint8Array;
+    registerTypeUrl(): void;
+};
+/**
+ * A CEL expression which has been successfully type checked.
+ * @name CheckedExpr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CheckedExpr
+ */
+export declare const CheckedExpr: {
+    typeUrl: string;
+    is(o: any): o is CheckedExpr;
+    isAmino(o: any): o is CheckedExprAmino;
+    encode(message: CheckedExpr, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CheckedExpr;
+    fromPartial(object: DeepPartial<CheckedExpr>): CheckedExpr;
+    fromAmino(object: CheckedExprAmino): CheckedExpr;
+    toAmino(message: CheckedExpr): CheckedExprAmino;
+    fromAminoMsg(object: CheckedExprAminoMsg): CheckedExpr;
+    fromProtoMsg(message: CheckedExprProtoMsg): CheckedExpr;
+    toProto(message: CheckedExpr): Uint8Array;
+    toProtoMsg(message: CheckedExpr): CheckedExprProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Represents a CEL type.
+ * @name Type
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type
+ */
+export declare const Type: {
+    typeUrl: string;
+    is(o: any): o is Type;
+    isAmino(o: any): o is TypeAmino;
+    encode(message: Type, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Type;
+    fromPartial(object: DeepPartial<Type>): Type;
+    fromAmino(object: TypeAmino): Type;
+    toAmino(message: Type): TypeAmino;
+    fromAminoMsg(object: TypeAminoMsg): Type;
+    fromProtoMsg(message: TypeProtoMsg): Type;
+    toProto(message: Type): Uint8Array;
+    toProtoMsg(message: Type): TypeProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * List type with typed elements, e.g. `list<example.proto.MyMessage>`.
+ * @name Type_ListType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ListType
+ */
+export declare const Type_ListType: {
+    typeUrl: string;
+    is(o: any): o is Type_ListType;
+    isAmino(o: any): o is Type_ListTypeAmino;
+    encode(message: Type_ListType, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Type_ListType;
+    fromPartial(object: DeepPartial<Type_ListType>): Type_ListType;
+    fromAmino(object: Type_ListTypeAmino): Type_ListType;
+    toAmino(message: Type_ListType): Type_ListTypeAmino;
+    fromAminoMsg(object: Type_ListTypeAminoMsg): Type_ListType;
+    fromProtoMsg(message: Type_ListTypeProtoMsg): Type_ListType;
+    toProto(message: Type_ListType): Uint8Array;
+    toProtoMsg(message: Type_ListType): Type_ListTypeProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Map type with parameterized key and value types, e.g. `map<string, int>`.
+ * @name Type_MapType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.MapType
+ */
+export declare const Type_MapType: {
+    typeUrl: string;
+    is(o: any): o is Type_MapType;
+    isAmino(o: any): o is Type_MapTypeAmino;
+    encode(message: Type_MapType, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Type_MapType;
+    fromPartial(object: DeepPartial<Type_MapType>): Type_MapType;
+    fromAmino(object: Type_MapTypeAmino): Type_MapType;
+    toAmino(message: Type_MapType): Type_MapTypeAmino;
+    fromAminoMsg(object: Type_MapTypeAminoMsg): Type_MapType;
+    fromProtoMsg(message: Type_MapTypeProtoMsg): Type_MapType;
+    toProto(message: Type_MapType): Uint8Array;
+    toProtoMsg(message: Type_MapType): Type_MapTypeProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Function type with result and arg types.
+ * @name Type_FunctionType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.FunctionType
+ */
+export declare const Type_FunctionType: {
+    typeUrl: string;
+    is(o: any): o is Type_FunctionType;
+    isAmino(o: any): o is Type_FunctionTypeAmino;
+    encode(message: Type_FunctionType, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Type_FunctionType;
+    fromPartial(object: DeepPartial<Type_FunctionType>): Type_FunctionType;
+    fromAmino(object: Type_FunctionTypeAmino): Type_FunctionType;
+    toAmino(message: Type_FunctionType): Type_FunctionTypeAmino;
+    fromAminoMsg(object: Type_FunctionTypeAminoMsg): Type_FunctionType;
+    fromProtoMsg(message: Type_FunctionTypeProtoMsg): Type_FunctionType;
+    toProto(message: Type_FunctionType): Uint8Array;
+    toProtoMsg(message: Type_FunctionType): Type_FunctionTypeProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Application defined abstract type.
+ * @name Type_AbstractType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.AbstractType
+ */
+export declare const Type_AbstractType: {
+    typeUrl: string;
+    is(o: any): o is Type_AbstractType;
+    isAmino(o: any): o is Type_AbstractTypeAmino;
+    encode(message: Type_AbstractType, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Type_AbstractType;
+    fromPartial(object: DeepPartial<Type_AbstractType>): Type_AbstractType;
+    fromAmino(object: Type_AbstractTypeAmino): Type_AbstractType;
+    toAmino(message: Type_AbstractType): Type_AbstractTypeAmino;
+    fromAminoMsg(object: Type_AbstractTypeAminoMsg): Type_AbstractType;
+    fromProtoMsg(message: Type_AbstractTypeProtoMsg): Type_AbstractType;
+    toProto(message: Type_AbstractType): Uint8Array;
+    toProtoMsg(message: Type_AbstractType): Type_AbstractTypeProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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.
+ * @name Decl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Decl
+ */
+export declare const Decl: {
+    typeUrl: string;
+    is(o: any): o is Decl;
+    isAmino(o: any): o is DeclAmino;
+    encode(message: Decl, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Decl;
+    fromPartial(object: DeepPartial<Decl>): Decl;
+    fromAmino(object: DeclAmino): Decl;
+    toAmino(message: Decl): DeclAmino;
+    fromAminoMsg(object: DeclAminoMsg): Decl;
+    fromProtoMsg(message: DeclProtoMsg): Decl;
+    toProto(message: Decl): Uint8Array;
+    toProtoMsg(message: Decl): DeclProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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.
+ * @name Decl_IdentDecl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.IdentDecl
+ */
+export declare const Decl_IdentDecl: {
+    typeUrl: string;
+    is(o: any): o is Decl_IdentDecl;
+    isAmino(o: any): o is Decl_IdentDeclAmino;
+    encode(message: Decl_IdentDecl, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Decl_IdentDecl;
+    fromPartial(object: DeepPartial<Decl_IdentDecl>): Decl_IdentDecl;
+    fromAmino(object: Decl_IdentDeclAmino): Decl_IdentDecl;
+    toAmino(message: Decl_IdentDecl): Decl_IdentDeclAmino;
+    fromAminoMsg(object: Decl_IdentDeclAminoMsg): Decl_IdentDecl;
+    fromProtoMsg(message: Decl_IdentDeclProtoMsg): Decl_IdentDecl;
+    toProto(message: Decl_IdentDecl): Uint8Array;
+    toProtoMsg(message: Decl_IdentDecl): Decl_IdentDeclProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Function declaration specifies one or more overloads which indicate the
+ * function's parameter types and return type.
+ *
+ * Functions have no observable side-effects (there may be side-effects like
+ * logging which are not observable from CEL).
+ * @name Decl_FunctionDecl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.FunctionDecl
+ */
+export declare const Decl_FunctionDecl: {
+    typeUrl: string;
+    is(o: any): o is Decl_FunctionDecl;
+    isAmino(o: any): o is Decl_FunctionDeclAmino;
+    encode(message: Decl_FunctionDecl, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Decl_FunctionDecl;
+    fromPartial(object: DeepPartial<Decl_FunctionDecl>): Decl_FunctionDecl;
+    fromAmino(object: Decl_FunctionDeclAmino): Decl_FunctionDecl;
+    toAmino(message: Decl_FunctionDecl): Decl_FunctionDeclAmino;
+    fromAminoMsg(object: Decl_FunctionDeclAminoMsg): Decl_FunctionDecl;
+    fromProtoMsg(message: Decl_FunctionDeclProtoMsg): Decl_FunctionDecl;
+    toProto(message: Decl_FunctionDecl): Uint8Array;
+    toProtoMsg(message: Decl_FunctionDecl): Decl_FunctionDeclProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * 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).
+ * @name Decl_FunctionDecl_Overload
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Overload
+ */
+export declare const Decl_FunctionDecl_Overload: {
+    typeUrl: string;
+    is(o: any): o is Decl_FunctionDecl_Overload;
+    isAmino(o: any): o is Decl_FunctionDecl_OverloadAmino;
+    encode(message: Decl_FunctionDecl_Overload, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Decl_FunctionDecl_Overload;
+    fromPartial(object: DeepPartial<Decl_FunctionDecl_Overload>): Decl_FunctionDecl_Overload;
+    fromAmino(object: Decl_FunctionDecl_OverloadAmino): Decl_FunctionDecl_Overload;
+    toAmino(message: Decl_FunctionDecl_Overload): Decl_FunctionDecl_OverloadAmino;
+    fromAminoMsg(object: Decl_FunctionDecl_OverloadAminoMsg): Decl_FunctionDecl_Overload;
+    fromProtoMsg(message: Decl_FunctionDecl_OverloadProtoMsg): Decl_FunctionDecl_Overload;
+    toProto(message: Decl_FunctionDecl_Overload): Uint8Array;
+    toProtoMsg(message: Decl_FunctionDecl_Overload): Decl_FunctionDecl_OverloadProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Describes a resolved reference to a declaration.
+ * @name Reference
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Reference
+ */
+export declare const Reference: {
+    typeUrl: string;
+    is(o: any): o is Reference;
+    isAmino(o: any): o is ReferenceAmino;
+    encode(message: Reference, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Reference;
+    fromPartial(object: DeepPartial<Reference>): Reference;
+    fromAmino(object: ReferenceAmino): Reference;
+    toAmino(message: Reference): ReferenceAmino;
+    fromAminoMsg(object: ReferenceAminoMsg): Reference;
+    fromProtoMsg(message: ReferenceProtoMsg): Reference;
+    toProto(message: Reference): Uint8Array;
+    toProtoMsg(message: Reference): ReferenceProtoMsg;
+    registerTypeUrl(): void;
+};