import * as fc from 'fast-check';
import type * as T from '@traversable/registry';
import { URI } from '@traversable/registry';
import { Json } from '@traversable/json';
import type { SchemaOptions } from '@traversable/schema';
import { t } from '@traversable/schema';
import type { ArrayBounds, BigIntBounds, ExclusiveBounds, InclusiveBounds, IntegerBounds, NumberBounds, StringBounds } from './bounds.js';
export { type Arbitraries, type Builder, type Constraints, type Fixpoint, type Free, type Nullary, type Positional, type Seed, type SortBias, type SpecialCase, type TypeName, type Unary, integerF as integer, bigintF as bigint, numberF as number, stringF as string, eqF as eq, refF as ref, optionalF as optional, arrayF as array, recordF as record, unionF as union, intersectF as intersect, objectF as object, tupleF as tuple, data, defaults, defineSeed, extensibleArbitrary, fold, fromJsonLiteral, fromSchema, Functor, getBounds, identity, initialOrder, is, isBoundable, isBoundableTag, isAssociative, isNullary, isPositional, isSeed, isSpecialCase, isUnary, laxMax, laxMin, numberConstraintsFromBounds, preprocessInclusiveBounds, parseConstraints, Algebra, schema, schemaWithMinDepth, seed, stringConstraintsFromBounds, arbitraryFromSchema, invalidArbitraryFromSchema, invalidValue, toArbitrary, toInvalidArbitrary, toSchema, toString, unfold, };
declare const invalidValue: any;
interface SeedWithRoot<Root extends keyof Builder, T extends Partial<SeedIR>> extends T.newtype<T> {
    tree: T[keyof T];
    root: fc.Arbitrary<Builder[Root]>;
}
type WithRoot<Root extends keyof Builder, TypeNames extends TypeName> = never | SeedWithRoot<Root, Pick<SeedIR, TypeNames>>;
type SeedIR = {
    eq: fc.Arbitrary<eqF<fc.JsonValue>>;
    array: fc.Arbitrary<arrayF<Fixpoint>>;
    record: fc.Arbitrary<recordF<Fixpoint>>;
    optional: fc.Arbitrary<optionalF<Fixpoint>>;
    tuple: fc.Arbitrary<tupleF<readonly Fixpoint[]>>;
    object: fc.Arbitrary<objectF<[k: string, v: Fixpoint][]>>;
    union: fc.Arbitrary<unionF<Fixpoint[]>>;
    intersect: fc.Arbitrary<intersectF<Fixpoint[]>>;
    never: fc.Arbitrary<neverF>;
    any: fc.Arbitrary<anyF>;
    unknown: fc.Arbitrary<unknownF>;
    void: fc.Arbitrary<voidF>;
    null: fc.Arbitrary<nullF>;
    undefined: fc.Arbitrary<undefinedF>;
    symbol: fc.Arbitrary<symbolF>;
    boolean: fc.Arbitrary<booleanF>;
    integer: fc.Arbitrary<integerF>;
    bigint: fc.Arbitrary<bigintF>;
    number: fc.Arbitrary<numberF>;
    string: fc.Arbitrary<stringF>;
};
export declare const LEAST_UPPER_BOUND = 4294967296;
export declare const GREATEST_LOWER_BOUND = 1e-8;
export declare const isBounded: (x: number) => boolean;
export type UniqueArrayDefaults<T = unknown, U = unknown> = fc.UniqueArrayConstraintsRecommended<T, U>;
declare namespace InferSchema {
    type SchemaMap = {
        [URI.never]: t.never;
        [URI.any]: t.any;
        [URI.unknown]: t.unknown;
        [URI.void]: t.void;
        [URI.null]: t.null;
        [URI.undefined]: t.undefined;
        [URI.boolean]: t.boolean;
        [URI.symbol]: t.symbol;
        [URI.integer]: t.integer;
        [URI.bigint]: t.bigint;
        [URI.number]: t.number;
        [URI.string]: t.string;
        [URI.eq]: t.eq<any>;
        [URI.array]: t.array<any>;
        [URI.optional]: t.optional<any>;
        [URI.record]: t.record<any>;
        [URI.union]: t.union<any>;
        [URI.intersect]: t.intersect<any>;
        [URI.tuple]: t.tuple<any>;
        [URI.object]: t.object<any>;
    };
    type LookupSchema<T> = SchemaMap[(T extends Boundable ? T[0] : T) & keyof SchemaMap];
    type CatchUnknown<T> = unknown extends T ? SchemaMap[keyof SchemaMap] : T;
    type fromFixpoint<T> = CatchUnknown<T extends {
        0: infer Head;
        1: infer Tail;
    } ? [Head, Tail] extends [[URI.integer] | [URI.integer, any], any] ? t.integer : [Head, Tail] extends [URI.eq, any] ? t.eq<any> : [Head, Tail] extends [URI.optional, Fixpoint] ? t.optional<LookupSchema<Tail>> : [Head, Tail] extends [URI.array, Fixpoint] ? t.array<LookupSchema<Tail>> : [Head, Tail] extends [URI.record, Fixpoint] ? t.record<LookupSchema<Tail>> : [Head, Tail] extends [URI.union, Fixpoint[]] ? t.union<{
        [I in keyof Tail]: LookupSchema<Tail[I]>;
    }> : [Head, Tail] extends [URI.intersect, Fixpoint[]] ? t.intersect<{
        [I in keyof Tail]: LookupSchema<Tail[I]>;
    }> : [Head, Tail] extends [URI.tuple, Fixpoint[]] ? t.tuple<{
        [I in keyof Tail]: LookupSchema<Tail[I]>;
    }> : [Head, Tail] extends [URI.object, infer Entries extends [k: string, v: any][]] ? t.object<{
        [E in Entries[number] as E[0]]: LookupSchema<E[1]>;
    }> : LookupSchema<T> : unknown>;
}
/**
 * If you provide a partial weight map, missing properties will fall back to `0`
 */
