import * as fc from 'fast-check';
import * as F from '@traversable/zod-types';
import { z } from 'zod';
export type CatchAllConstraints = fc.DictionaryConstraints;
export type RestConstraints = fc.ArrayConstraints;
export type AnyConstraints = fc.ObjectConstraints;
export type ArrayConstraints = fc.ArrayConstraints;
export type BigIntConstraints = fc.BigIntConstraints;
export type CatchConstraints = fc.OneOfConstraints;
export type DateConstraints = fc.DateConstraints;
export type DefaultConstraints = fc.OneOfConstraints;
export type EnumConstraints = fc.OneOfConstraints & fc.StringConstraints & fc.IntegerConstraints;
export type FileConstraints = fc.WebUrlConstraints & fc.IntArrayConstraints & fc.ArrayConstraints;
export type IntegerConstraints = fc.IntegerConstraints;
export type LiteralConstraints = fc.StringConstraints;
export type MapConstraints = {
    minItems?: number;
    maxItems?: number;
};
export type NumberConstraints = fc.DoubleConstraints;
export type ObjectConstraints = CatchAllConstraints;
export type PipeConstraints = fc.OneOfConstraints;
export type PrefaultConstraints = fc.OneOfConstraints;
export type RecordConstraints = fc.DictionaryConstraints;
export type SetConstraints = {
    minItems?: number;
    maxItems?: number;
};
export type StringConstraints = fc.StringConstraints;
export type SymbolConstraints = fc.StringConstraints & {
    uniqueSymbol?: boolean;
};
export type TemplateLiteralConstraints = fc.StringMatchingConstraints;
export type TupleConstraints = RestConstraints;
export type UnionConstraints = fc.OneOfConstraints & {
    minMembers?: number;
    maxMembers?: number;
};
export type UnknownConstraints = fc.ObjectConstraints;
export type Options = {
    any?: AnyConstraints;
    array?: ArrayConstraints;
    bigint?: BigIntConstraints;
    boolean?: never;
    catch?: CatchConstraints;
    custom?: never;
    date?: DateConstraints;
    default?: DefaultConstraints;
    enum?: EnumConstraints;
    file?: FileConstraints;
    int?: IntegerConstraints;
    intersection?: never;
    lazy?: never;
    literal?: LiteralConstraints;
    map?: MapConstraints;
    nan?: never;
    never?: never;
    nonoptional?: never;
    null?: never;
    nullable?: never;
    number?: NumberConstraints;
    object?: ObjectConstraints;
    optional?: never;
    pipe?: PipeConstraints;
    prefault?: PrefaultConstraints;
    promise?: never;
    readonly?: never;
    record?: RecordConstraints;
    set?: SetConstraints;
    string?: StringConstraints;
    success?: never;
    symbol?: SymbolConstraints;
    template_literal?: TemplateLiteralConstraints;
    transform?: never;
    tuple?: TupleConstraints;
    undefined?: never;
    union?: UnionConstraints;
    unknown?: UnknownConstraints;
    void?: never;
};
export type Override<K extends F.AnyTypeName> = (traversed: F.Z.Lookup<K, fc.Arbitrary<unknown>>, options?: Options[K]) => fc.Arbitrary<z.infer<F.Z.ZodLookup<K>>>;
export type Overrides = {
    [K in keyof F.Z.Catalog]+?: Override<K>;
};
export declare namespace fuzz {
    export { Options, Override, Overrides, CatchAllConstraints, RestConstraints, AnyConstraints, ArrayConstraints, BigIntConstraints, CatchConstraints, DateConstraints, DefaultConstraints, EnumConstraints, FileConstraints, IntegerConstraints, LiteralConstraints, MapConstraints, NumberConstraints, ObjectConstraints, PipeConstraints, PrefaultConstraints, RecordConstraints, SetConstraints, StringConstraints, SymbolConstraints, TemplateLiteralConstraints, TupleConstraints, UnionConstraints, UnknownConstraints, };
}
/**
 * ## {@link fuzz `zxTest.fuzz`}
 *
 * Convert a Zod schema into a [fast-check](https://github.com/dubzzz/fast-check) arbitrary.
 *
 * Configure how fuzzed values will be generated via type {@link options `options`} argument.
 *
 * Override individual arbitraries via the {@link overrides `overrides`} argument.
 *
 * **Note:** {@link fuzz `zxTest.fuzz`} is the __only__ schema-to-generator function that has itself
 * been fuzz tested to ensure that no matter what schema you give it, the data-generator that `fuzz`
 * returns will always produce valid data.
 *
 * The only known exceptions are schemas that make it impossible to generate valid data. For example:
 *
 * - `z.never`
 * - `z.nonoptional(z.undefined())`
 * - `z.enum([])`
 * - `z.union([])`
 * - `z.intersection(z.number(), z.string())`
 *
 * See also:
 * - {@link Options `fuzz.Options`}
 * - {@link Overrides `fuzz.Overrides`}
 * - the [fast-check docs](https://fast-check.dev)
 *
 * @example
 * import * as vi from 'vitest'
 * import * as fc from 'fast-check' * import { fuzz } from '@traversable/zod-test'
 *
 * const Schema = z.record(
 *   z.string(),
 *   z.union(
 *     z.number(),
 *     z.string(),
 *   )
 * )
 *
 * const generator = fuzz(
 *   Schema,
 *   { record: { minKeys: 1 }, number: { noDefaultInfinity: true } },
 *   { string: () => fc.stringMatching(/[\S\s]+[\S]+/) },
 * )
 *
 * vi.test('fuzz test example', () => {
 *   fc.assert(
 *     fc.property(generator, (data) => {
 *       vi.assert.doesNotThrow(() => Schema.parse(data))
 *     }),
 *     { numRuns: 1_000 }
 *   )
 * })
 */
export declare function fuzz<T>(type: z.ZodType<T>, options?: fuzz.Options, overrides?: fuzz.Overrides): fc.Arbitrary<T>;
export declare namespace fuzz {
    var unfuzzable: readonly ["custom", "default", "prefault", "promise", "pipe", "nonoptional", "never"];
}
//# sourceMappingURL=fuzz.d.ts.map