import * as fc from 'fast-check';
import type { SeedMap } from './generator.js';
export type ArrayParams = {
    minLength?: number;
    maxLength?: number;
};
export type IntegerParams = {
    minimum?: number;
    maximum?: number;
    multipleOf?: number;
};
export type NumberParams = {
    minimum?: number;
    maximum?: number;
    minExcluded?: boolean;
    maxExcluded?: boolean;
    multipleOf?: number;
};
export type BigIntParams = {
    minimum?: bigint;
    maximum?: bigint;
    multipleOf?: bigint;
};
export type StringParams = {
    minLength?: number;
    maxLength?: number;
};
export type Params = {
    any?: {};
    array?: ArrayParams;
    bigint?: BigIntParams;
    boolean?: {};
    catch?: {};
    custom?: {};
    date?: {};
    default?: {};
    enum?: {};
    file?: {};
    int?: IntegerParams;
    intersection?: {};
    lazy?: {};
    literal?: {};
    map?: {};
    nan?: {};
    never?: {};
    nonoptional?: {};
    null?: {};
    nullable?: {};
    number?: NumberParams;
    object?: {};
    optional?: {};
    pipe?: {};
    readonly?: {};
    record?: {};
    set?: {};
    string?: StringParams;
    success?: {};
    symbol?: {};
    template_literal?: {};
    transform?: {};
    tuple?: {};
    undefined?: {};
    union?: {};
    unknown?: {};
    void?: {};
    promise?: {};
};
export interface Options<T = never> extends Partial<OptionsBase<T>>, Constraints {
}
export type InferConfigType<S> = S extends Options<infer T> ? T : never;
export interface OptionsBase<T = never, K extends string & keyof T = string & keyof T> {
    include: readonly K[];
    exclude: readonly K[];
    root: '*' | K;
    sortBias: {
        [K in keyof SeedMap]+?: number;
    };
    forceInvalid: boolean;
}
export interface Config<T = never> extends OptionsBase<T>, byTypeName {
}
type StringConstraints = {
    unbounded?: boolean;
} & fc.StringConstraints;
export type Constraints = {
    any?: {};
    array?: {
        minLength?: number;
        maxLength?: number;
        unbounded?: boolean;
    };
    bigint?: {
        min?: undefined | bigint;
        max?: undefined | bigint;
        multipleOf?: bigint | null;
        unbounded?: boolean;
    };
    boolean?: {};
    catch?: {};
    custom?: {};
    date?: {};
    default?: {};
    enum?: {};
    file?: {};
    int?: {
        min?: undefined | number;
        max?: undefined | number;
        multipleOf?: number;
        unbounded?: boolean;
    } & fc.IntegerConstraints;
    intersection?: {};
    lazy?: {};
    literal?: {};
    map?: {};
    nan?: {};
    never?: {};
    nonoptional?: {};
    null?: {};
    nullable?: {};
    number?: {
        min?: undefined | number;
        max?: undefined | number;
        multipleOf?: number;
        unbounded?: boolean;
    } & fc.DoubleConstraints;
    object?: ObjectConstraints;
    optional?: {};
    pipe?: {};
    prefault?: {};
    readonly?: {};
    record?: fc.DictionaryConstraints;
    set?: {};
    string?: StringConstraints;
    success?: {};
    symbol?: {};
    template_literal?: fc.ArrayConstraints;
    transform?: {};
    tuple?: fc.ArrayConstraints;
    undefined?: {};
    union?: fc.ArrayConstraints;
    unknown?: {};
    void?: {};
    promise?: {};
    ['*']?: fc.OneOfConstraints;
};
export interface byTypeName extends Required<Omit<Constraints, 'array' | 'object'>> {
    object: fc.UniqueArrayConstraintsRecommended<[k: string, v: unknown], string>;
    array: fc.IntegerConstraints & {
        unbounded?: boolean;
    };
}
export type ObjectConstraints = Omit<fc.UniqueArrayConstraintsRecommended<[k: string, v: unknown], string>, 'minLength' | 'maxLength'> & {
    minKeys?: number;
    maxKeys?: number;
    size?: fc.SizeForArbitrary;
};
export declare const defaultConstraints: {
    readonly object: {
        minKeys: number;
        maxKeys: number;
        size: "xsmall";
        selector: ([k]: [k: string, v: unknown]) => string;
        comparator: "SameValueZero";
        depthIdentifier: fc.DepthContext;
    };
    readonly any: {};
    readonly array: {
        readonly unbounded: false;
        readonly minLength: 0;
        readonly maxLength: 16;
    };
    readonly bigint: {
        readonly unbounded: false;
        readonly min: never;
        readonly max: never;
        readonly multipleOf: null;
    };
    readonly boolean: {};
    readonly catch: {};
    readonly custom: {};
    readonly date: {};
    readonly default: {};
    readonly enum: {};
    readonly file: {};
    readonly int: {
        readonly unbounded: false;
        readonly min: never;
        readonly max: never;
        readonly multipleOf: number;
    };
    readonly intersection: {};
    readonly lazy: {};
    readonly literal: {};
    readonly map: {};
    readonly nan: {};
    readonly never: {};
    readonly nonoptional: {};
    readonly null: {};
    readonly nullable: {};
    readonly number: {
        readonly unbounded: false;
        readonly min: -65536;
        readonly max: 65536;
        readonly multipleOf: number;
        readonly noNaN: true;
        readonly noDefaultInfinity: true;
        readonly minExcluded: false;
        readonly maxExcluded: false;
        readonly noInteger: false;
    };
    readonly optional: {};
    readonly pipe: {};
    readonly prefault: {};
    readonly readonly: {};
    readonly record: {
        depthIdentifier: fc.DepthContext;
        maxKeys: number;
        minKeys: number;
        noNullPrototype: false;
        size: "xsmall";
    };
    readonly set: {};
    readonly string: {
        unbounded: false;
        minLength: number;
        maxLength: number;
        size: "xsmall";
        unit: "grapheme-ascii";
    };
    readonly success: {};
    readonly symbol: {};
    readonly template_literal: {
        minLength: number;
        maxLength: number;
        depthIdentifier: fc.DepthContext;
        size: "xsmall";
    };
    readonly transform: {};
    readonly tuple: {
        minLength: number;
        maxLength: number;
        size: "xsmall";
        depthIdentifier: fc.DepthContext;
    };
    readonly undefined: {};
    readonly union: {
        depthIdentifier: fc.DepthContext;
        minLength: number;
        maxLength: number;
        size: "xsmall";
    };
    readonly unknown: {};
    readonly void: {};
    readonly promise: {};
    readonly "*": {
        maxDepth: number;
        depthIdentifier: fc.DepthContext;
        depthSize: "xsmall";
        withCrossShrink: true;
    };
};
export declare const unsupportedSchemas: "promise"[];
export declare const defaults: {
    readonly exclude: "promise"[];
    readonly forceInvalid: false;
    readonly include: ("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "map" | "int" | "null" | "void" | "never" | "any" | "unknown" | "date" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "custom")[];
    readonly root: "*";
    readonly sortBias: {
        readonly any: 10;
        readonly boolean: 15;
        readonly date: 20;
        readonly file: 25;
        readonly nan: 30;
        readonly never: 35;
        readonly null: 40;
        readonly symbol: 45;
        readonly undefined: 50;
        readonly unknown: 55;
        readonly void: 60;
        readonly int: 100;
        readonly bigint: 150;
        readonly number: 200;
        readonly string: 250;
        readonly enum: 500;
        readonly literal: 550;
        readonly template_literal: 600;
        readonly array: 1000;
        readonly nonoptional: 1500;
        readonly nullable: 2000;
        readonly optional: 2500;
        readonly readonly: 3000;
        readonly set: 3500;
        readonly success: 4000;
        readonly catch: 5000;
        readonly default: 5500;
        readonly prefault: 5600;
        readonly intersection: 6000;
        readonly map: 6500;
        readonly record: 7000;
        readonly object: 7500;
        readonly tuple: 8000;
        readonly union: 8500;
        readonly pipe: 9000;
        readonly custom: 9500;
        readonly transform: 10000;
        readonly lazy: 10500;
        readonly promise: 100000;
    };
};
export declare function parseOptions<Opts extends Options>(options?: Opts): Config<InferConfigType<Opts>>;
export declare function parseOptions(options?: Options<any>): Config<any>;
export {};
//# sourceMappingURL=generator-options.d.ts.map