import ts from 'typescript';
import type { Validation, Validator } from './types';
/** A function taking a `Validator` and producing its `TypeNode`. */
type TypeGenerator<V extends Validator = Validator> = (validator: V, references: ReadonlyMap<Validator, string>, isInput: boolean) => ts.TypeNode;
/** The generic constructor of a `Validator` instance. */
type ValidatorConstructor<V extends Validator = Validator> = {
    new (...args: any[]): V;
};
/** Register a `TypeGenerator` function for a `Validator`. */
export declare function registerTypeGenerator<V extends Validator>(validator: V | ValidatorConstructor<V>, generator: TypeGenerator<V>): void;
/**
 * Generate typings (validated or input type) for the given `Validation`s.
 *
 * When `isInput` is `false` (the default) then the _validated_ type will be
 * generated (that is, optional fields with default values will be considered
 * as defined).
 *
 * When `isInput` is `true` then the _input_ type will be generated (that is,
 * optional fields will be considered as optional).
 */
export declare function generateTypes(validations: Record<string, Validation>, isInput?: boolean): string;
/**
 * Generate a full declaration map for the specified validations.
 *
 * The full declaration map will include validated and input types and the
 * declaration of the validator itself. For example:
 *
 * ```ts
 * const testValidator = object({ test: optional(string, 'myValue' ) })
 * generateDeclarations({ testValidator })
 * ```
 *
 * Will result in the following declaration to be emitted:
 *
 * ```ts
 * export type Test: { test: string }
 * export type TestInput: { test?: string }
 * export const testValidator: Validator<Test, TestInput>
 * ```
 */
export declare function generateDeclarations(validations: Record<string, Validation>): string;
export {};