@bufbuild/protovalidate/dist/esm/cel.d.ts

Protocol Buffer Validation for ECMAScript

import { type DescExtension, type DescField, type DescMessage, type Registry, type ScalarType } from "@bufbuild/protobuf";
import type { Path, ReflectMessageGet } from "@bufbuild/protobuf/reflect";
import { type CelInput, plan } from "@bufbuild/cel";
import { type Rule, type FieldRules } from "./gen/buf/validate/validate_pb.js";
import { CompilationError } from "./error.js";
import type { Eval } from "./eval.js";
import type { Cursor } from "./cursor.js";
import { type RegexMatcher } from "./func.js";
type CelCompiledRules = {
    standard: {
        field: DescField;
        rule: Rule;
        compiled: CelCompiledRule;
    }[];
    extensions: Map<number, {
        ext: DescExtension;
        rule: Rule;
        compiled: CelCompiledRule;
    }[]>;
};
export type CelCompiledRule = {
    kind: "compilation_error";
    error: CompilationError;
} | {
    kind: "interpretable";
    interpretable: ReturnType<typeof plan>;
    rule: Rule;
};
export declare class CelManager {
    private readonly registry;
    private readonly env;
    private readonly rulesCache;
    private readonly bindings;
    constructor(registry: Registry, regexMatcher: RegexMatcher | undefined);
    /**
     * Update the CEL variable "now" to the current time.
     */
    updateCelNow(): void;
    setEnv(key: Exclude<keyof typeof this.bindings, "now">, value: CelInput | undefined): void;
    eval(compiled: CelCompiledRule): {
        message: string;
        ruleId: string;
    } | undefined;
    compileRule(ruleOrExpr: Rule | string): CelCompiledRule;
    compileRules(descMessage: DescMessage): CelCompiledRules;
    private compileRulesUncached;
}
export declare class EvalCustomCel implements Eval<ReflectMessageGet> {
    private readonly celMan;
    private readonly forMapKey;
    private readonly thisScalarType;
    private readonly children;
    constructor(celMan: CelManager, forMapKey: boolean, thisScalarType: ScalarType | undefined);
    add(compiled: CelCompiledRule, rulePath: Path): void;
    eval(val: ReflectMessageGet, cursor: Cursor): void;
    prune(): boolean;
}
export declare class EvalExtendedRulesCel implements Eval<ReflectMessageGet> {
    private readonly celMan;
    private readonly rules;
    private readonly forMapKey;
    private readonly children;
    private readonly thisScalarType;
    constructor(celMan: CelManager, rules: Exclude<FieldRules["type"]["value"], undefined>, forMapKey: boolean);
    add(compiled: CelCompiledRule, rulePath: Path, ruleValue: ReflectMessageGet, ruleScalarType: ScalarType | undefined): void;
    eval(val: ReflectMessageGet, cursor: Cursor): void;
    prune(): boolean;
}
export declare class EvalStandardRulesCel implements Eval<ReflectMessageGet> {
    private readonly celMan;
    private readonly rules;
    private readonly forMapKey;
    private readonly children;
    private readonly thisScalarType;
    constructor(celMan: CelManager, rules: Exclude<FieldRules["type"]["value"], undefined>, forMapKey: boolean);
    add(compiled: CelCompiledRule, rulePath: Path): void;
    eval(val: ReflectMessageGet, cursor: Cursor): void;
    prune(): boolean;
}
export {};