import * as fc from 'fast-check';
import type { newtype } from '@traversable/registry';
import { Z } from '@traversable/zod-types';
export declare const defaultDoubleConstraints: {
    noNaN: true;
    noDefaultInfinity: true;
};
export declare const defaults: {
    int: [number, number, null];
    number: [number, number, null, false, false];
    bigint: [bigint, bigint, null];
    string: [number, number];
    array: [number, number];
};
export declare const clampMin: <T extends number | bigint>(min: T, max: T, predicate: (x: T | null) => x is T) => (x: T | null, y: T | null) => T | null;
export declare const clampMax: <T extends number | bigint>(min: T, max: T, predicate: (x: T | null) => x is T) => (x: T | null, y: T | null) => T | null;
export declare const makeInclusiveBounds: <T>(model: fc.Arbitrary<T>) => {
    minimum: fc.Arbitrary<T>;
    maximum: fc.Arbitrary<T>;
};
export { Bounds_int as int };
interface Bounds_int extends newtype<[
    minimum: number | null,
    maximum: number | null,
    multipleOf: number | null
]> {
}
declare const Bounds_int: (model: fc.Arbitrary<number>) => fc.Arbitrary<Bounds_int>;
export { Bounds_bigint as bigint };
interface Bounds_bigint extends newtype<[
    minimum: bigint | null,
    maximum: bigint | null,
    multipleOf: bigint | null
]> {
}
declare const Bounds_bigint: (model: fc.Arbitrary<bigint>) => fc.Arbitrary<Bounds_bigint>;
export { Bounds_string as string };
interface Bounds_string extends newtype<[
    minLength: number | null,
    maxLength: number | null
]> {
}
declare const Bounds_string: (model: fc.Arbitrary<number>) => fc.Arbitrary<Bounds_string>;
export { Bounds_number as number };
interface Bounds_number extends newtype<[
    minimum: number | null,
    maximum: number | null,
    multipleOf: number | null,
    exclusiveMinimum: boolean,
    exclusiveMaximum: boolean
]> {
}
declare const Bounds_number: (model: fc.Arbitrary<number>) => fc.Arbitrary<Bounds_number>;
export { Bounds_array as array };
interface Bounds_array extends newtype<[
    minLength: number | null,
    maxLength: number | null
]> {
}
declare const Bounds_array: (model: fc.Arbitrary<number>) => fc.Arbitrary<Bounds_array>;
export declare const intBoundsToIntegerConstraints: (bounds?: Bounds_int) => fc.IntegerConstraints;
export declare const bigintBoundsToBigIntConstraints: (bounds?: Bounds_bigint) => fc.BigIntConstraints;
export declare const numberBoundsToDoubleConstraints: (bounds?: Bounds_number) => fc.DoubleConstraints;
type NumericConstraints<T> = {
    min?: T;
    max?: T;
    minExcluded?: boolean;
    maxExcluded?: boolean;
};
export declare function bagToConstraints<T>(guard: (x: unknown) => x is T): (bag: Z.NumericBag<T>, $?: {}) => NumericConstraints<T>;
export declare const numberBagToDoubleConstraints: (bag: Z.NumericBag<number>, $?: {}) => NumericConstraints<number>;
export declare const bigintBagToBigintConstraints: (bag: Z.NumericBag<bigint>, $?: fc.BigIntConstraints) => fc.BigIntConstraints;
export declare const integerBagToIntegerConstraints: (bag: Z.NumericBag<number>, $?: fc.IntegerConstraints) => fc.IntegerConstraints;
export declare const stringBagToStringConstraints: (bag: {
    minLength?: number;
    maxLength?: number;
}, $?: fc.StringConstraints) => fc.StringConstraints;
export declare const stringBoundsToStringConstraints: (bounds?: Bounds_string) => fc.StringConstraints;
export declare const arrayBoundsToArrayConstraints: (bounds?: Bounds_array) => fc.ArrayConstraints;
//# sourceMappingURL=generator-bounds.d.ts.map