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

Protocol Buffer Validation for ECMAScript

import type { ReflectList, ReflectMap, ReflectMessage, ReflectMessageGet, ScalarValue, PathBuilder } from "@bufbuild/protobuf/reflect";
import type { DescEnum, DescField, DescOneof } from "@bufbuild/protobuf";
import { type AnyRules, type EnumRules } from "./gen/buf/validate/validate_pb.js";
import type { Cursor } from "./cursor.js";
import type { Condition } from "./condition.js";
/**
 * Evaluate rules for a value.
 */
export type Eval<V> = {
    eval(val: V, cursor: Cursor): void;
    /**
     * Remove any dead code paths.
     * Return true if this is now a no-op.
     */
    prune(): boolean;
};
/**
 * The no-op evaluator.
 */
export declare class EvalNoop<T> implements Eval<T> {
    private static instance;
    static get<T>(): EvalNoop<T>;
    eval(): void;
    prune(): boolean;
}
/**
 * Evaluate many.
 */
export declare class EvalMany<T> implements Eval<T> {
    private many;
    constructor(...evals: (Eval<T> | Eval<T>[])[]);
    add(...evals: Eval<T>[]): this;
    eval(val: T, cursor: Cursor): void;
    prune(): boolean;
}
/**
 * Evaluated all items in a list.
 */
export declare class EvalListItems<T extends ReflectMessageGet> implements Eval<ReflectList> {
    private readonly condition;
    private readonly pass;
    constructor(condition: Condition<T>, pass: Eval<T>);
    eval(val: ReflectList, cursor: Cursor): void;
    prune(): boolean;
}
/**
 * Evaluate key and value of all entries in a map.
 */
export declare class EvalMapEntries<V extends ReflectMessageGet> implements Eval<ReflectMap> {
    private keyCondition;
    private key;
    private valueCondition;
    private value;
    constructor(keyCondition: Condition<ScalarValue>, key: Eval<string | number | bigint | boolean>, valueCondition: Condition<V>, value: Eval<V>);
    eval(val: ReflectMap, cursor: Cursor): void;
    prune(): boolean;
}
/**
 * Evaluate field. If the condition passes, evaluate the field's value.
 */
export declare class EvalField<F extends DescField> implements Eval<ReflectMessage> {
    private readonly field;
    private readonly required;
    private readonly legacyRequired;
    private readonly condition;
    private readonly pass;
    constructor(field: F, required: boolean, legacyRequired: boolean, condition: Condition<ReflectMessage>, pass: Eval<ReflectMessageGet<F>>);
    eval(val: ReflectMessage, cursor: Cursor): void;
    prune(): boolean;
}
export declare class EvalOneofRequired implements Eval<ReflectMessage> {
    private readonly oneof;
    constructor(oneof: DescOneof);
    eval(val: ReflectMessage, cursor: Cursor): void;
    prune(): boolean;
}
/**
 * buf.validate.EnumRules.defined_only does not use CEL expressions. This implements custom logic for this field.
 */
export declare class EvalEnumDefinedOnly implements Eval<number> {
    private readonly rulePath;
    private readonly definedOnly;
    constructor(descEnum: DescEnum, rulePath: PathBuilder, rules: EnumRules);
    eval(val: number, cursor: Cursor): void;
    prune(): boolean;
}
/**
 * buf.validate.AnyRules.in and not_in do not use CEL expressions. This implements custom logic for these fields.
 */
export declare class EvalAnyRules implements Eval<ReflectMessage> {
    private readonly rulePath;
    private readonly in;
    private readonly notIn;
    constructor(rulePath: PathBuilder, rules: AnyRules);
    eval(val: ReflectMessage, cursor: Cursor): void;
    prune(): boolean;
}
/**
 * buf.validate.MessageOneofRule does not use CEL expressions. This implements custom logic for this rule.
 */
export declare class EvalMessageOneofRule implements Eval<ReflectMessage> {
    private readonly fields;
    private readonly required;
    constructor(fields: DescField[], required: boolean);
    eval(val: ReflectMessage, cursor: Cursor): void;
    prune(): boolean;
}