import type { Intersect, SchemaOptions } from '@traversable/registry';
import { symbol as Symbol, URI } from '@traversable/registry';
import type * as t from './schema.js';
export { null_ as null, undefined_ as undefined, true_ as true, false_ as false, isComposite as composite, };
export declare const conjunctiveIdentity: () => true;
export declare const disjunctiveIdentity: () => false;
declare const null_: (u: unknown) => u is null;
declare const undefined_: (u: unknown) => u is undefined;
export declare const any: (_: unknown) => _ is unknown;
export declare const never: (_: unknown) => _ is never;
export declare function array(u: unknown): u is readonly unknown[];
export declare function array$<T>(guard: (u: unknown) => u is T): (u: unknown) => u is readonly T[];
export declare function optional$<T>(guard: (u: unknown) => u is T): (u: unknown) => u is undefined | T;
export declare const bigint: (u: unknown) => u is bigint;
export declare const boolean: (u: unknown) => u is boolean;
export declare const number: (u: unknown) => u is number;
export declare const string: (u: unknown) => u is string;
export declare const symbol: (u: unknown) => u is symbol;
export declare const object: (u: unknown) => u is {
    [x: string]: unknown;
};
export declare const is: {
    array: typeof array$;
    record: typeof record;
    union: typeof union;
    intersect: typeof intersect;
    optional: typeof optional$;
    object: typeof object$;
    anyObject: (u: unknown) => u is {
        [x: string]: unknown;
    };
    anyArray: typeof array;
    tuple: typeof tuple$;
    unknown: (_: unknown) => _ is unknown;
};
export declare function literally<T extends {} | null | undefined>(value: T): (u: unknown) => u is T;
export declare function literally<T extends {} | null | undefined>(...values: readonly T[]): (u: unknown) => u is T;
export declare const key: (u: unknown) => u is keyof any;
export declare const nonnullable: (u: {} | null | undefined) => u is {};
export declare const showable: (u: unknown) => u is boolean | number | bigint | string;
export declare const scalar: (u: unknown) => u is undefined | null | boolean | number | string;
export declare const primitive: (u: unknown) => boolean;
declare const true_: (u: unknown) => u is true;
declare const false_: (u: unknown) => u is false;
export declare const defined: (u: {} | null | undefined) => u is {} | null;
export declare const notnull: (u: {} | null | undefined) => u is {} | undefined;
export declare const nullable: (u: {} | null | undefined) => u is null | undefined;
export declare const nonempty: {
    array: <T>(xs: T[] | readonly T[]) => xs is {
        [0]: NonNullable<T>;
    } & typeof xs;
};
export { isOptionalSchema as __isOptionalSchema };
declare function isOptionalSchema(u: unknown): u is ((u: unknown) => u is unknown) & {
    [Symbol.tag]: URI.optional;
    def: (u: unknown) => u is unknown;
};
export declare function record<T>(guard: (u: unknown) => u is T): (u: unknown) => u is globalThis.Record<string, T>;
export declare function record<T, K extends keyof any>(keyGuard: (k: keyof any) => k is K, valueGuard: (u: unknown) => u is T): (u: unknown) => u is globalThis.Record<K, T>;
declare function union<T extends readonly ((u: unknown) => u is unknown)[]>(guard: readonly [...T]): (u: unknown) => u is T[number];
declare function intersect<T extends readonly ((u: unknown) => u is unknown)[]>(guard: readonly [...T]): (u: unknown) => u is Intersect<T>;
type Target<S> = S extends {
    (_: any): _ is infer T;
} ? T : S extends {
    (u: infer T): boolean;
} ? T : never;
export declare function object$(predicates: Record<string, (x: unknown) => boolean>, $?: SchemaOptions): (got: unknown) => got is object;
export declare function object$(predicates: Record<string, unknown>, $?: SchemaOptions): (got: unknown) => got is object;
export declare function record$<T>(guard: (u: unknown) => u is T): (u: unknown) => u is globalThis.Record<string, T>;
export declare function record$<T, K extends keyof any>(keyGuard: (k: keyof any) => k is K, valueGuard: (u: unknown) => u is T): (u: unknown) => u is globalThis.Record<K, T>;
export declare function intersect$<T extends readonly ((u: unknown) => u is unknown)[]>(...guard: [...T]): (u: unknown) => u is Intersect<T>;
export declare function union$<T extends readonly ((u: unknown) => u is unknown)[]>(...guard: [...T]): (u: unknown) => u is T[number];
export declare function tuple$<Opts extends {
    minLength?: number;
} & SchemaOptions>(options: Opts): <T extends readonly t.Predicate[]>(qs: T) => (u: unknown) => u is {
    [I in keyof T]: Target<T[I]>;
};
//# sourceMappingURL=predicates.d.ts.map