import { Equal } from '@traversable/registry';
import { t } from '@traversable/schema';
export declare const defaults: {
    readonly "@traversable/schema/URI::unknown": <T>(l: T, r: T) => boolean;
    readonly "@traversable/schema/URI::any": <T>(l: T, r: T) => boolean;
    readonly "@traversable/schema/URI::never": (l: never, r: never) => boolean;
    readonly "@traversable/schema/URI::void": (l: void, r: void) => boolean;
    readonly "@traversable/schema/URI::undefined": <T>(l: T, r: T) => boolean;
    readonly "@traversable/schema/URI::null": (l: null, r: null) => boolean;
    readonly "@traversable/schema/URI::symbol": (l: symbol, r: symbol) => boolean;
    readonly "@traversable/schema/URI::boolean": (l: boolean, r: boolean) => boolean;
    readonly "@traversable/schema/URI::bigint": (l: bigint, r: bigint) => boolean;
    readonly "@traversable/schema/URI::integer": (l: number, r: number) => boolean;
    readonly "@traversable/schema/URI::number": (l: number, r: number) => boolean;
    readonly "@traversable/schema/URI::string": (l: string, r: string) => boolean;
    readonly "@traversable/schema/URI::eq": (x: import("@traversable/json/functor").Fixpoint, y: import("@traversable/json/functor").Fixpoint) => boolean;
};
export declare const array: <T>(equalsFn: Equal<T>) => Equal<readonly T[]>;
export declare function record<T>(equalsFn: Equal<T>): Equal<Record<string, T>>;
export declare function object<T>(equalsFns: {
    [x: string]: Equal<T>;
}): Equal<{
    [x: string]: T;
}>;
export declare function tuple<T>(equalsFns: readonly Equal<T>[]): Equal<readonly T[]>;
export declare const union: <T>(equalsFns: readonly Equal<T>[]) => Equal<T>;
export declare const intersect: <T>(equalsFns: readonly Equal<T>[]) => Equal<T>;
export declare const optional: <T>(equalsFn: Equal<T>) => Equal<T>;
/**
 * ## {@link fromSchema `Eq.fromSchema`}
 *
 * Derive an _equals function_ from a {@link t.Schema `Schema`}.
 *
 * An "equals function" a.k.a. {@link Eq `Eq`} is kinda like lodash's
 * `deepEquals`, except more performant. This is possible because
 * when the shape of the values being compared is known ahead of time,
 * we can optimize ahead of time, and only check what's necessary.
 */
export declare const fromSchema: <S extends t.Schema>(term: S) => Equal<FixUnknown<S['_type']>>;
//# sourceMappingURL=equals.d.ts.map