import type { Returns, Join, Showable, UnionToTuple } from '@traversable/registry';
import { symbol } from '@traversable/registry';
import { t } from '@traversable/schema';
export { neverToString as never, unknownToString as unknown, anyToString as any, voidToString as void, nullToString as null, undefinedToString as undefined, symbolToString as symbol, booleanToString as boolean, integerToString as integer, bigintToString as bigint, numberToString as number, stringToString as string, eqToString as eq, refToString as ref, arrayToString as array, recordToString as record, unionToString as union, intersectToString as intersect, optionalToString as optional, tupleToString as tuple, objectToString as object, };
declare const Symbol_optional: typeof symbol.optional;
export declare function toType(x: unknown): string;
export declare namespace toType {
    export var eq: <S>(x: S) => toType.eq<S>;
    export var ref: <Id>(id: Id) => toType.ref<Id>;
    export var intersect: <S>(xs: S) => toType.intersect<S>;
    export var union: <S>(xs: S) => toType.union<S>;
    export var record: <S>(x: S) => toType.record<S>;
    export var tuple: <S>(xs: S) => toType.tuple<S>;
    export var optional: <S>(x: S) => toType.optional<S>;
    export var array: <S>(x: S) => toType.array<S>;
    export var object: <S, _ = UnionToTuple<keyof S>>(xs: S) => toType.object<S, _>;
    export var never: "never";
    export var unknown: "unknown";
    export var any: "any";
    var _a: "void";
    export var undefined: "undefined";
    var _b: "null";
    export var symbol: "symbol";
    export var boolean: "boolean";
    export var integer: "number";
    export var number: "number";
    export var bigint: "bigint";
    export var string: "string";
    export { _a as void, _b as null };
}
export declare namespace toType {
    export type eq<T, _ extends string = [T] extends [Showable] ? `${T}` : never> = [_] extends [never] ? [T] extends [symbol] ? 'symbol' : string : [T] extends [string] ? `'${_}'` : _;
    export type ref<Id> = `${Id & string}`;
    export type intersect<T> = never | [T] extends [readonly []] ? 'unknown' : `(${Join<{
        [I in keyof T]: Returns<T[I]['toType']>;
    }, ' & '>})`;
    export type union<T> = never | [T] extends [readonly []] ? 'never' : `(${Join<{
        [I in keyof T]: Returns<T[I]['toType']>;
    }, ' | '>})`;
    /** @ts-expect-error */
    export type record<T> = never | `Record<string, ${Returns<T['toType']>}>`;
    export type tuple<T> = never | `[${Join<{
        [I in keyof T]: `${
        /** @ts-expect-error */
        T[I] extends {
            [Symbol_optional]: any;
        } ? `_?: ${Returns<T[I]['toType']>}` : Returns<T[I]['toType']>}`;
    }, ', '>}]`;
    /** @ts-expect-error */
    export type optional<T> = never | `(${Returns<T['toType']>} | undefined)`;
    /** @ts-expect-error */
    export type array<T> = `(${Returns<T['toType']>})[]`;
    export { object_ as object };
    export type object_<T, _ = UnionToTuple<keyof T>> = never | [keyof T] extends [never] ? '{}' : `{ ${Join<{
        [I in keyof _]: `'${_[I]}${T[_[I]] extends {
            [Symbol_optional]: any;
        } ? `'?` : `'`}: ${Returns<T[_[I]]['toType']>}`;
    }, ', '>} }`;
}
interface neverToString {
    toType(): typeof toType.never;
}
interface unknownToString {
    toType(): typeof toType.unknown;
}
interface anyToString {
    toType(): typeof toType.any;
}
interface voidToString {
    toType(): typeof toType.void;
}
interface nullToString {
    toType(): typeof toType.null;
}
interface undefinedToString {
    toType(): typeof toType.undefined;
}
interface bigintToString {
    toType(): typeof toType.bigint;
}
interface symbolToString {
    toType(): typeof toType.symbol;
}
interface booleanToString {
    toType(): typeof toType.boolean;
}
interface integerToString {
    toType(): typeof toType.integer;
}
interface numberToString {
    toType(): typeof toType.number;
}
interface stringToString {
    toType(): typeof toType.string;
}
declare function neverToString(): "never";
declare function unknownToString(): "unknown";
declare function anyToString(): "any";
declare function voidToString(): "void";
declare function undefinedToString(): "undefined";
declare function nullToString(): "null";
declare function symbolToString(): "symbol";
declare function booleanToString(): "boolean";
declare function integerToString(): "number";
declare function bigintToString(): "bigint";
declare function numberToString(): "number";
declare function stringToString(): "string";
interface eqToString<V = unknown> {
    toType(): Returns<typeof toType.eq<V>>;
}
interface refToString<S, Id> {
    toType(): Returns<typeof toType.ref<Id>>;
}
interface arrayToString<S> {
    toType(): Returns<typeof toType.array<S>>;
}
interface optionalToString<S> {
    toType(): Returns<typeof toType.optional<S>>;
    [Symbol_optional]: number;
}
interface recordToString<S> {
    toType(): Returns<typeof toType.record<S>>;
}
interface unionToString<S> {
    toType(): Returns<typeof toType.union<S>>;
}
interface intersectToString<S> {
    toType(): Returns<typeof toType.intersect<S>>;
}
interface tupleToString<S> {
    toType(): Returns<typeof toType.tuple<S>>;
}
interface objectToString<S, _ = UnionToTuple<keyof S>> {
    toType(): Returns<typeof toType.object<S, _>>;
}
declare function eqToString<V>(this: t.eq<V>): toType.eq<V, [V] extends [Showable] ? `${V}` : never>;
declare function refToString<S, Id>(this: t.ref<S, Id & string>): `${Id & string}`;
declare function arrayToString<S>(this: t.array<S>): `(${Returns<S["toType"]>})[]`;
declare function optionalToString<S>(this: t.optional<S>): `(${Returns<S["toType"]>} | undefined)`;
declare function recordToString<S>(this: t.record<S>): `Record<string, ${Returns<S["toType"]>}>`;
declare function unionToString<S>(this: t.union<S>): toType.union<S>;
declare function intersectToString<S>(this: t.intersect<S>): toType.intersect<S>;
declare function tupleToString<S>(this: t.tuple<S>): `[${Join<{ [I in keyof S]: `${S[I] extends {
    [symbol_optional]: any;
} ? `_?: ${Returns<S[I]["toType"]>}` : Returns<S[I]["toType"]>}`; }, ", ", "">}]`;
declare function objectToString<S>(this: t.object<S>): toType.object<S, UnionToTuple.loop<[], keyof S, ((keyof S extends infer T ? T extends keyof S ? T extends T ? (_: () => T) => void : never : never : never) extends (_: infer _) => void ? _ : never) extends () => infer X ? X : never>>;
//# sourceMappingURL=toType.d.ts.map