/** A value that does not fit its schema: path is where ("payload.targetSetpoint.scale"), problem is what. */
export declare class SchemaError extends Error {
    readonly path: string;
    readonly problem: string;
    constructor(path: string, problem: string);
}
export interface Schema<T> {
    /** What the schema accepts, in the words of an error message: "an integer from 0 to 100", "ON | OFF". */
    readonly expects: string;
    /** The checked value. path names it in the error message. */
    parse(input: unknown, path?: string): T;
}
/** A schema that accepts a missing value; s.object() makes its key optional in the inferred type. */
export interface OptionalSchema<T> extends Schema<T | undefined> {
    readonly optional: true;
}
export interface EnumSchema<V> extends Schema<V> {
    readonly values: readonly V[];
}
/** The type a schema produces. */
export type Infer<S> = S extends Schema<infer T> ? T : never;
export type Shape = Record<string, Schema<any>>;
type OptionalKeys<S extends Shape> = {
    [K in keyof S]: S[K] extends OptionalSchema<any> ? K : never;
}[keyof S];
export type InferShape<S extends Shape> = {
    [K in Exclude<keyof S, OptionalKeys<S>>]: Infer<S[K]>;
} & {
    [K in OptionalKeys<S>]?: Infer<S[K]>;
};
export interface NumberRules {
    min?: number;
    max?: number;
    /** Greater than, the bound itself excluded. */
    gt?: number;
    integer?: boolean;
}
export interface Temperature {
    value: number;
    scale: "CELSIUS" | "FAHRENHEIT" | "KELVIN";
}
export interface TimeInterval {
    start?: string;
    end?: string;
    duration?: string;
}
/** The error of a value that is not what a schema expects. */
export declare function mismatch(path: string, expects: string, input: unknown): SchemaError;
/** The path of a key of the object at path. */
export declare const at: (path: string, key: string) => string;
declare function number(rules?: NumberRules): Schema<number>;
declare function string(rules?: {
    min?: number;
    max?: number;
    pattern?: RegExp;
    expects?: string;
}): Schema<string>;
declare function boolean(): Schema<boolean>;
declare function literal<V extends string | number | boolean | null>(value: V): Schema<V>;
declare function enumeration<V extends readonly string[]>(...values: V): EnumSchema<V[number]>;
/** One of a list too long to print in an error message: expects says what the list is. */
declare function oneOf<V extends string>(values: readonly V[], expects: string): EnumSchema<V>;
declare function unknown(): Schema<unknown>;
declare function optional<T>(inner: Schema<T>): OptionalSchema<T>;
declare function nullable<T>(inner: Schema<T>): Schema<T | null>;
declare function array<T>(item: Schema<T>, rules?: {
    min?: number;
    max?: number;
}): Schema<T[]>;
/**
 * An object with the keys of shape. Keys the shape does not name are kept as they are: a field Alexa adds to a
 * directive reaches the handler. unknownKeys "reject" is for what a developer writes, where such a key is a typo.
 */
declare function object<S extends Shape>(shape: S, rules?: {
    unknownKeys?: "keep" | "reject";
}): Schema<InferShape<S>>;
declare function temperature(): Schema<Temperature>;
declare function dateTime(): Schema<string>;
declare function duration(): Schema<string>;
declare function timeInterval(): Schema<TimeInterval>;
export declare const s: {
    string: typeof string;
    number: typeof number;
    boolean: typeof boolean;
    literal: typeof literal;
    enum: typeof enumeration;
    oneOf: typeof oneOf;
    unknown: typeof unknown;
    optional: typeof optional;
    nullable: typeof nullable;
    array: typeof array;
    object: typeof object;
    temperature: typeof temperature;
    dateTime: typeof dateTime;
    duration: typeof duration;
    timeInterval: typeof timeInterval;
};
export {};