export interface Meta {
    description?: string;
    title?: string;
    /** What `check` says when this value is wrong. */
    message?: string;
}
/** A JSON-Schema-shaped object; `T` is the TypeScript type of the values it accepts (never present at run time). */
export interface Schema<T = unknown> extends Meta {
    readonly "~type": T;
    type?: "string" | "number" | "integer" | "boolean" | "null" | "array" | "object";
    const?: string | number | boolean;
    enum?: string[];
    anyOf?: Schema[];
    items?: Schema;
    properties?: Record<string, Schema>;
    required?: string[];
    additionalProperties?: Schema;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    minimum?: number;
    maximum?: number;
    minItems?: number;
    maxItems?: number;
    /** M76: `check` passes any value (no check today: a bad one is dropped where it is read). */
    "x-loose"?: true;
    /** M76: the limits apply to the value trimmed (the daemon trims it first). */
    "x-trim"?: true;
    /** M76: maxLength is not refused here: the daemon cuts the value ("cut"), or the op refuses it with its own code ("op"). */
    "x-max"?: "cut" | "op";
    /** M76: a union picked by this field alone; another value fails with the union's message. */
    "x-discriminant"?: string;
    /** M77: `check` asks only that the value be an object (an array too); its fields are the op's to check. */
    "x-shallow"?: true;
}
export type Infer<S> = S extends Schema<infer T> ? T : never;
declare const OPTIONAL: unique symbol;
/** A field that may be left out (see `optional`). */
export interface OptionalField<S extends Schema = Schema> {
    readonly [OPTIONAL]: true;
    readonly schema: S;
}
type Field = Schema | OptionalField;
type Fields = Record<string, Field>;
type Plain<F> = F extends OptionalField<infer S> ? S : F;
type Flat<T> = {
    [K in keyof T]: T[K];
} & {};
type ObjectOf<P extends Fields> = Flat<{
    [K in keyof P as P[K] extends OptionalField ? never : K]: Infer<Plain<P[K]>>;
} & {
    [K in keyof P as P[K] extends OptionalField ? K : never]?: Infer<Plain<P[K]>>;
}>;
export declare const str: (o?: Meta & {
    min?: number;
    max?: number;
    pattern?: string;
    trim?: boolean;
    maxBy?: "cut" | "op";
}) => Schema<string>;
export declare const num: (o?: Meta & {
    int?: boolean;
    min?: number;
    max?: number;
}) => Schema<number>;
export declare const bool: (o?: Meta) => Schema<boolean>;
export declare const nul: (o?: Meta) => Schema<null>;
export declare const literal: <const V extends string | number | boolean>(v: V, o?: Meta) => Schema<V>;
/** A string that is one of these. */
export declare const oneOf: <const V extends string>(values: readonly V[], o?: Meta) => Schema<V>;
/** Plain, or discriminated by a literal field (`check` then reports the matching member's error). */
export declare const union: <const M extends readonly Schema[]>(members: M, o?: Meta & {
    discriminant?: string;
}) => Schema<Infer<M[number]>>;
/** M76: the same schema (its type, its doc), not checked: a bad value is dropped where the daemon reads it. */
export declare const loose: <S extends Schema>(s: S) => S;
/** The schema a loose (or shallow, or relaxed) one was made from (the doc names a shared shape by it). */
export declare const looseOf: WeakMap<Schema<unknown>, Schema<unknown>>;
/** M77: the same schema, checked only for being an object (an array passes, as `typeof` let it), in these words. */
export declare const shallow: <S extends Schema>(s: S, o?: Meta) => S;
/** M77: an object schema whose fields are loose, but a literal one (a union's discriminant) and those given in `keep` (in their place). */
export declare const relax: <S extends Schema>(s: S, keep?: Record<string, Schema>, o?: Meta) => S;
/** M77: a schema as plain JSON Schema for a tool's parameters: without `message` and the `x-` marks; a maximum the daemon cuts is left out. */
export declare function jsonSchemaOf(s: Schema): Record<string, unknown>;
export declare const nullable: <S extends Schema>(s: S, o?: Meta) => Schema<Infer<S> | null>;
export declare const arr: <S extends Schema>(item: S, o?: Meta & {
    min?: number;
    max?: number;
}) => Schema<Infer<S>[]>;
/** A string-keyed record. */
export declare const rec: <S extends Schema>(value: S, o?: Meta) => Schema<Record<string, Infer<S>>>;
export declare const optional: <S extends Schema>(schema: S) => OptionalField<S>;
export declare const obj: <P extends Fields>(fields: P, o?: Meta) => Schema<ObjectOf<P>>;
/** An object with no fields (`Record<string, never>`); like `obj({})` to `check`: other keys are ignored. */
export declare const empty: (o?: Meta) => Schema<Record<string, never>>;
/** A type another module owns (its interface stays there): checked only as an object. */
export declare const opaque: <T>(title: string, description: string) => Schema<T>;
/** Anything. */
export declare const unknown: (o?: Meta) => Schema<unknown>;
export type CheckResult = {
    ok: true;
} | {
    ok: false;
    path: string;
    message: string;
};
/** Whether `value` is what `schema` says; the first failure's path ("launch.env", "ids[2]") and message. Unknown fields are ignored. */
export declare function check(schema: Schema, value: unknown, path?: string): CheckResult;
/** The values a discriminated union's members take on `key`, in their order. */
export declare function discriminantValues(union: Schema, key: string): string[];
export {};