import { Buffer } from 'buffer';
import { NamedTypeDefinition, ObjectType, Type } from './reflection-type';
export declare class MakeError extends Error {
    readonly errors: ValidationError[];
    readonly name = "MakeError";
    constructor(errors: ValidationError[]);
}
export interface ErrorGroup {
    groupMessage: string;
    errors: ValidationError[];
}
export interface ValidationError {
    path: Path;
    error: string | ErrorGroup;
}
type Path = ReadonlyArray<string>;
export declare function validationErrorPrinter(error: ValidationError, indentation?: number): string;
export declare class Make<V> {
    static ok<V>(value: V): Make<V>;
    static error<V>(errors: ValidationError[]): Make<V>;
    readonly errors: ValidationError[];
    private readonly value;
    private constructor();
    isError(): boolean;
    isSuccess(): boolean;
    success(handler?: (e: this) => V): V;
    group(groupMessage: string): Make<null>;
    errorPath(path: string): Make<null>;
    map<R>(fn: (value: V) => R): Make<R>;
}
export interface MakeOptions {
    /**
     * if 'true' merge types between successive '.make' calls for the object
     * RECOMMEND not to set this unless you have thought things through
     */
    mergeTypes?: boolean;
    unknownField?: 'drop' | 'fail';
    /**
     * If enabled, "number" ans "integer" schemas will accept strings and try to parse them.
     */
    parseNumericStrings?: boolean;
    /**
     * If enabled, "boolean" schemas will accept strings and try to parse them.
     */
    parseBooleanStrings?: boolean;
    /**
     * If enabled, "array" schema will convert any non-array value to an array with a single element.
     * Useful for supporting arrays in query parameters
     * (if query parameter is not repeated, it will not be an array on server side).
     */
    allowConvertForArrayType?: boolean;
    /** If true convert property names from network to ts format while parsing objects */
    convertFromNetwork?: boolean;
}
export type Maker<Shape, V> = (value: Shape, opts?: MakeOptions) => Make<V>;
export declare function registerFormat(format: string, maker: Maker<any, undefined>): void;
export declare function makeString(format?: string, pattern?: string, minLength?: number, maxLength?: number): Maker<any, string>;
export declare function makeNumber(min?: number, max?: number): Maker<unknown, number>;
export declare function makeInteger(min?: number, max?: number): Maker<unknown, number>;
declare function checkAny(value: any, opts?: MakeOptions): Make<any>;
export declare function makeAny(): typeof checkAny;
declare function checkVoid(value: any): Make<any>;
export declare function makeVoid(): typeof checkVoid;
export declare function makeEnum<T>(...args: T[]): (value: T) => Make<T>;
export declare function makeOptional(maker: any): {
    optional: any;
};
export declare function makeBoolean(): Maker<unknown, boolean>;
export declare function makeArray(maker: any, minSize?: number, maxSize?: number): Maker<unknown, unknown[]>;
export declare function makeOneOf(...options: any[]): (value: any, opts?: MakeOptions) => any;
export declare function makeAllOf(...all: Maker<any, any>[]): (value: any, opts?: MakeOptions) => Make<any>;
export declare function makeObject<P extends {
    [key: string]: Maker<any, any> | {
        optional: Maker<any, any>;
    };
}>(props: P, additionalProp?: Maker<any, any> | undefined, comparisorOrder?: string[], type?: ObjectType): (value: any, opts?: MakeOptions) => Make<any>;
interface FormDataArguments {
    value: any;
    options: string | undefined | {
        [key: string]: string;
    };
}
export type Binary = File | Buffer | FormBinary;
export declare class FormBinary {
    readonly binary: Binary;
    readonly options?: FormDataArguments['options'];
    constructor(binary: Binary, options?: FormDataArguments['options']);
}
export declare class File {
    readonly path: string;
    readonly size: number;
    readonly name?: string | undefined;
    private brand;
    constructor(path: string, size: number, name?: string | undefined);
}
declare function checkBinary(value: any): Make<any>;
export declare function makeBinary(): typeof checkBinary;
export declare function makeNullable(maker: any): (value: any, opts?: MakeOptions) => any;
export declare function fromReflection(type: Type): Maker<any, any>;
export declare function createMaker<Shape, Type>(fun: () => any): (value: Shape, opts?: MakeOptions) => Make<Type>;
export declare function createMakerWith<Shape, Type>(constructor: new (v: Shape, opts?: MakeOptions) => Type): Maker<Shape, Type>;
/**
 * Merge multiple mappings into one set of mappings
 *
 * Throw error if there are duplicate koys
 * @deprecated
 */
export declare function mergeMappings(...mappings: readonly {
    [key: string]: Maker<any, any>;
}[]): {
    [key: string]: Maker<any, any>;
};
export declare function extractDiscriminatorKeys(discriminatorField: string, typeObjectRef: Type): string[];
/** @deprecated */
export declare function extractDiscriminatorValueMap(discriminatorField: string, typeObject: NamedTypeDefinition<any>): {
    [key: string]: Maker<any, any>;
};
/**
 * Make oneOf with the discriminator support
 *
 * Will use given mapping to find correct maker. If optional importedTypes are provided, will extract
 * extra mapping keys from them.
 *
 * @deprecated
 *
 * @param discriminatorField Field to use as discriminator
 * @param mapping Mappings that we should use to determine target makers
 * @param importedTypes Optional types where we should extract enum values for makers
 */
export declare function makeOneOfWithDiscriminator(discriminatorField: string, mapping: {
    [key: string]: Maker<any, any>;
}, importedTypes?: readonly any[]): (value: any, opts?: MakeOptions) => Make<any>;
export {};