import { z } from 'zod';
import type * as T from '@traversable/registry';
import * as Bounds from './generator-bounds.js';
export type Tag = byTag[keyof byTag];
export type byTag = typeof byTag;
export declare const byTag: {
    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;
    /** @deprecated */
    readonly promise: 100000;
};
export declare function invert<T extends Record<keyof any, keyof any>>(x: T): {
    [K in keyof T as T[K]]: K;
};
export type bySeed = typeof bySeed;
export declare const bySeed: {
    readonly 10: "any";
    readonly 15: "boolean";
    readonly 20: "date";
    readonly 25: "file";
    readonly 30: "nan";
    readonly 35: "never";
    readonly 40: "null";
    readonly 45: "symbol";
    readonly 50: "undefined";
    readonly 55: "unknown";
    readonly 60: "void";
    readonly 100: "int";
    readonly 150: "bigint";
    readonly 200: "number";
    readonly 250: "string";
    readonly 500: "enum";
    readonly 550: "literal";
    readonly 600: "template_literal";
    readonly 1000: "array";
    readonly 1500: "nonoptional";
    readonly 2000: "nullable";
    readonly 2500: "optional";
    readonly 3000: "readonly";
    readonly 3500: "set";
    readonly 4000: "success";
    readonly 5000: "catch";
    readonly 5500: "default";
    readonly 5600: "prefault";
    readonly 6000: "intersection";
    readonly 6500: "map";
    readonly 7000: "record";
    readonly 7500: "object";
    readonly 8000: "tuple";
    readonly 8500: "union";
    readonly 9000: "pipe";
    readonly 9500: "custom";
    readonly 10000: "transform";
    readonly 10500: "lazy";
    readonly 100000: "promise";
};
export type Seed<T = unknown> = Seed.TerminalMap & Seed.BoundableMap & Seed.ValueMap & Seed.UnaryMap<T>;
export declare namespace Seed {
    type Fixpoint = [
        tag: Tag,
        children?: unknown,
        bounds?: Seed.Array<never>[2]
    ];
    type F<T> = Seed.Nullary | Seed.Unary<T>;
    type Nullary = Seed.Terminal | Seed.Boundable | Seed.Value;
    type Unary<T> = Seed.Array<T> | Seed.Record<T> | Seed.Object<T> | Seed.Tuple<T> | Seed.Union<T> | Seed.NonOptional<T> | Seed.Optional<T> | Seed.Nullable<T> | Seed.Readonly<T> | Seed.Set<T> | Seed.Success<T> | Seed.Catch<T> | Seed.Default<T> | Seed.Prefault<T> | Seed.Map<T> | Seed.Pipe<T> | Seed.Custom<T> | Seed.Transform<T> | Seed.Lazy<T> | Seed.Intersection<T> | Seed.Promise<T>;
    interface Free extends T.HKT {
        [-1]: Seed.F<this[0]>;
    }
    type Any = [any: byTag['any']];
    type Boolean = [boolean: byTag['boolean']];
    type Date = [date: byTag['date']];
    type File = [file: byTag['file']];
    type NaN = [NaN: byTag['nan']];
    type Never = [never: byTag['never']];
    type Null = [null: byTag['null']];
    type Symbol = [symbol: byTag['symbol']];
    type Undefined = [undefined: byTag['undefined']];
    type Unknown = [unknown: byTag['unknown']];
    type Void = [void: byTag['void']];
    type Terminal = TerminalMap[keyof TerminalMap];
    type TerminalMap = {
        any: Any;
        boolean: Boolean;
        date: Date;
        file: File;
        nan: NaN;
        never: Never;
        null: Null;
        symbol: Symbol;
        undefined: Undefined;
        unknown: Unknown;
        void: Void;
    };
    type Integer = [int: byTag['int'], bounds?: Bounds.int];
    type BigInt = [bigint: byTag['bigint'], bounds?: Bounds.bigint];
    type Number = [number: byTag['number'], bounds?: Bounds.number];
    type String = [string: byTag['string'], bounds?: Bounds.string];
    type Boundable = BoundableMap[keyof BoundableMap];
    type BoundableMap = {
        int: Integer;
        bigint: BigInt;
        number: Number;
        string: String;
    };
    type Enum = [enum_: byTag['enum'], value: {
        [x: string]: number | string;
    }];
    type Literal = [literal: byTag['literal'], value: z.core.util.Literal];
    type TemplateLiteral = [templateLiteral: byTag['template_literal'], value: TemplateLiteral.Node[]];
    namespace TemplateLiteral {
        type Node = T.Showable | Seed.Boolean | Seed.Null | Seed.Undefined | Seed.Integer | Seed.Number | Seed.BigInt | Seed.String | Seed.Literal | Seed.Nullable | Seed.Optional;
    }
    type Value = ValueMap[keyof ValueMap];
    type ValueMap = {
        enum: Enum;
        literal: Literal;
        template_literal: TemplateLiteral;
    };
    type Array<T = unknown> = [array: byTag['array'], element: T, bounds?: Bounds.array];
    type NonOptional<T = unknown> = [nonOptional: byTag['nonoptional'], innerType: T];
    type Optional<T = unknown> = [optional: byTag['optional'], innerType: T];
    type Nullable<T = unknown> = [nullable: byTag['nullable'], innerType: T];
    type Readonly<T = unknown> = [readonly: byTag['readonly'], innerType: T];
    type Set<T = unknown> = [set: byTag['set'], valueType: T];
    type Success<T = unknown> = [success: byTag['success'], innerType: T];
    type Catch<T = unknown> = [catch_: byTag['catch'], innerType: T];
    type Default<T = unknown> = [default_: byTag['default'], innerType: T];
    type Prefault<T = unknown> = [prefault: byTag['prefault'], innerType: T];
    type UnaryMap<T = unknown> = {
        array: Seed.Array<T>;
        record: Seed.Record<T>;
        object: Seed.Object<T>;
        tuple: Seed.Tuple<T>;
        union: Seed.Union<T>;
        nonoptional: Seed.NonOptional<T>;
        optional: Seed.Optional<T>;
        nullable: Seed.Nullable<T>;
        readonly: Seed.Readonly<T>;
        set: Seed.Set<T>;
        success: Seed.Success<T>;
        catch: Seed.Catch<T>;
        default: Seed.Default<T>;
        prefault: Seed.Prefault<T>;
        map: Seed.Map<T>;
        pipe: Seed.Pipe<T>;
        custom: Seed.Custom<T>;
        transform: Seed.Transform<T>;
        lazy: Seed.Lazy<T>;
        intersection: Seed.Intersection<T>;
        promise: Seed.Promise<T>;
    };
    type Composite = Seed.Array | Seed.Record | Seed.Object | Seed.Tuple;
    type fromComposite = {
        [byTag.array]: unknown[];
        [byTag.record]: globalThis.Record<string, unknown>;
        [byTag.object]: {
            [x: string]: unknown;
        };
        [byTag.tuple]: unknown[];
    };
    type schemaFromComposite = {
        [byTag.array]: z.ZodArray;
        [byTag.record]: z.ZodRecord;
        [byTag.object]: z.ZodObject;
        [byTag.tuple]: z.ZodTuple;
    };
    type Object<T = unknown> = [object: byTag['object'], shape: [K: string, V: T][]];
    type Union<T = unknown> = [union: byTag['union'], members: T[]];
    type Tuple<T = unknown> = [tuple: byTag['tuple'], items: T[]];
    type Map<T = unknown> = [map: byTag['map'], def: [keyType: T, valueType: T]];
    type Record<T = unknown> = [record: byTag['record'], valueType: T];
    type Intersection<T = unknown> = [intersection: byTag['intersection'], def: [left: T, right: T]];
    type Pipe<T = unknown> = [pipe: byTag['pipe'], def: [in_: T, out: T]];
    type Custom<T = unknown> = [custom: byTag['custom'], def: T];
    type Transform<T = unknown> = [transform: byTag['transform'], def: T];
    type Lazy<T = unknown> = [lazy: byTag['lazy'], getter: () => T];
    /** @deprecated */
    type Promise<T = unknown> = [promise: byTag['promise'], innerType: T];
}
export declare const Functor: T.Functor.Ix<boolean, Seed.Free, Seed.F<any>>;
export declare const fold: <T>(g: (src: Seed.F<T>, ix: boolean, x: Seed.F<any>) => T) => {
    (src: Seed.F<T>, ix?: boolean | undefined): T;
    (src: Seed.F<any>, ix?: boolean | undefined): T;
    (src: Seed.F<T>, ix?: boolean | undefined): T;
};
//# sourceMappingURL=generator-seed.d.ts.map