import type * as T from '@traversable/registry';
import type { Integer, Label, Natural as NaturalNumber, SchemaOptions as Options, TypeError, Unknown } from '@traversable/registry';
import { symbol, URI } from '@traversable/registry';
import type { Guard, Predicate as AnyPredicate, Typeguard, ValidateTuple } from './types.js';
export declare const isPredicate: <S, T extends S>(got: unknown) => got is {
    (): boolean;
    (x: S): x is T;
};
export type Source<T> = T extends (_: infer S) => unknown ? S : unknown;
export type Target<S> = never | S extends (_: any) => _ is infer T ? T : S;
export type Inline<S> = never | of<Target<S>>;
export type Predicate = AnyPredicate | Schema;
export type Force<T> = never | {
    -readonly [K in keyof T]: T[K];
};
export type Optional<S, K extends keyof S = keyof S> = never | string extends K ? string : K extends K ? S[K] extends bottom | optional<any> ? K : never : never;
export type FirstOptionalItem<S, Offset extends 1[] = []> = S extends readonly [infer H, ...infer T] ? optional<any> extends H ? Offset['length'] : FirstOptionalItem<T, [...Offset, 1]> : never;
export type Required<S, K extends keyof S = keyof S> = never | string extends K ? string : K extends K ? S[K] extends bottom | optional<any> ? never : K : never;
export type Entry<S> = [Schema] extends [S] ? Schema : S extends {
    def: unknown;
} ? S : S extends Guard<infer T> ? of<T> : S extends globalThis.BooleanConstructor ? nonnullable : S extends (() => infer _ extends boolean) ? BoolLookup[`${_}`] : S;
export type BoolLookup = never | {
    true: top;
    false: bottom;
    boolean: unknown_;
};
export type IntersectType<Todo, Out = unknown> = Todo extends readonly [infer H, ...infer T] ? IntersectType<T, Out & H['_type' & keyof H]> : Out;
export type TupleType<T, Out extends readonly unknown[] = []> = never | optional<any> extends T[number & keyof T] ? T extends readonly [infer Head, ...infer Tail] ? [Head] extends [optional<any>] ? Label<{
    [ix in keyof Out]: Out[ix]['_type' & keyof Out[ix]];
}, {
    [ix in keyof T]: T[ix]['_type' & keyof T[ix]];
}> : TupleType<Tail, [...Out, Head]> : never : {
    [ix in keyof T]: T[ix]['_type' & keyof T[ix]];
};
export type typeOf<T extends {
    _type?: unknown;
}, _ extends T['_type'] = T['_type']> = never | _;
export interface LowerBound<T = unknown> {
    readonly _type?: T;
    (got: Unknown): got is T;
    (got: unknown): got is T;
    tag?: string;
    def?: unknown;
}
export interface Schema<Fn extends LowerBound = LowerBound> {
    readonly _type?: Fn['_type'];
    (got: Unknown): got is Fn['_type'];
    (got: unknown): got is Fn['_type'];
    tag?: Fn['tag'];
    def?: Fn['def'];
}
export type Type = F<any>;
export type Unary = eq<Unary> | ref<Unary> | array<Unary> | record<Unary> | optional<Unary> | union<Unary[]> | intersect<readonly Unary[]> | tuple<Unary[]> | object_<{
    [x: string]: Unary;
}>;
export type F<T> = Leaf | eq<T> | ref<T> | array<T> | record<T> | optional<T> | union<T[]> | intersect<readonly T[]> | tuple<T[]> | object_<{
    [x: string]: T;
}>;
export type Fixpoint = Leaf | Unary;
export interface Free extends T.HKT {
    [-1]: F<this[0]>;
}
export interface of<S> {
    readonly _type: Target<S>;
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.inline;
    def: S;
}
export declare function of<S extends Guard>(typeguard: S): Entry<S>;
export declare function of<S extends Predicate>(typeguard: S): of<Entry<S>>;
export declare namespace of {
    let prototype: {
        tag: "@traversable/schema/URI::inline";
    };
    type type<S, T = Target<S>> = never | T;
    function def<T extends Guard>(guard: T): of<T>;
}
export interface top {
    readonly _type: unknown;
    tag: URI.top;
    def: unknown;
}
export interface bottom {
    readonly _type: never;
    tag: URI.bottom;
    def: never;
}
export interface invalid<_Err> extends TypeError<''>, never_ {
}
export { void_ as void };
interface void_ {
    readonly _type: void;
    (got: this['_type'] | Unknown): got is void;
    (got: unknown): got is void;
    tag: URI.void;
    def: void;
}
declare const void_: void_;
export { never_ as never };
interface never_ {
    readonly _type: never;
    (got: unknown): got is never;
    tag: URI.never;
    def: never;
}
declare const never_: never_;
export { unknown_ as unknown };
interface unknown_ {
    readonly _type: unknown;
    (got: unknown): got is unknown;
    tag: URI.unknown;
    def: unknown;
}
declare const unknown_: unknown_;
export { any_ as any };
interface any_ {
    readonly _type: any;
    (got: unknown): got is any;
    tag: URI.any;
    def: any;
}
declare const any_: any_;
export { null_ as null };
interface null_ {
    readonly _type: null;
    (got: null | Unknown): got is null;
    (got: unknown): got is null;
    tag: URI.null;
    def: this['_type'];
}
declare const null_: null_;
export { undefined_ as undefined };
interface undefined_ {
    readonly _type: undefined;
    (got: undefined | Unknown): got is undefined;
    (got: unknown): got is undefined;
    tag: URI.undefined;
    def: undefined;
}
declare const undefined_: undefined_;
export { symbol_ as symbol };
interface symbol_ {
    readonly _type: symbol;
    (got: symbol | Unknown): got is symbol;
    (got: unknown): got is symbol;
    tag: URI.symbol;
    def: symbol;
}
declare const symbol_: symbol_;
export { boolean_ as boolean };
interface boolean_ {
    readonly _type: boolean;
    (got: boolean | Unknown): got is boolean;
    (got: unknown): got is boolean;
    tag: URI.boolean;
    def: boolean;
}
declare const boolean_: boolean_;
export { integer };
interface integer extends integer.methods {
    readonly _type: number;
    (got: number | Unknown): got is number;
    (got: unknown): got is number;
    tag: URI.integer;
    def: this['_type'];
    minimum?: number;
    maximum?: number;
}
declare namespace integer {
    type Min<X extends number, Self> = [Self] extends [{
        maximum: number;
    }] ? integer.between<[min: X, max: Self['maximum']]> : integer.min<X>;
    type Max<X extends number, Self> = [Self] extends [{
        minimum: number;
    }] ? integer.between<[min: Self['minimum'], max: X]> : integer.max<X>;
    interface methods {
        min<Min extends Integer<Min>>(minimum: Min): integer.Min<Min, this>;
        max<Max extends Integer<Max>>(maximum: Max): integer.Max<Max, this>;
        between<Min extends Integer<Min>, Max extends Integer<Max>>(minimum: Min, maximum: Max): integer.between<[min: Min, max: Max]>;
    }
    interface min<Min extends number> extends integer {
        minimum: Min;
    }
    interface max<Max extends number> extends integer {
        maximum: Max;
    }
    interface between<Bounds extends [min: number, max: number]> extends integer {
        minimum: Bounds[0];
        maximum: Bounds[1];
    }
}
declare const integer: integer;
export { bigint_ as bigint };
interface bigint_ extends bigint_.methods {
    readonly _type: bigint;
    (got: bigint | Unknown): got is bigint;
    (got: unknown): got is bigint;
    tag: URI.bigint;
    def: this['_type'];
    minimum?: bigint;
    maximum?: bigint;
}
declare namespace bigint_ {
    type Min<X extends bigint, Self> = [Self] extends [{
        maximum: bigint;
    }] ? bigint_.between<[min: X, max: Self['maximum']]> : bigint_.min<X>;
    type Max<X extends bigint, Self> = [Self] extends [{
        minimum: bigint;
    }] ? bigint_.between<[min: Self['minimum'], max: X]> : bigint_.max<X>;
    interface methods extends Typeguard<bigint> {
        min<Min extends bigint>(minimum: Min): bigint_.Min<Min, this>;
        max<Max extends bigint>(maximum: Max): bigint_.Max<Max, this>;
        between<Min extends bigint, Max extends bigint>(minimum: Min, maximum: Max): bigint_.between<[min: Min, max: Max]>;
    }
    interface min<Min extends bigint> extends bigint_ {
        minimum: Min;
    }
    interface max<Max extends bigint> extends bigint_ {
        maximum: Max;
    }
    interface between<Bounds extends [min: bigint, max: bigint]> extends bigint_ {
        minimum: Bounds[0];
        maximum: Bounds[1];
    }
}
declare const bigint_: bigint_;
export { number_ as number };
interface number_ extends number_.methods {
    readonly _type: number;
    (got: number | Unknown): got is number;
    (got: unknown): got is number;
    tag: URI.number;
    def: number;
    minimum?: number;
    maximum?: number;
    exclusiveMinimum?: number;
    exclusiveMaximum?: number;
}
declare namespace number_ {
    interface methods {
        min<Min extends number>(minimum: Min): number_.Min<Min, this>;
        max<Max extends number>(maximum: Max): number_.Max<Max, this>;
        moreThan<Min extends number>(moreThan: Min): ExclusiveMin<Min, this>;
        lessThan<Max extends number>(lessThan: Max): ExclusiveMax<Max, this>;
        between<Min extends number, Max extends number>(minimum: Min, maximum: Max): number_.between<[min: Min, max: Max]>;
    }
    type Min<X extends number, Self> = [Self] extends [{
        exclusiveMaximum: number;
    }] ? number_.minStrictMax<[min: X, lessThan: Self['exclusiveMaximum']]> : [Self] extends [{
        maximum: number;
    }] ? number_.between<[min: X, max: Self['maximum']]> : number_.min<X>;
    type Max<X extends number, Self> = [Self] extends [{
        exclusiveMinimum: number;
    }] ? number_.maxStrictMin<[moreThan: Self['exclusiveMinimum'], max: X]> : [Self] extends [{
        minimum: number;
    }] ? number_.between<[min: Self['minimum'], max: X]> : number_.max<X>;
    type ExclusiveMin<X extends number, Self> = [Self] extends [{
        exclusiveMaximum: number;
    }] ? number_.strictlyBetween<[moreThan: X, lessThan: Self['exclusiveMaximum']]> : [Self] extends [{
        maximum: number;
    }] ? number_.maxStrictMin<[moreThan: X, max: Self['maximum']]> : number_.moreThan<X>;
    type ExclusiveMax<X extends number, Self> = [Self] extends [{
        exclusiveMinimum: number;
    }] ? number_.strictlyBetween<[moreThan: Self['exclusiveMinimum'], lessThan: X]> : [Self] extends [{
        minimum: number;
    }] ? number_.minStrictMax<[min: Self['minimum'], lessThan: X]> : number_.lessThan<X>;
    interface min<Min extends number> extends number_ {
        minimum: Min;
    }
    interface max<Max extends number> extends number_ {
        maximum: Max;
    }
    interface moreThan<Min extends number> extends number_ {
        exclusiveMinimum: Min;
    }
    interface lessThan<Max extends number> extends number_ {
        exclusiveMaximum: Max;
    }
    interface between<Bounds extends [min: number, max: number]> extends number_ {
        minimum: Bounds[0];
        maximum: Bounds[1];
    }
    interface minStrictMax<Bounds extends [min: number, lessThan: number]> extends number_ {
        minimum: Bounds[0];
        exclusiveMaximum: Bounds[1];
    }
    interface maxStrictMin<Bounds extends [moreThan: number, max: number]> extends number_ {
        maximum: Bounds[1];
        exclusiveMinimum: Bounds[0];
    }
    interface strictlyBetween<Bounds extends [moreThan: number, lessThan: number]> extends number_ {
        exclusiveMinimum: Bounds[0];
        exclusiveMaximum: Bounds[1];
    }
}
declare const number_: number_;
export { string_ as string };
interface string_ extends string_.methods {
    _type: string;
    (got: string | Unknown): got is string;
    (got: unknown): got is string;
    tag: URI.string;
    def: this['_type'];
    minLength?: number;
    maxLength?: number;
}
declare namespace string_ {
    interface methods {
        min<Min extends NaturalNumber<Min>>(minLength: Min): string_.Min<Min, this>;
        max<Max extends NaturalNumber<Max>>(maxLength: Max): string_.Max<Max, this>;
        between<Min extends NaturalNumber<Min>, Max extends NaturalNumber<Max>>(minLength: Min, maxLength: Max): string_.between<[min: Min, max: Max]>;
    }
    type Min<Min extends number, Self> = [Self] extends [{
        maxLength: number;
    }] ? string_.between<[min: Min, max: Self['maxLength']]> : string_.min<Min>;
    type Max<Max extends number, Self> = [Self] extends [{
        minLength: number;
    }] ? string_.between<[min: Self['minLength'], max: Max]> : string_.max<Max>;
    interface min<Min extends number> extends string_ {
        minLength: Min;
    }
    interface max<Max extends number> extends string_ {
        maxLength: Max;
    }
    interface between<Bounds extends [min: number, max: number]> extends string_ {
        minLength: Bounds[0];
        maxLength: Bounds[1];
    }
}
declare const string_: string_;
export { nonnullable };
interface nonnullable extends Typeguard<{}> {
    readonly _type: {};
    (got: {} | Unknown): got is {};
    (got: unknown): got is {};
    tag: URI.nonnullable;
    def: {};
}
declare const nonnullable: nonnullable;
export declare function eq<const V extends T.Mut<V>>(value: V, options?: Options<V>): eq<T.Mutable<V>>;
export declare function eq<const V>(value: V, options?: Options<V>): eq<V>;
export interface eq<V> {
    readonly _type: V;
    (got: V | Unknown): got is V;
    (got: unknown): got is V;
    tag: URI.eq;
    def: V;
}
export declare namespace eq {
    let prototype: {
        tag: "@traversable/schema/URI::eq";
    };
    function def<T>(value: T, options?: Options): eq<T>;
}
export declare function optional<S extends Schema>(schema: S): optional<S>;
export declare function optional<S extends Predicate>(schema: S): optional<Inline<S>>;
export interface optional<S> {
    readonly _type: undefined | S['_type' & keyof S];
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.optional;
    def: S;
    [symbol.optional]: number;
}
export declare namespace optional {
    let prototype: {
        tag: "@traversable/schema/URI::optional";
    };
    type type<S, T = undefined | S['_type' & keyof S]> = never | T;
    function def<T>(x: T): optional<T>;
    const is: <S extends Schema>(got: unknown) => got is optional<S>;
}
export interface ref<S, Id = string> {
    readonly _type: S['_type' & keyof S];
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: Unknown): got is this['_type'];
    tag: URI.ref;
    id: Id;
    def: S;
    toString(): Id;
}
export declare function ref<S extends Schema, Id extends string>(schema: S, id: Id): ref<S, Id>;
export declare namespace ref {
    let prototype: {
        tag: string;
    };
    function def<S, Id extends string>(schema: S, id: Id): ref<S, Id>;
}
export declare function array<S extends Schema>(schema: S, readonly: 'readonly'): ReadonlyArray<S>;
export declare function array<S extends Schema>(schema: S): array<S>;
export declare function array<S extends Predicate>(schema: S): array<Inline<S>>;
export interface array<S> extends array.methods<S> {
    readonly _type: S['_type' & keyof S][];
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.array;
    def: S;
    minLength?: number;
    maxLength?: number;
}
export declare namespace array {
    interface methods<S> {
        min<Min extends NaturalNumber<Min>>(minLength: Min): array.Min<Min, this>;
        max<Max extends NaturalNumber<Max>>(maxLength: Max): array.Max<Max, this>;
        between<Min extends NaturalNumber<Min>, Max extends NaturalNumber<Max>>(minLength: Min, maxLength: Max): array.between<[min: Min, max: Max], S>;
    }
    type Min<Min extends number, Self> = [Self] extends [{
        maxLength: number;
    }] ? array.between<[min: Min, max: Self['maxLength']], Self['def' & keyof Self]> : array.min<Min, Self['def' & keyof Self]>;
    type Max<Max extends number, Self> = [Self] extends [{
        minLength: number;
    }] ? array.between<[min: Self['minLength'], max: Max], Self['def' & keyof Self]> : array.max<Max, Self['def' & keyof Self]>;
    interface min<Min extends number, S> extends array<S> {
        minLength: Min;
    }
    interface max<Max extends number, S> extends array<S> {
        maxLength: Max;
    }
    interface between<Bounds extends [min: number, max: number], S> extends array<S> {
        minLength: Bounds[0];
        maxLength: Bounds[1];
    }
    type type<S> = never | S['_type' & keyof S][];
}
export declare namespace array {
    let prototype: array<unknown>;
    function def<S>(x: S, prev?: array<unknown>): array<S>;
    function def<S>(x: S, prev?: unknown): array<S>;
    function def<S>(x: S, prev?: array<unknown>): array<S>;
}
export declare const readonlyArray: {
    <S extends Schema>(schema: S, readonly: 'readonly'): ReadonlyArray<S>;
    <S extends Predicate>(schema: S): ReadonlyArray<Inline<S>>;
};
export interface ReadonlyArray<S> {
    readonly _type: readonly S['_type' & keyof S][];
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.array;
    def: S;
}
export declare function record<S extends Schema>(schema: S): record<S>;
export declare function record<S extends Predicate>(schema: S): record<Inline<S>>;
export interface record<S> {
    readonly _type: Record<string, S['_type' & keyof S]>;
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.record;
    def: S;
}
export declare namespace record {
    let prototype: record<unknown>;
    type type<S, T = Record<string, S['_type' & keyof S]>> = never | T;
    function def<T>(x: T): record<T>;
}
export declare function union<S extends readonly Schema[]>(...schemas: S): union<S>;
export declare function union<S extends readonly Predicate[], T extends {
    [I in keyof S]: Entry<S[I]>;
}>(...schemas: S): union<T>;
export interface union<S> {
    readonly _type: S[number & keyof S]['_type' & keyof S[number & keyof S]];
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.union;
    def: S;
}
export declare namespace union {
    let prototype: union<unknown>;
    type type<S, T = S[number & keyof S]['_type' & keyof S[number & keyof S]]> = never | T;
    function def<T extends readonly unknown[]>(xs: T): union<T>;
}
export declare function intersect<S extends readonly Schema[]>(...schemas: S): intersect<S>;
export declare function intersect<S extends readonly Predicate[], T extends {
    [I in keyof S]: Entry<S[I]>;
}>(...schemas: S): intersect<T>;
export interface intersect<S> {
    _type: IntersectType<S>;
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.intersect;
    def: S;
}
export declare namespace intersect {
    let prototype: intersect<unknown>;
    type type<S, T = IntersectType<S>> = never | T;
    function def<T extends readonly unknown[]>(xs: readonly [...T]): intersect<T>;
}
export { tuple };
declare function tuple<S extends readonly Predicate[], T extends {
    [I in keyof S]: Entry<S[I]>;
}>(...schemas: tuple.validate<S>): tuple<tuple.from<tuple.validate<S>, T>>;
declare function tuple<S extends readonly Schema[]>(...schemas: tuple.validate<S>): tuple<tuple.from<tuple.validate<S>, S>>;
declare function tuple<S extends readonly Predicate[], T extends {
    [I in keyof S]: Entry<S[I]>;
}>(...args: [...schemas: tuple.validate<S>, options: Options]): tuple<tuple.from<tuple.validate<S>, T>>;
declare function tuple<S extends readonly Schema[]>(...args: [...schemas: tuple.validate<S>, options: Options]): tuple<tuple.from<tuple.validate<S>, S>>;
declare function tuple<S extends readonly Predicate[], T extends {
    [I in keyof S]: Entry<S[I]>;
}>(...schemas: tuple.validate<S>): tuple<tuple.from<tuple.validate<S>, T>>;
declare function tuple<S extends readonly Schema[]>(...schemas: tuple.validate<S>): tuple<tuple.from<tuple.validate<S>, S>>;
interface tuple<S> {
    readonly _type: TupleType<S>;
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.tuple;
    def: S;
    opt: FirstOptionalItem<S>;
}
declare namespace tuple {
    let prototype: tuple<unknown>;
    function def<T extends readonly unknown[]>(xs: readonly [...T], $?: Options, opt_?: number): tuple<T>;
}
declare namespace tuple {
    type type<S> = never | TupleType<S>;
    type validate<T extends readonly unknown[]> = ValidateTuple<T, optional<any>>;
    type from<V extends readonly unknown[], T extends readonly unknown[]> = TypeError extends V[number] ? {
        [I in keyof V]: V[I] extends TypeError ? invalid<Extract<V[I], TypeError>> : V[I];
    } : T;
    type InternalOptions = {
        minLength?: number;
    };
}
export { object_ as object };
declare function object_<S extends {
    [x: string]: Schema;
}, T extends {
    [K in keyof S]: Entry<S[K]>;
}>(schemas: S, options?: Options): object_<T>;
declare function object_<S extends {
    [x: string]: Predicate;
}, T extends {
    [K in keyof S]: Entry<S[K]>;
}>(schemas: S, options?: Options): object_<T>;
interface object_<S = {
    [x: string]: Schema;
}> {
    readonly _type: object_.type<S>;
    (got: this['_type'] | Unknown): got is this['_type'];
    (got: unknown): got is this['_type'];
    tag: URI.object;
    def: S;
    opt: Optional<S>[];
    req: Required<S>[];
}
declare namespace object_ {
    let prototype: object_<unknown>;
    type Opt<S, K extends keyof S> = symbol.optional extends keyof S[K] ? never : K;
    type Req<S, K extends keyof S> = symbol.optional extends keyof S[K] ? K : never;
    type type<S> = Force<{
        [K in keyof S as Opt<S, K>]-?: S[K]['_type' & keyof S[K]];
    } & {
        [K in keyof S as Req<S, K>]+?: S[K]['_type' & keyof S[K]];
    }>;
    function def<T extends {
        [x: string]: unknown;
    }>(xs: T, $?: Options, opt?: string[]): object_<T>;
    function def<T>(xs: T, $?: Options, opt?: string[]): object_<T>;
}
export type Leaf = typeof leaves[number];
export type LeafTag = Leaf['tag'];
export type Nullary = typeof nullaries[number];
export type NullaryTag = Nullary['tag'];
export type Boundable = typeof boundables[number];
export type BoundableTag = Boundable['tag'];
export type Tag = typeof tags[number];
export type TypeName = T.TypeName<Tag>;
export type UnaryTag = typeof unaryTags[number];
export type UnaryTypeName = T.TypeName<UnaryTag>;
export declare const nullaries: (unknown_ | never_ | any_ | void_ | undefined_ | null_ | symbol_ | boolean_)[];
export declare const nullaryTags: ("@traversable/schema/URI::boolean" | "@traversable/schema/URI::unknown" | "@traversable/schema/URI::never" | "@traversable/schema/URI::any" | "@traversable/schema/URI::void" | "@traversable/schema/URI::undefined" | "@traversable/schema/URI::null" | "@traversable/schema/URI::symbol")[];
export declare const isNullaryTag: (got: unknown) => got is NullaryTag;
export declare const isNullary: (got: unknown) => got is Nullary;
export declare const boundables: (integer | bigint_ | number_ | string_)[];
export declare const boundableTags: ("@traversable/schema/URI::string" | "@traversable/schema/URI::integer" | "@traversable/schema/URI::bigint" | "@traversable/schema/URI::number")[];
export declare const isBoundableTag: (got: unknown) => got is BoundableTag;
export declare const isBoundable: (got: unknown) => got is Boundable;
export declare const leaves: (unknown_ | never_ | any_ | void_ | undefined_ | null_ | symbol_ | boolean_ | integer | bigint_ | number_ | string_)[];
export declare const leafTags: ("@traversable/schema/URI::boolean" | "@traversable/schema/URI::unknown" | "@traversable/schema/URI::never" | "@traversable/schema/URI::any" | "@traversable/schema/URI::void" | "@traversable/schema/URI::undefined" | "@traversable/schema/URI::null" | "@traversable/schema/URI::symbol" | "@traversable/schema/URI::string" | "@traversable/schema/URI::integer" | "@traversable/schema/URI::bigint" | "@traversable/schema/URI::number")[];
export declare const isLeaf: (got: unknown) => got is Leaf;
export declare const unaryTags: readonly ["@traversable/schema/URI::optional", "@traversable/schema/URI::eq", "@traversable/schema/URI::ref", "@traversable/schema/URI::array", "@traversable/schema/URI::record", "@traversable/schema/URI::tuple", "@traversable/schema/URI::union", "@traversable/schema/URI::intersect", "@traversable/schema/URI::object"];
export declare const tags: ("@traversable/schema/URI::boolean" | "@traversable/schema/URI::unknown" | "@traversable/schema/URI::never" | "@traversable/schema/URI::any" | "@traversable/schema/URI::void" | "@traversable/schema/URI::undefined" | "@traversable/schema/URI::null" | "@traversable/schema/URI::symbol" | "@traversable/schema/URI::string" | "@traversable/schema/URI::integer" | "@traversable/schema/URI::bigint" | "@traversable/schema/URI::number" | "@traversable/schema/URI::eq" | "@traversable/schema/URI::optional" | "@traversable/schema/URI::ref" | "@traversable/schema/URI::array" | "@traversable/schema/URI::record" | "@traversable/schema/URI::union" | "@traversable/schema/URI::intersect" | "@traversable/schema/URI::tuple" | "@traversable/schema/URI::object")[];
export declare const isUnary: (got: unknown) => got is Unary;
export type AnyCoreSchema = Schema | Nullary | Boundable;
export declare const isCore: <T>(got: unknown) => got is Schema;
export declare const defaultIndex: {
    path: (string | number | symbol)[];
    depth: number;
};
export type Index = {
    path: (keyof any)[];
    depth: number;
};
export declare namespace Functor {
    export { Index };
}
export declare const Functor: T.Functor<Free, Schema>;
export type IndexedFunctor<Ix = Functor.Index> = T.Functor.Ix<Ix, Free, Schema>;
export declare const IndexedFunctor: IndexedFunctor;
export declare const unfold: <T>(coalgebra: T.Coalgebra<Free, T>) => <S extends Schema<LowerBound<unknown>>>(expr: S) => F<T>;
export declare const fold: <T>(g: (src: F<T>, ix: Index, x: Schema<LowerBound<unknown>>) => T) => {
    (src: F<T>, ix?: Index | undefined): T;
    (src: Schema<LowerBound<unknown>>, ix?: Index | undefined): T;
    (src: F<T>, ix?: Index | undefined): T;
};
export declare const foldWithIndex: <T>(algebra: T.IndexedAlgebra<Index, Free, T>) => <S extends Schema<LowerBound<unknown>>>(term: S, ix: Index) => T;
//# sourceMappingURL=schema.d.ts.map