declare const TYPE: unique symbol;
/** A schema built by `oneOf`, `listOf`, `setOf`, `recordOf`, `nullable` or `type`. */
export interface Shaped<T> {
    readonly schema: "oneOf" | "list" | "set" | "record" | "nullable" | "type";
    /** Phantom: the type it describes. */
    readonly [TYPE]?: T;
}
/** A schema: a constructor, a nested object of schemas, or one built by the functions below. */
export type Schema = StringConstructor | NumberConstructor | BooleanConstructor | Shaped<unknown> | {
    readonly [field: string]: Schema;
};
/** An object of field schemas: a payload's schema. */
export type Fields = {
    readonly [field: string]: Schema;
};
/** The type a schema describes. */
export type TypeOf<S> = S extends StringConstructor ? string : S extends NumberConstructor ? number : S extends BooleanConstructor ? boolean : S extends Shaped<infer T> ? T : S extends {
    readonly [field: string]: Schema;
} ? {
    -readonly [K in keyof S]: TypeOf<S[K]>;
} : never;
interface OneOf<T> extends Shaped<T> {
    readonly schema: "oneOf";
    readonly values: readonly T[];
}
interface Of<T> extends Shaped<T> {
    readonly schema: "list" | "set" | "record" | "nullable";
    readonly of: Schema;
}
/** One of these values: `oneOf("yes", "no")` is `"yes" | "no"`. */
export declare function oneOf<const T extends string | number | boolean>(...values: T[]): OneOf<T>;
/** A list: `listOf(String)` is `string[]`. */
export declare function listOf<S extends Schema>(item: S): Of<TypeOf<S>[]>;
/** A set: `setOf(String)` is `Set<string>`. */
export declare function setOf<S extends Schema>(item: S): Of<Set<TypeOf<S>>>;
/** A record keyed by strings: `recordOf(Number)` is `Record<string, number>`. */
export declare function recordOf<S extends Schema>(value: S): Of<Record<string, TypeOf<S>>>;
/** The schema's type, or null. */
export declare function nullable<S extends Schema>(of: S): Of<TypeOf<S> | null>;
/** Any TypeScript type, for what a schema can't say. It is not checked at run time. */
export declare function type<T>(): Shaped<T>;
export declare function isSchema(value: unknown): value is Schema;
/**
 * Where `value` doesn't match `schema`, in words ("payment: 1, but its schema says string"),
 * or null when it matches. Objects must have exactly their schema's fields.
 */
export declare function mismatch(schema: Schema, value: unknown, path?: string): string | null;
/** A schema in words, for the views: `{ socket: number, chains: string[] }`. */
export declare function describeSchema(schema: Schema): string;
export {};