google-ads-api-client/dist/protos/bindings/google/api/expr/v1alpha1/eval.d.ts

A friendly and exhaustive client to the google-ads-api, code generated directly from google's published protobuf schema.

import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { Status } from "../../../rpc/status";
import { Value } from "./value";
/**
 * The state of an evaluation.
 *
 * Can represent an inital, partial, or completed state of evaluation.
 *
 * @generated from protobuf message google.api.expr.v1alpha1.EvalState
 */
export interface EvalState {
    /**
     * The unique values referenced in this message.
     *
     * @generated from protobuf field: repeated google.api.expr.v1alpha1.ExprValue values = 1;
     */
    values: ExprValue[];
    /**
     * An ordered list of results.
     *
     * Tracks the flow of evaluation through the expression.
     * May be sparse.
     *
     * @generated from protobuf field: repeated google.api.expr.v1alpha1.EvalState.Result results = 3;
     */
    results: EvalState_Result[];
}
/**
 * A single evalution result.
 *
 * @generated from protobuf message google.api.expr.v1alpha1.EvalState.Result
 */
export interface EvalState_Result {
    /**
     * The id of the expression this result if for.
     *
     * @generated from protobuf field: int64 expr = 1;
     */
    expr: bigint;
    /**
     * The index in `values` of the resulting value.
     *
     * @generated from protobuf field: int64 value = 2;
     */
    value: bigint;
}
/**
 * The value of an evaluated expression.
 *
 * @generated from protobuf message google.api.expr.v1alpha1.ExprValue
 */
export interface ExprValue {
    /**
     * @generated from protobuf oneof: kind
     */
    kind: {
        oneofKind: "value";
        /**
         * A concrete value.
         *
         * @generated from protobuf field: google.api.expr.v1alpha1.Value value = 1;
         */
        value: Value;
    } | {
        oneofKind: "error";
        /**
         * The set of errors in the critical path of evalution.
         *
         * Only errors in the critical path are included. For example,
         * `(<error1> || true) && <error2>` will only result in `<error2>`,
         * while `<error1> || <error2>` will result in both `<error1>` and
         * `<error2>`.
         *
         * Errors cause by the presence of other errors are not included in the
         * set. For example `<error1>.foo`, `foo(<error1>)`, and `<error1> + 1` will
         * only result in `<error1>`.
         *
         * Multiple errors *might* be included when evaluation could result
         * in different errors. For example `<error1> + <error2>` and
         * `foo(<error1>, <error2>)` may result in `<error1>`, `<error2>` or both.
         * The exact subset of errors included for this case is unspecified and
         * depends on the implementation details of the evaluator.
         *
         * @generated from protobuf field: google.api.expr.v1alpha1.ErrorSet error = 2;
         */
        error: ErrorSet;
    } | {
        oneofKind: "unknown";
        /**
         * The set of unknowns in the critical path of evaluation.
         *
         * Unknown behaves identically to Error with regards to propagation.
         * Specifically, only unknowns in the critical path are included, unknowns
         * caused by the presence of other unknowns are not included, and multiple
         * unknowns *might* be included included when evaluation could result in
         * different unknowns. For example:
         *
         *     (<unknown[1]> || true) && <unknown[2]> -> <unknown[2]>
         *     <unknown[1]> || <unknown[2]> -> <unknown[1,2]>
         *     <unknown[1]>.foo -> <unknown[1]>
         *     foo(<unknown[1]>) -> <unknown[1]>
         *     <unknown[1]> + <unknown[2]> -> <unknown[1]> or <unknown[2[>
         *
         * Unknown takes precidence over Error in cases where a `Value` can short
         * circuit the result:
         *
         *     <error> || <unknown> -> <unknown>
         *     <error> && <unknown> -> <unknown>
         *
         * Errors take precidence in all other cases:
         *
         *     <unknown> + <error> -> <error>
         *     foo(<unknown>, <error>) -> <error>
         *
         * @generated from protobuf field: google.api.expr.v1alpha1.UnknownSet unknown = 3;
         */
        unknown: UnknownSet;
    } | {
        oneofKind: undefined;
    };
}
/**
 * A set of errors.
 *
 * The errors included depend on the context. See `ExprValue.error`.
 *
 * @generated from protobuf message google.api.expr.v1alpha1.ErrorSet
 */
export interface ErrorSet {
    /**
     * The errors in the set.
     *
     * @generated from protobuf field: repeated google.rpc.Status errors = 1;
     */
    errors: Status[];
}
/**
 * A set of expressions for which the value is unknown.
 *
 * The unknowns included depend on the context. See `ExprValue.unknown`.
 *
 * @generated from protobuf message google.api.expr.v1alpha1.UnknownSet
 */
export interface UnknownSet {
    /**
     * The ids of the expressions with unknown values.
     *
     * @generated from protobuf field: repeated int64 exprs = 1;
     */
    exprs: bigint[];
}
declare class EvalState$Type extends MessageType<EvalState> {
    constructor();
    create(value?: PartialMessage<EvalState>): EvalState;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EvalState): EvalState;
    internalBinaryWrite(message: EvalState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.api.expr.v1alpha1.EvalState
 */
export declare const EvalState: EvalState$Type;
declare class EvalState_Result$Type extends MessageType<EvalState_Result> {
    constructor();
    create(value?: PartialMessage<EvalState_Result>): EvalState_Result;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EvalState_Result): EvalState_Result;
    internalBinaryWrite(message: EvalState_Result, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.api.expr.v1alpha1.EvalState.Result
 */
export declare const EvalState_Result: EvalState_Result$Type;
declare class ExprValue$Type extends MessageType<ExprValue> {
    constructor();
    create(value?: PartialMessage<ExprValue>): ExprValue;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExprValue): ExprValue;
    internalBinaryWrite(message: ExprValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.api.expr.v1alpha1.ExprValue
 */
export declare const ExprValue: ExprValue$Type;
declare class ErrorSet$Type extends MessageType<ErrorSet> {
    constructor();
    create(value?: PartialMessage<ErrorSet>): ErrorSet;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ErrorSet): ErrorSet;
    internalBinaryWrite(message: ErrorSet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.api.expr.v1alpha1.ErrorSet
 */
export declare const ErrorSet: ErrorSet$Type;
declare class UnknownSet$Type extends MessageType<UnknownSet> {
    constructor();
    create(value?: PartialMessage<UnknownSet>): UnknownSet;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UnknownSet): UnknownSet;
    internalBinaryWrite(message: UnknownSet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.api.expr.v1alpha1.UnknownSet
 */
export declare const UnknownSet: UnknownSet$Type;
export {};