type SortBias<T> = T.Comparator<keyof T> | {
    [K in keyof T]+?: number;
};
type TypeName = Exclude<keyof Builder, 'tree'>;
declare const initialOrderMap: {
    readonly string: 0;
    readonly number: 1;
    readonly object: 2;
    readonly boolean: 3;
    readonly undefined: 4;
    readonly symbol: 5;
    readonly integer: 6;
    readonly bigint: 7;
    readonly null: 8;
    readonly eq: 9;
    readonly array: 9;
    readonly record: 10;
    readonly optional: 11;
    readonly tuple: 12;
    readonly intersect: 13;
    readonly union: 14;
    readonly any: 15;
    readonly unknown: 16;
    readonly void: 17;
    readonly never: 18;
};
declare const initialOrder: (keyof typeof initialOrderMap)[];
type LibConstraints<Exclude extends TypeName, Include extends TypeName = TypeName, Root extends keyof Builder = keyof Builder> = {
    rootType?: Root;
    minDepth?: number;
    sortBias?: SortBias<Builder>;
    exclude?: Exclude[];
    include?: Include[];
    forceInvalid?: boolean;
};
type ObjectConstraints = {
    min?: number;
    max?: number;
} & Omit<TargetConstraints['object'], 'minLength' | 'maxLength'>;
type Arbitraries = {
    never?: unknown;
    unknown?: unknown;
    void?: unknown;
    any?: unknown;
    undefined?: unknown;
    null?: unknown;
    symbol?: unknown;
    boolean?: unknown;
    integer?: unknown;
    number?: unknown;
    bigint?: unknown;
    string?: unknown;
    eq?(x: unknown, $?: SchemaOptions): unknown;
    ref?(x: unknown, id?: string, $?: SchemaOptions): unknown;
    array?(x: unknown, $?: SchemaOptions): unknown;
    record?(x: unknown, $?: SchemaOptions): unknown;
    optional?(x: unknown, $?: SchemaOptions): unknown;
    union?(x: readonly unknown[], $?: SchemaOptions): unknown;
    intersect?(x: readonly unknown[], $?: SchemaOptions): unknown;
    tuple?(x: readonly unknown[], $?: SchemaOptions): unknown;
    object?(x: {
        [x: string]: unknown;
    }, $?: SchemaOptions): unknown;
};
type Constraints<Exclude extends TypeName, Include extends TypeName = TypeName, Root extends keyof Builder = keyof Builder> = LibConstraints<Exclude, Include, Root> & {
    arbitraries?: Arbitraries;
    integer?: TargetConstraints['integer'];
    bigint?: TargetConstraints['bigint'];
    number?: TargetConstraints['number'];
    string?: TargetConstraints['string'];
    array?: TargetConstraints['array'];
    union?: TargetConstraints['union'];
    intersect?: TargetConstraints['intersect'];
    tree?: TargetConstraints['tree'];
    object?: ObjectConstraints;
    tuple?: TargetConstraints['tuple'];
    eq?: TargetConstraints['eq'];
};
type Seed<F> = Nullary | Boundable | refF<F> | eqF<F> | arrayF<F> | recordF<F> | optionalF<F> | tupleF<readonly F[]> | unionF<readonly F[]> | intersectF<readonly F[]> | objectF<[k: string, v: F][]>;
type Fixpoint = Nullary | Boundable | refF<Fixpoint> | eqF | arrayF<Fixpoint> | recordF<Fixpoint> | optionalF<Fixpoint> | tupleF<readonly Fixpoint[]> | unionF<readonly Fixpoint[]> | intersectF<readonly Fixpoint[]> | objectF<[k: string, v: Fixpoint][]>;
interface Free extends T.HKT {
    [-1]: Seed<this[0]>;
}
type Inductive<S> = [S] extends [infer T extends Nullary] ? T : [S] extends [readonly [Unary, infer T]] ? [tag: S[0], unary: Inductive<T>] : [S] extends [readonly [Positional, infer T extends readonly unknown[]]] ? [S[0], {
    -readonly [Ix in keyof T]: Inductive<T[Ix]>;
}] : [S] extends [readonly [Associative, infer T extends readonly [k: string, v: unknown][]]] ? [S[0], {
    -readonly [Ix in keyof T]: [k: T[Ix][0], v: Inductive<T[Ix][1]>];
}] : T.TypeError<'Expected: Fixpoint'>;
interface Builder {
    never: neverF;
    any: anyF;
    unknown: unknownF;
    void: voidF;
    null: nullF;
    undefined: undefinedF;
    symbol: symbolF;
    boolean: booleanF;
    bigint: bigintF;
    integer: integerF;
    number: numberF;
    string: stringF;
    eq: eqF<Json>;
    array: arrayF<Fixpoint>;
    record: recordF<Fixpoint>;
    optional: optionalF<Fixpoint>;
    tuple: tupleF<readonly Fixpoint[]>;
    union: unionF<readonly Fixpoint[]>;
    intersect: intersectF<readonly Seed.Fixpoint[]>;
    object: objectF<[k: string, Fixpoint][]>;
    tree: Omit<this, 'tree'>[keyof Omit<this, 'tree'>];
}
declare namespace Seed {
    export { Builder, Free, Fixpoint, Inductive, Nullary, };
}
declare const defaults: {
    sortBias: () => number;
    include: ("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "never" | "any" | "unknown" | "void" | "null" | "integer" | "eq" | "array" | "record" | "optional" | "tuple" | "union" | "intersect")[];
    exclude: [];
    forceInvalid: false;
    arbitraries: {};
    minDepth: number;
    rootType: "tree";
    integer: {
        min: number;
        max: number;
    };
    bigint: {
        min: bigint;
        max: bigint;
    };
    number: {
        min: number;
        max: number;
        noNaN: true;
        noDefaultInfinity: true;
    };
    string: {
        min: number;
        max: number;
    };
    array: {
        min: number;
        max: number;
    };
    union: {
        readonly minLength: 2;
        readonly maxLength: 2;
        readonly size: "xsmall";
    };
    intersect: {
        readonly minLength: 1;
        readonly maxLength: 2;
        readonly size: "xsmall";
        readonly depthIdentifier: fc.DepthContext;
    };
    tuple: {
        readonly minLength: 1;
        readonly maxLength: 3;
        readonly size: "xsmall";
        readonly depthIdentifier: fc.DepthContext;
    };
    object: {
        min: number;
        max: number;
        size: "xsmall";
    };
    eq: {
        jsonArbitrary: fc.Arbitrary<fc.JsonValue>;
    };
    tree: {
        readonly maxDepth: 3;
        readonly depthIdentifier: fc.DepthContext;
        readonly depthSize: "xsmall";
        readonly withCrossShrink: false;
    };
};
interface neverF extends T.newtype<URI.never> {
}
interface anyF extends T.newtype<URI.any> {
}
interface unknownF extends T.newtype<URI.unknown> {
}
interface voidF extends T.newtype<URI.void> {
}
interface nullF extends T.newtype<URI.null> {
}
interface undefinedF extends T.newtype<URI.undefined> {
}
interface booleanF extends T.newtype<URI.boolean> {
}
interface symbolF extends T.newtype<URI.symbol> {
}
interface integerF extends T.newtype<[tag: URI.integer, constraints?: IntegerBounds]> {
}
interface bigintF extends T.newtype<[tag: URI.bigint, constraints?: BigIntBounds]> {
}
interface numberF extends T.newtype<[tag: URI.number, constraints?: NumberBounds]> {
}
interface stringF extends T.newtype<[tag: URI.string, constraints?: StringBounds]> {
}
interface arrayF<S> extends T.newtype<[tag: URI.array, def: S, constraints?: ArrayBounds]> {
}
declare function integerF(constraints?: IntegerBounds): integerF;
declare function bigintF(constraints?: BigIntBounds): bigintF;
declare function numberF(constraints?: NumberBounds): numberF;
declare function stringF(constraints?: StringBounds): stringF;
declare function arrayF<S>(def: S, constraints?: ArrayBounds): arrayF<S>;
interface eqF<S = Json> extends T.newtype<[tag: URI.eq, def: S]> {
}
interface refF<S> extends T.newtype<[tag: URI.ref, def: S, id: string]> {
}
interface optionalF<S> extends T.newtype<[tag: URI.optional, def: S]> {
}
interface recordF<S> extends T.newtype<[tag: URI.record, def: S]> {
}
interface objectF<S> extends T.newtype<[tag: URI.object, def: S]> {
}
interface tupleF<S> extends T.newtype<[tag: URI.tuple, def: S]> {
}
interface unionF<S> extends T.newtype<[tag: URI.union, def: S]> {
}
interface intersectF<S> extends T.newtype<[tag: URI.intersect, def: S]> {
}
declare function eqF<V = Json>(def: V): eqF<V>;
declare function refF<S>(def: S, id: string): refF<S>;
declare function optionalF<S>(def: S): optionalF<S>;
declare function recordF<S>(def: S): recordF<S>;
declare function objectF<S extends [k: string, v: unknown][]>(def: readonly [...S]): objectF<[...S]>;
declare function tupleF<S extends readonly unknown[]>(def: readonly [...S]): tupleF<readonly [...S]>;
declare function unionF<S extends readonly unknown[]>(def: readonly [...S]): unionF<readonly [...S]>;
declare function intersectF<S extends readonly unknown[]>(def: readonly [...S]): intersectF<readonly [...S]>;
type Nullary = typeof NullaryTags[number];
declare const NullaryTags: ["@traversable/schema/URI::never", "@traversable/schema/URI::any", "@traversable/schema/URI::unknown", "@traversable/schema/URI::void", "@traversable/schema/URI::undefined", "@traversable/schema/URI::null", "@traversable/schema/URI::boolean", "@traversable/schema/URI::symbol"];
declare const isNullary: (u: unknown) => u is Nullary;
declare const laxMin: (...xs: (number | undefined)[]) => number | undefined;
declare const laxMax: (...xs: (number | undefined)[]) => number | undefined;
declare const preprocessInclusiveBounds: <T>({ minimum, maximum }: InclusiveBounds<T>) => InclusiveBounds<T> | undefined;
type Boundable = integerF | bigintF | numberF | stringF;
type BoundableTag = typeof BoundableTags[number];
declare const BoundableTags: ["@traversable/schema/URI::bigint", "@traversable/schema/URI::integer", "@traversable/schema/URI::number", "@traversable/schema/URI::string"];
declare const isBoundableTag: (u: unknown) => u is BoundableTag;
declare const isBoundable: (u: unknown) => u is Boundable;
type SpecialCase<T = unknown> = [SpecialCaseTag, T];
type SpecialCaseTag = typeof SpecialCaseTags[number];
declare const SpecialCaseTags: ["@traversable/schema/URI::eq"];
declare const isSpecialCase: <T>(u: unknown) => u is SpecialCase<T>;
type Unary<T = unknown> = arrayF<T> | recordF<T> | optionalF<T>;
declare const isUnary: <T>(u: unknown) => u is Unary<T>;
type Positional<T = unknown> = tupleF<T> | unionF<T> | intersectF<T>;
declare const isPositional: <T>(u: unknown) => u is Positional<T>;
type Associative<T = unknown> = [AssociativeTag, [k: string, v: T][]];
type AssociativeTag = typeof AssociativeTags[number];
declare const AssociativeTags: ["@traversable/schema/URI::object"];
declare const isAssociative: <T>(u: unknown) => u is Associative<T>;
declare const isSeed: (u: unknown) => u is unknown;
/**
 * ## {@link is `is`}
 *
 * Type-guard from `unknown` to {@link Seed `Seed`}.
 *
 * The {@link is `is`} function is also an object whose properties narrow
 * to a particular member or subset of members of {@link Seed `Seed`}.
 */
declare function is(u: unknown): boolean;
declare namespace is {
    export var nullary: (u: unknown) => u is Nullary;
    export var unary: <T>(u: unknown) => u is Unary<T>;
    export var positional: <T>(u: unknown) => u is Positional<T>;
    export var associative: <T>(u: unknown) => u is Associative<T>;
    export var special: <T>(u: unknown) => u is SpecialCase<T>;
    export var never: (u: unknown) => u is "@traversable/schema/URI::never";
    export var any: (u: unknown) => u is "@traversable/schema/URI::any";
    export var unknown: (u: unknown) => u is "@traversable/schema/URI::unknown";
    var _a: (u: unknown) => u is "@traversable/schema/URI::void";
    var _b: (u: unknown) => u is "@traversable/schema/URI::null";
    export var undefined: (u: unknown) => u is "@traversable/schema/URI::undefined";
    export var boolean: (u: unknown) => u is "@traversable/schema/URI::boolean";
    export var symbol: (u: unknown) => u is "@traversable/schema/URI::symbol";
    export var string: t.has<[0], t.of<(u: unknown) => u is "@traversable/schema/URI::string">>;
    export var number: t.has<[0], t.of<(u: unknown) => u is "@traversable/schema/URI::number">>;
    export var integer: t.has<[0], t.of<(u: unknown) => u is "@traversable/schema/URI::integer">>;
    export var bigint: t.has<[0], t.of<(u: unknown) => u is "@traversable/schema/URI::bigint">>;
    export var eq: <T>(u: unknown) => u is [tag: URI.eq, def: T];
    export var array: <T>(u: unknown) => u is [tag: URI.array, T];
    export var optional: <T>(u: unknown) => u is [tag: URI.optional, T];
    export var record: <T>(u: unknown) => u is [tag: URI.record, T];
    export var union: <T>(u: unknown) => u is [tag: URI.union, readonly T[]];
    export var intersect: <T>(u: unknown) => u is [tag: URI.intersect, readonly T[]];
    export var tuple: <T>(u: unknown) => u is [tag: URI.tuple, readonly T[]];
    export var object: <T>(u: unknown) => u is [tag: URI.tuple, {
        [x: string]: T;
    }];
    export { _a as void, _b as null };
}
/**
 * Hand-tuned constructor that gives you both more precise and
 * more localized feedback than the TS compiler when you make a mistake
 * in an inline {@link Seed `Seed`} definition.
 *
 * When you're working with deeply nested tuples where only certain sequences
 * are valid constructions, this turns out to be pretty useful / necessary.
 */
declare function defineSeed<T extends Inductive<T>>(seed: T): T;
declare const numberConstraintsFromBounds: (bounds?: InclusiveBounds<number> & ExclusiveBounds<number>) => fc.DoubleConstraints;
declare const stringConstraintsFromBounds: ({ minimum: min, maximum: max }?: InclusiveBounds) => fc.StringConstraints;
declare const Functor: T.Functor<Seed.Free, Seed.Fixpoint>;
type Index = {
    mode: 'INVALID' | 'VALID';
    invalidGeneratedForLevel: boolean;
};
declare const fold: <T>(algebra: T.Algebra<Free, T>) => <S extends Fixpoint>(term: S) => T;
declare const unfold: <T>(coalgebra: T.Coalgebra<Free, T>) => <S extends Fixpoint>(expr: S) => Seed<T>;
type t_Boundable = t.Boundable | t.array<any>;
declare function getBounds(x: t_Boundable): (IntegerBounds & NumberBounds & BigIntBounds & StringBounds) | undefined;
export declare const sortOptionalsLast: (l: unknown, r: unknown) => 1 | 0 | -1;
export declare const pickAndSortNodes: (nodes: readonly TypeName[]) => <Exclude extends TypeName, Include extends TypeName>(constraints?: Pick<TargetConstraints<Exclude, Include>, 'exclude' | 'include' | 'sortBias'>) => TypeName[];
declare function parseConstraints<Exclude extends TypeName, Include extends TypeName, T, U>(constraints?: Constraints<Exclude, Include>): Required<TargetConstraints<Exclude, Include>>;
export declare const toJson: (seed: Seed.Fixpoint) => Json.Fixpoint;
declare const schemaWithMinDepth: <Exclude extends TypeName, Include extends TypeName>(_: Constraints<Exclude, Include, keyof Builder> | undefined, n: number) => fc.Arbitrary<t.never | t.any | t.unknown | t.void | t.null | t.undefined | t.boolean | t.symbol | t.integer | t.bigint | t.number | t.string | t.eq<any> | t.array<any> | t.optional<any> | t.record<any> | t.union<any> | t.intersect<any> | t.tuple<any> | t.object<any>>;
declare function seed<Root extends keyof Builder, Included extends TypeName, Excluded extends TypeName = never, Build = WithRoot<Root, Exclude<Included, Excluded>>>(constraints?: Constraints<Excluded, Included, Root>): (go: fc.LetrecTypedTie<Build>) => Build;
declare namespace Algebra {
    const identity: T.Functor.Algebra<Seed.Free, Seed.Fixpoint>;
    const toExtensibleSchema: (constraints?: Constraints<never>['arbitraries']) => T.Functor.Algebra<Seed.Free, unknown>;
    const toSchema: T.Functor.Algebra<Seed.Free, t.Schema>;
    const fromSchema: T.Functor.Algebra<t.Free, Seed.Fixpoint>;
    const toArbitrary: T.Functor.Algebra<Seed.Free, fc.Arbitrary<unknown>>;
    const arbitraryFromSchema: T.Functor.Algebra<t.Free, fc.Arbitrary<unknown>>;
    const invalidArbitraryFromSchema: T.Functor.Algebra<t.Free, fc.Arbitrary<unknown>>;
    const toInvalidArbitrary: T.Functor.Algebra<Seed.Free, fc.Arbitrary<unknown>>;
    const toString: T.Functor.Algebra<Seed.Free, string>;
    const fromJsonLiteral: T.Functor.Algebra<Json.Free, Seed.Fixpoint>;
}
declare const identity: <S extends Fixpoint>(term: S) => Fixpoint;
declare const toSchema: <T extends Seed<unknown>>(seed: T) => InferSchema.fromFixpoint<T>;
declare const toArbitrary: <S extends Fixpoint>(term: S) => fc.Arbitrary<unknown>;
declare const arbitraryFromSchema: {
    (src: t.F<fc.Arbitrary<unknown>>, ix?: t.Functor.Index | undefined): fc.Arbitrary<unknown>;
    (src: t.Schema<t.LowerBound<unknown>>, ix?: t.Functor.Index | undefined): fc.Arbitrary<unknown>;
    (src: t.F<fc.Arbitrary<unknown>>, ix?: t.Functor.Index | undefined): fc.Arbitrary<unknown>;
};
declare const invalidArbitraryFromSchema: {
    (src: t.F<fc.Arbitrary<unknown>>, ix?: t.Functor.Index | undefined): fc.Arbitrary<unknown>;
    (src: t.Schema<t.LowerBound<unknown>>, ix?: t.Functor.Index | undefined): fc.Arbitrary<unknown>;
    (src: t.F<fc.Arbitrary<unknown>>, ix?: t.Functor.Index | undefined): fc.Arbitrary<unknown>;
};
declare const toInvalidArbitrary: <S extends Fixpoint>(term: S, ix: Index) => fc.Arbitrary<unknown>;
declare const toString: <S extends Fixpoint>(term: S) => string;
declare const fromSchema: <S extends t.Schema<t.LowerBound<unknown>>>(term: S) => Fixpoint;
declare const fromJsonLiteral: <S extends Fixpoint>(term: S) => Fixpoint;
/**
 * ## {@link schema `Seed.schema`}
 *
 * Generates an arbitrary,
 * [pseudo-random](https://en.wikipedia.org/wiki/Pseudorandomness)
 * {@link t `t`} schema.
 *
 * Internally, schemas are generated from a
 * {@link Seed `seed value`}, which is itself generated by a library
 * called [`fast-check`](https://github.com/dubzzz/fast-check).
 */
declare function schema<Include extends TypeName = TypeName, Exclude extends TypeName = never>(constraints?: Constraints<Exclude, Include>): fc.Arbitrary<globalThis.Exclude<t.F<Fixpoint>, {
    tag: `${T.NS}${Exclude}`;
}>>;
declare function schema(constraints?: Constraints<never>): fc.Arbitrary<t.LowerBound>;
declare const extensibleArbitrary: <T>(constraints?: Constraints<never>) => fc.Arbitrary<unknown>;
/**
 * ## {@link data `Seed.data`}
 *
 * Generates an arbitrary,
 * [pseudo-random](https://en.wikipedia.org/wiki/Pseudorandomness)
 * data generator.
 *
 * Internally, schemas are generated from a
 * {@link Seed `seed value`}, which is itself generated by a library
 * called [`fast-check`](https://github.com/dubzzz/fast-check).
 */
declare const data: (constraints?: Constraints<never>) => fc.Arbitrary<unknown>;
export declare const REG_EXP: {
    alphanumeric: RegExp;
    ident: RegExp;
    exponential: RegExp;
};
export declare const floatConstraints: {
    noDefaultInfinity: true;
    min: number;
    max: number;
};
export declare const getExponential: (x: number) => number;
export declare const toFixed: (x: number) => number;
export declare const alphanumeric: fc.Arbitrary<string>;
export declare const int32toFixed: fc.Arbitrary<number>;
export declare const ident: fc.Arbitrary<string>;
export declare const jsonValue: fc.LetrecValue<JsonBuilder>;
export type DefaultSchemas = never | Exclude<t.F<t.Schema>, {
    tag: `${T.NS}${typeof defaults.exclude[number]}`;
}>;
export type Options<TypeName extends t.TypeName = typeof exclude[number]> = {
    rootType?: keyof Builder;
    exclude?: [TypeName] extends [never] ? [] : TypeName[];
    jsonArbitrary?: fc.Arbitrary<JsonValue>;
    minDepth?: number;
};
interface JsonBuilder {
    null: null;
    boolean: boolean;
    number: number;
    string: string;
    array: JsonValue[];
    object: Record<string, JsonValue>;
    tree: JsonValue;
}
type JsonValue = undefined | null | boolean | number | string | JsonValue[] | {
    [x: string]: JsonValue;
};
type ExcludeBy<TypeName extends t.TypeName> = Exclude<t.F<t.Schema>, {
    tag: `${T.NS}${TypeName}`;
}>;
export declare namespace SchemaGenerator {
    export { Options };
}
export declare function SchemaGenerator(): fc.Arbitrary<DefaultSchemas>;
export declare function SchemaGenerator<TypeName extends t.TypeName>(options?: Options<TypeName>): fc.Arbitrary<ExcludeBy<TypeName>>;
export declare const exclude: ["any", "never", "unknown", "void", "intersect", "symbol"];
export declare const generatorDefaults: {
    exclude: ["any", "never", "unknown", "void", "intersect", "symbol"];
    jsonArbitrary: fc.Arbitrary<JsonValue>;
    rootType: "tree";
    minDepth: number;
};
//# sourceMappingURL=seed.d.ts.map