@bufbuild/cel-spec/dist/cjs/gen/cel/expr/eval_pb.d.ts

CEL definitions and test data

import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
import type { Any } from "@bufbuild/protobuf/wkt";
import type { Value } from "./value_pb.js";
import type { Message } from "@bufbuild/protobuf";
/**
 * Describes the file cel/expr/eval.proto.
 */
export declare const file_cel_expr_eval: GenFile;
/**
 * The state of an evaluation.
 *
 * Can represent an initial, partial, or completed state of evaluation.
 *
 * @generated from message cel.expr.EvalState
 */
export type EvalState = Message<"cel.expr.EvalState"> & {
    /**
     * The unique values referenced in this message.
     *
     * @generated from field: repeated cel.expr.ExprValue values = 1;
     */
    values: ExprValue[];
    /**
     * An ordered list of results.
     *
     * Tracks the flow of evaluation through the expression.
     * May be sparse.
     *
     * @generated from field: repeated cel.expr.EvalState.Result results = 3;
     */
    results: EvalState_Result[];
};
/**
 * Describes the message cel.expr.EvalState.
 * Use `create(EvalStateSchema)` to create a new message.
 */
export declare const EvalStateSchema: GenMessage<EvalState>;
/**
 * A single evaluation result.
 *
 * @generated from message cel.expr.EvalState.Result
 */
export type EvalState_Result = Message<"cel.expr.EvalState.Result"> & {
    /**
     * The id of the expression this result if for.
     *
     * @generated from field: int64 expr = 1;
     */
    expr: bigint;
    /**
     * The index in `values` of the resulting value.
     *
     * @generated from field: int64 value = 2;
     */
    value: bigint;
};
/**
 * Describes the message cel.expr.EvalState.Result.
 * Use `create(EvalState_ResultSchema)` to create a new message.
 */
export declare const EvalState_ResultSchema: GenMessage<EvalState_Result>;
/**
 * The value of an evaluated expression.
 *
 * @generated from message cel.expr.ExprValue
 */
export type ExprValue = Message<"cel.expr.ExprValue"> & {
    /**
     * An expression can resolve to a value, error or unknown.
     *
     * @generated from oneof cel.expr.ExprValue.kind
     */
    kind: {
        /**
         * @generated from field: cel.expr.Value value = 1;
         */
        value: Value;
        case: "value";
    } | {
        /**
         * The set of errors in the critical path of evaluation.
         *
         * Only errors in the critical path are included. For example,
         * `(<error1> || true) && <error2>` will only result in `<error2>`,
         * while `<error1> || <error2>` will result in both `<error1>` and
         * `<error2>`.
         *
         * Errors cause by the presence of other errors are not included in the
         * set. For example `<error1>.foo`, `foo(<error1>)`, and `<error1> + 1` will
         * only result in `<error1>`.
         *
         * Multiple errors *might* be included when evaluation could result
         * in different errors. For example `<error1> + <error2>` and
         * `foo(<error1>, <error2>)` may result in `<error1>`, `<error2>` or both.
         * The exact subset of errors included for this case is unspecified and
         * depends on the implementation details of the evaluator.
         *
         * @generated from field: cel.expr.ErrorSet error = 2;
         */
        value: ErrorSet;
        case: "error";
    } | {
        /**
         * The set of unknowns in the critical path of evaluation.
         *
         * Unknown behaves identically to Error with regards to propagation.
         * Specifically, only unknowns in the critical path are included, unknowns
         * caused by the presence of other unknowns are not included, and multiple
         * unknowns *might* be included when evaluation could result in
         * different unknowns. For example:
         *
         *     (<unknown[1]> || true) && <unknown[2]> -> <unknown[2]>
         *     <unknown[1]> || <unknown[2]> -> <unknown[1,2]>
         *     <unknown[1]>.foo -> <unknown[1]>
         *     foo(<unknown[1]>) -> <unknown[1]>
         *     <unknown[1]> + <unknown[2]> -> <unknown[1]> or <unknown[2[>
         *
         * Unknown takes precedence over Error in cases where a `Value` can short
         * circuit the result:
         *
         *     <error> || <unknown> -> <unknown>
         *     <error> && <unknown> -> <unknown>
         *
         * Errors take precedence in all other cases:
         *
         *     <unknown> + <error> -> <error>
         *     foo(<unknown>, <error>) -> <error>
         *
         * @generated from field: cel.expr.UnknownSet unknown = 3;
         */
        value: UnknownSet;
        case: "unknown";
    } | {
        case: undefined;
        value?: undefined;
    };
};
/**
 * Describes the message cel.expr.ExprValue.
 * Use `create(ExprValueSchema)` to create a new message.
 */
export declare const ExprValueSchema: GenMessage<ExprValue>;
/**
 * A set of errors.
 *
 * The errors included depend on the context. See `ExprValue.error`.
 *
 * @generated from message cel.expr.ErrorSet
 */
export type ErrorSet = Message<"cel.expr.ErrorSet"> & {
    /**
     * Errors that could come up during evaluation phase.
     *
     * @generated from field: repeated cel.expr.Status errors = 1;
     */
    errors: Status[];
};
/**
 * Describes the message cel.expr.ErrorSet.
 * Use `create(ErrorSetSchema)` to create a new message.
 */
export declare const ErrorSetSchema: GenMessage<ErrorSet>;
/**
 * Each `Status` message contains three pieces of data: error code, error message,
 * and error details.
 *
 * You can find out more about this error model and how to work with it in the
 * [API Design Guide](https://cloud.google.com/apis/design/errors).
 *
 * Status value is intended to be wire and field compatible with `google.rpc.Status`.
 *
 * @generated from message cel.expr.Status
 */
export type Status = Message<"cel.expr.Status"> & {
    /**
     * The status code, which should be an enum value of [google.rpc.Code][].
     *
     * @generated from field: int32 code = 1;
     */
    code: number;
    /**
     * A developer-facing error message, which should be in English. Any
     * user-facing error message should be localized and sent in the
     * [Status.details][] field, or localized by the client.
     *
     * @generated from field: string message = 2;
     */
    message: string;
    /**
     * A list of messages that carry the error details.  There is a common set of
     * message types for APIs to use.
     *
     * @generated from field: repeated google.protobuf.Any details = 3;
     */
    details: Any[];
};
/**
 * Describes the message cel.expr.Status.
 * Use `create(StatusSchema)` to create a new message.
 */
export declare const StatusSchema: GenMessage<Status>;
/**
 * A set of expressions for which the value is unknown.
 *
 * The unknowns included depend on the context. See `ExprValue.unknown`.
 *
 * @generated from message cel.expr.UnknownSet
 */
export type UnknownSet = Message<"cel.expr.UnknownSet"> & {
    /**
     * The ids of the expressions with unknown values.
     *
     * @generated from field: repeated int64 exprs = 1;
     */
    exprs: bigint[];
};
/**
 * Describes the message cel.expr.UnknownSet.
 * Use `create(UnknownSetSchema)` to create a new message.
 */
export declare const UnknownSetSchema: GenMessage<UnknownSet>;