type DecodePath = readonly (string | number)[];
export type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
export interface JsonObject {
    [key: string]: JsonValue;
}
declare class BoundaryDecodeError extends Error {
    readonly path: DecodePath;
    /** The problem without its location, such as "expected string". */
    readonly reason: string;
    constructor(message: string, path?: DecodePath);
}
/** One problem found by `decodeBoundaryAll`; `where` reads like `outputs[0].label` ("input" for the root). */
export interface BoundaryIssue {
    readonly path: DecodePath;
    readonly where: string;
    readonly message: string;
}
/** Every problem `decodeBoundaryAll` found, in schema field order; the message lists them as `where: message; ...`. */
export declare class BoundaryDecodeIssues extends BoundaryDecodeError {
    readonly issues: readonly BoundaryIssue[];
    constructor(issues: readonly BoundaryIssue[]);
}
export interface BoundaryCursor {
    readonly value: unknown;
    readonly path: DecodePath;
    child(key: string | number, value: unknown): BoundaryCursor;
    fail(message: string): never;
    /**
     * Records a child's failure when decoding with `decodeBoundaryAll` and returns true, so the
     * caller moves on to the next field; returns false otherwise, and the caller rethrows.
     */
    collect(error: BoundaryDecodeError): boolean;
    /** The same position without collecting, for schemas that must see the first failure (unions). */
    strict(): BoundaryCursor;
}
export interface BoundarySchema<T> {
    decode(cursor: BoundaryCursor): T;
}
type ObjectFields = {
    [key: string]: BoundarySchema<unknown>;
};
type InferSchema<Schema> = Schema extends BoundarySchema<infer Value> ? Value : never;
type InferObject<Fields extends ObjectFields> = {
    [Key in keyof Fields]: InferSchema<Fields[Key]>;
};
declare function decodeJsonValue(current: BoundaryCursor): JsonValue;
declare function decodeJsonObject(current: BoundaryCursor): JsonObject;
export declare const boundary: {
    string: BoundarySchema<string>;
    nonEmptyString: {
        decode(current: BoundaryCursor): string;
    };
    number: BoundarySchema<number>;
    boolean: BoundarySchema<boolean>;
    json: {
        decode: typeof decodeJsonValue;
    };
    jsonObject: {
        decode: typeof decodeJsonObject;
    };
    literal<const Value extends string | number | boolean | null>(expected: Value): BoundarySchema<Value>;
    enumeration<const Values extends readonly (string | number)[]>(...values: Values): BoundarySchema<Values[number]>;
    optional<Value>(schema: BoundarySchema<Value>): BoundarySchema<Value | undefined>;
    nullable<Value>(schema: BoundarySchema<Value>): BoundarySchema<Value | null>;
    array<Value>(schema: BoundarySchema<Value>): BoundarySchema<Value[]>;
    object<const Fields extends ObjectFields>(fields: Fields): BoundarySchema<InferObject<Fields>>;
    /** Accepts a decoded value only when `test` holds; otherwise fails with `message`. */
    refine<Value>(schema: BoundarySchema<Value>, test: (value: Value) => boolean, message: string): BoundarySchema<Value>;
    union<const Schemas extends readonly BoundarySchema<unknown>[]>(...schemas: Schemas): BoundarySchema<InferSchema<Schemas[number]>>;
};
export declare function decodeBoundary<Value>(value: unknown, schema: BoundarySchema<Value>): Value;
/**
 * Like `decodeBoundary`, but reports every problem at once: object fields and array items are all
 * decoded, an absent required field reads "missing", and a failure throws `BoundaryDecodeIssues`.
 * Opt-in, for payloads people and agents write by hand.
 */
export declare function decodeBoundaryAll<Value>(value: unknown, schema: BoundarySchema<Value>): Value;
export {};
//# sourceMappingURL=boundaryDecoder.d.ts.map