import type { FlatType, TupleToIntersection, Writable } from "./_typeutil.js";
import { type GetMetadata, type WithMetadata } from "./metadata.js";
/**
 * A type predicate function.
 */
export type Predicate<T> = (x: unknown) => x is T;
/**
 * A type predicated by Predicate<T>.
 *
 * ```ts
 * import { is, type PredicateType } from "@core/unknownutil";
 *
 * const isPerson = is.ObjectOf({
 *   name: is.String,
 *   age: is.Number,
 *   address: is.OptionalOf(is.String),
 * });
 *
 * type Person = PredicateType<typeof isPerson>;
 * // Above is equivalent to the following type
 * // type Person = {
 * //   name: string;
 * //   age: number;
 * //   address: string | undefined;
 * // };
 */
export type PredicateType<P> = P extends Predicate<infer T> ? T : never;
/**
 * Assume `x is `any` and always return `true` regardless of the type of `x`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a = "a";
 * if (is.Any(a)) {
 *   // a is narrowed to any
 *   const _: any = a;
 * }
 * ```
 */
export declare function isAny(_x: unknown): _x is any;
/**
 * Assume `x` is `unknown` and always return `true` regardless of the type of `x`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a = "a";
 * if (is.Unknown(a)) {
 *   // a is narrowed to unknown
 *   const _: unknown = a;
 * }
 * ```
 */
export declare function isUnknown(_x: unknown): _x is unknown;
/**
 * Return `true` if the type of `x` is `string`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = "a";
 * if (is.String(a)) {
 *   // a is narrowed to string
 *   const _: string = a;
 * }
 * ```
 */
export declare function isString(x: unknown): x is string;
/**
 * Return `true` if the type of `x` is `number`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = 0;
 * if (is.Number(a)) {
 *   // a is narrowed to number
 *   const _: number = a;
 * }
 * ```
 */
export declare function isNumber(x: unknown): x is number;
/**
 * Return `true` if the type of `x` is `bigint`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = 0n;
 * if (is.BigInt(a)) {
 *   // a is narrowed to bigint
 *   const _: bigint = a;
 * }
 * ```
 */
export declare function isBigInt(x: unknown): x is bigint;
/**
 * Return `true` if the type of `x` is `boolean`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = true;
 * if (is.Boolean(a)) {
 *   // a is narrowed to boolean
 *   const _: boolean = a;
 * }
 * ```
 */
export declare function isBoolean(x: unknown): x is boolean;
/**
 * Return `true` if the type of `x` is `unknown[]`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = [0, 1, 2];
 * if (is.Array(a)) {
 *   // a is narrowed to unknown[]
 *   const _: unknown[] = a;
 * }
 * ```
 */
export declare function isArray(x: unknown): x is unknown[];
/**
 * Return `true` if the type of `x` is `Set<unknown>`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = new Set([0, 1, 2]);
 * if (is.Set(a)) {
 *   // a is narrowed to Set<unknown>
 *   const _: Set<unknown> = a;
 * }
 * ```
 */
export declare function isSet(x: unknown): x is Set<unknown>;
/**
 * Return `true` if the type of `x` is an object instance that satisfies `Record<PropertyKey, unknown>`.
 *
 * Note that this function check if the `x` is an instance of `Object`.
 * Use `isRecordLike` instead if you want to check if the `x` satisfies the `Record<PropertyKey, unknown>` type.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = {"a": 0, "b": 1};
 * if (is.RecordObject(a)) {
 *   // a is narrowed to Record<PropertyKey, unknown>
 *   const _: Record<PropertyKey, unknown> = a;
 * }
 *
 * const b: unknown = new Set();
 * if (is.RecordObject(b)) {
 *   // b is not a raw object, so it is not narrowed
 * }
 * ```
 */
export declare function isRecordObject(x: unknown): x is Record<PropertyKey, unknown>;
/**
 * Return `true` if the type of `x` satisfies `Record<PropertyKey, unknown>`.
 *
 * Note that this function returns `true` for ambiguous instances like `Set`, `Map`, `Date`, `Promise`, etc.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = {"a": 0, "b": 1};
 * if (is.Record(a)) {
 *   // a is narrowed to Record<PropertyKey, unknown>
 *   const _: Record<PropertyKey, unknown> = a;
 * }
 *
 * const b: unknown = new Set();
 * if (is.Record(b)) {
 *   // b is narrowed to Record<PropertyKey, unknown>
 *   const _: Record<PropertyKey, unknown> = b;
 * }
 * ```
 */
export declare function isRecord(x: unknown): x is Record<PropertyKey, unknown>;
/**
 * Return `true` if the type of `x` is like `Record<PropertyKey, unknown>`.
 *
 * @deprecated Use `is.Record` instead.
 * ```
 */
export declare function isRecordLike(x: unknown): x is Record<PropertyKey, unknown>;
/**
 * Return `true` if the type of `x` is `Map<unknown, unknown>`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = new Map([["a", 0], ["b", 1]]);
 * if (is.Map(a)) {
 *   // a is narrowed to Map<unknown, unknown>
 *   const _: Map<unknown, unknown> = a;
 * }
 * ```
 */
export declare function isMap(x: unknown): x is Map<unknown, unknown>;
/**
 * Return `true` if the type of `x` is `function`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = () => {};
 * if (is.Function(a)) {
 *   // a is narrowed to (...args: unknown[]) => unknown
 *   const _: ((...args: unknown[]) => unknown) = a;
 * }
 * ```
 */
export declare function isFunction(x: unknown): x is (...args: unknown[]) => unknown;
/**
 * Return `true` if the type of `x` is `function` (non async function).
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = () => {};
 * if (is.Function(a)) {
 *   // a is narrowed to (...args: unknown[]) => unknown
 *   const _: ((...args: unknown[]) => unknown) = a;
 * }
 * ```
 */
export declare function isSyncFunction(x: unknown): x is (...args: unknown[]) => unknown;
/**
 * Return `true` if the type of `x` is `function` (async function).
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = async () => {};
 * if (is.Function(a)) {
 *   // a is narrowed to (...args: unknown[]) => Promise<unknown>
 *   const _: ((...args: unknown[]) => unknown) = a;
 * }
 * ```
 */
export declare function isAsyncFunction(x: unknown): x is (...args: unknown[]) => Promise<unknown>;
/**
 * Return `true` if the type of `x` is `null`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = null;
 * if (is.Null(a)) {
 *   // a is narrowed to null
 *   const _: null = a;
 * }
 * ```
 */
export declare function isNull(x: unknown): x is null;
/**
 * Return `true` if the type of `x` is `undefined`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = undefined;
 * if (is.Undefined(a)) {
 *   // a is narrowed to undefined
 *   const _: undefined = a;
 * }
 * ```
 */
export declare function isUndefined(x: unknown): x is undefined;
/**
 * Return `true` if the type of `x` is `null` or `undefined`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = null;
 * if (is.Nullish(a)) {
 *   // a is narrowed to null | undefined
 *   const _: (null | undefined) = a;
 * }
 * ```
 */
export declare function isNullish(x: unknown): x is null | undefined;
/**
 * Return `true` if the type of `x` is `symbol`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const a: unknown = Symbol("symbol");
 * if (is.Symbol(a)) {
 *   // a is narrowed to symbol
 *   const _: symbol = a;
 * }
 * ```
 */
export declare function isSymbol(x: unknown): x is symbol;
export type Primitive = string | number | bigint | boolean | null | undefined | symbol;
/**
 * Return `true` if the type of `x` is `Primitive`.
 *
 * ```ts
 * import { is, Primitive } from "@core/unknownutil";
 *
 * const a: unknown = 0;
 * if (is.Primitive(a)) {
 *   // a is narrowed to Primitive
 *   const _: Primitive = a;
 * }
 * ```
 */
export declare function isPrimitive(x: unknown): x is Primitive;
/**
 * Return `true` if the type of predicate function `x` is annotated as `Optional`
 */
export declare function isOptional<P extends Predicate<unknown>>(x: P): x is P & WithMetadata<IsOptionalOfMetadata>;
/**
 * Return an `Optional` annotated type predicate function that returns `true` if the type of `x` is `T` or `undefined`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.OptionalOf(is.String);
 * const a: unknown = "a";
 * if (isMyType(a)) {
 *   // a is narrowed to string | undefined
 *   const _: string | undefined = a;
 * }
 * ```
 */
export declare function isOptionalOf<T>(pred: Predicate<T>): Predicate<T | undefined> & WithMetadata<IsOptionalOfMetadata>;
type IsOptionalOfMetadata = {
    name: "isOptionalOf";
    args: Parameters<typeof isOptionalOf>;
};
/**
 * Return an `Optional` un-annotated type predicate function that returns `true` if the type of `x` is `T`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.UnwrapOptionalOf(is.OptionalOf(is.String));
 * const a: unknown = "a";
 * if (isMyType(a)) {
 *   // a is narrowed to string
 *   const _: string = a;
 * }
 * ```
 */
export declare function isUnwrapOptionalOf<P extends Predicate<unknown>>(pred: P): UnwrapOptionalOf<P>;
type UnwrapOptionalOf<T> = T extends Predicate<undefined | infer U> & WithMetadata<IsOptionalOfMetadata> ? Predicate<U> : T extends Predicate<unknown> ? T : never;
/**
 * Return `true` if the type of predicate function `x` is annotated as `Readonly`
 *
 * **This is unstable and may be removed in the future.**
 */
export declare function isReadonly<P extends Predicate<unknown>>(x: P): x is P & WithMetadata<IsReadonlyOfMetadata>;
/**
 * Return an `Readonly` annotated type predicate function that returns `true` if the type of `x` is `T`.
 *
 * **This is unstable and may be removed in the future.**
 *
 * Note that this function does nothing but annotate the predicate function as `Readonly`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ReadonlyOf(is.TupleOf([is.String, is.Number]));
 * const a: unknown = ["a", 1];
 * if (isMyType(a)) {
 *   // a is narrowed to readonly [string, number]
 *   const _: readonly [string, number] = a;
 * }
 * ```
 */
export declare function isReadonlyOf<T>(pred: Predicate<T>): Predicate<Readonly<T>> & WithMetadata<IsReadonlyOfMetadata>;
type IsReadonlyOfMetadata = {
    name: "isReadonlyOf";
    args: Parameters<typeof isReadonlyOf>;
};
/**
 * Return an `Readonly` un-annotated type predicate function that returns `true` if the type of `x` is `T`.
 *
 * **This is unstable and may be removed in the future.**
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.UnwrapReadonlyOf(is.ReadonlyOf(is.TupleOf([is.String, is.Number])));
 * const a: unknown = ["a", 1];
 * if (isMyType(a)) {
 *   // a is narrowed to [string, number]
 *   const _: [string, number] = a;
 * }
 * ```
 */
export declare function isUnwrapReadonlyOf<P extends Predicate<unknown>>(pred: P): UnwrapReadonlyOf<P>;
type UnwrapReadonlyOf<T> = T extends Predicate<infer U> & WithMetadata<IsReadonlyOfMetadata> ? Predicate<Writable<U>> : T extends Predicate<unknown> ? T : never;
/**
 * Return a type predicate function that returns `true` if the type of `x` is `T[]`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ArrayOf(is.String);
 * const a: unknown = ["a", "b", "c"];
 * if (isMyType(a)) {
 *   // a is narrowed to string[]
 *   const _: string[] = a;
 * }
 * ```
 */
export declare function isArrayOf<T>(pred: Predicate<T>): Predicate<T[]> & WithMetadata<IsArrayOfMetadata>;
type IsArrayOfMetadata = {
    name: "isArrayOf";
    args: Parameters<typeof isArrayOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Set<T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.SetOf(is.String);
 * const a: unknown = new Set(["a", "b", "c"]);
 * if (isMyType(a)) {
 *   // a is narrowed to Set<string>
 *   const _: Set<string> = a;
 * }
 * ```
 */
export declare function isSetOf<T>(pred: Predicate<T>): Predicate<Set<T>> & WithMetadata<IsSetOfMetadata>;
type IsSetOfMetadata = {
    name: "isSetOf";
    args: Parameters<typeof isSetOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `TupleOf<T>` or `TupleOf<T, E>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.TupleOf([is.Number, is.String, is.Boolean]);
 * const a: unknown = [0, "a", true];
 * if (isMyType(a)) {
 *   // a is narrowed to [number, string, boolean]
 *   const _: [number, string, boolean] = a;
 * }
 * ```
 *
 * With `predElse`:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.TupleOf(
 *   [is.Number, is.String, is.Boolean],
 *   is.ArrayOf(is.Number),
 * );
 * const a: unknown = [0, "a", true, 0, 1, 2];
 * if (isMyType(a)) {
 *   // a is narrowed to [number, string, boolean, ...number[]]
 *   const _: [number, string, boolean, ...number[]] = a;
 * }
 * ```
 *
 * Depending on the version of TypeScript and how values are provided, it may be necessary to add `as const` to the array
 * used as `predTup`. If a type error occurs, try adding `as const` as follows:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const predTup = [is.Number, is.String, is.Boolean] as const;
 * const isMyType = is.TupleOf(predTup);
 * const a: unknown = [0, "a", true];
 * if (isMyType(a)) {
 *   // a is narrowed to [number, string, boolean]
 *   const _: [number, string, boolean] = a;
 * }
 * ```
 */
export declare function isTupleOf<T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]]>(predTup: T): Predicate<TupleOf<T>> & WithMetadata<IsTupleOfMetadata>;
export declare function isTupleOf<T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]], E extends Predicate<unknown[]>>(predTup: T, predElse: E): Predicate<[...TupleOf<T>, ...PredicateType<E>]> & WithMetadata<IsTupleOfMetadata>;
type TupleOf<T> = {
    -readonly [P in keyof T]: T[P] extends Predicate<infer U> ? U : never;
};
type IsTupleOfMetadata = {
    name: "isTupleOf";
    args: [Parameters<typeof isTupleOf>[0], Parameters<typeof isTupleOf>[1]?];
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `ParametersOf<T>` or `ParametersOf<T, E>`.
 *
 * This is similar to `TupleOf<T>` or `TupleOf<T, E>`, but if `is.OptionalOf()` is specified at the trailing, the trailing elements becomes optional and makes variable-length tuple.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ParametersOf([
 *   is.Number,
 *   is.OptionalOf(is.String),
 *   is.Boolean,
 *   is.OptionalOf(is.Number),
 *   is.OptionalOf(is.String),
 *   is.OptionalOf(is.Boolean),
 * ] as const);
 * const a: unknown = [0, undefined, "a"];
 * if (isMyType(a)) {
 *   // a is narrowed to [number, string | undefined, boolean, number?, string?, boolean?]
 *   const _: [number, string | undefined, boolean, number?, string?, boolean?] = a;
 * }
 * ```
 *
 * With `predElse`:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ParametersOf(
 *   [
 *     is.Number,
 *     is.OptionalOf(is.String),
 *     is.OptionalOf(is.Boolean),
 *   ] as const,
 *   is.ArrayOf(is.Number),
 * );
 * const a: unknown = [0, "a", true, 0, 1, 2];
 * if (isMyType(a)) {
 *   // a is narrowed to [number, string?, boolean?, ...number[]]
 *   const _: [number, string?, boolean?, ...number[]] = a;
 * }
 * ```
 *
 * Depending on the version of TypeScript and how values are provided, it may be necessary to add `as const` to the array
 * used as `predTup`. If a type error occurs, try adding `as const` as follows:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const predTup = [is.Number, is.String, is.OptionalOf(is.Boolean)] as const;
 * const isMyType = is.ParametersOf(predTup);
 * const a: unknown = [0, "a"];
 * if (isMyType(a)) {
 *   // a is narrowed to [number, string, boolean?]
 *   const _: [number, string, boolean?] = a;
 * }
 * ```
 */
export declare function isParametersOf<T extends readonly [...Predicate<unknown>[]]>(predTup: T): Predicate<ParametersOf<T>> & WithMetadata<IsParametersOfMetadata>;
export declare function isParametersOf<T extends readonly [...Predicate<unknown>[]], E extends Predicate<unknown[]>>(predTup: T, predElse: E): Predicate<[...ParametersOf<T>, ...PredicateType<E>]> & WithMetadata<IsParametersOfMetadata>;
type ParametersOf<T> = T extends readonly [] ? [] : T extends readonly [...infer P, infer R] ? P extends Predicate<unknown>[] ? R extends Predicate<unknown> & WithMetadata<IsOptionalOfMetadata> ? [...ParametersOf<P>, PredicateType<R>?] : [...ParametersOf<P>, PredicateType<R>] : never : TupleOf<T>;
type IsParametersOfMetadata = {
    name: "isParametersOf";
    args: [
        Parameters<typeof isParametersOf>[0],
        Parameters<typeof isParametersOf>[1]?
    ];
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Readonly<TupleOf<T>>`.
 *
 * @deprecated Use `is.ReadonlyOf(is.TupleOf(...))` instead.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ReadonlyTupleOf([is.Number, is.String, is.Boolean]);
 * const a: unknown = [0, "a", true];
 * if (isMyType(a)) {
 *   // a is narrowed to readonly [number, string, boolean]
 *   const _: readonly [number, string, boolean] = a;
 * }
 * ```
 *
 * With `predElse`:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ReadonlyTupleOf(
 *   [is.Number, is.String, is.Boolean],
 *   is.ArrayOf(is.Number),
 * );
 * const a: unknown = [0, "a", true, 0, 1, 2];
 * if (isMyType(a)) {
 *   // a is narrowed to readonly [number, string, boolean, ...number[]]
 *   const _: readonly [number, string, boolean, ...number[]] = a;
 * }
 * ```
 *
 * Depending on the version of TypeScript and how values are provided, it may be necessary to add `as const` to the array
 * used as `predTup`. If a type error occurs, try adding `as const` as follows:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const predTup = [is.Number, is.String, is.Boolean] as const;
 * const isMyType = is.ReadonlyTupleOf(predTup);
 * const a: unknown = [0, "a", true];
 * if (isMyType(a)) {
 *   // a is narrowed to readonly [number, string, boolean]
 *   const _: readonly [number, string, boolean] = a;
 * }
 * ```
 */
export declare function isReadonlyTupleOf<T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]]>(predTup: T): Predicate<Readonly<TupleOf<T>>> & WithMetadata<IsReadonlyOfMetadata>;
export declare function isReadonlyTupleOf<T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]], E extends Predicate<unknown[]>>(predTup: T, predElse: E): Predicate<Readonly<[...TupleOf<T>, ...PredicateType<E>]>> & WithMetadata<IsReadonlyOfMetadata>;
/**
 * Return a type predicate function that returns `true` if the type of `x` is `UniformTupleOf<T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.UniformTupleOf(5);
 * const a: unknown = [0, 1, 2, 3, 4];
 * if (isMyType(a)) {
 *   // a is narrowed to [unknown, unknown, unknown, unknown, unknown]
 *   const _: [unknown, unknown, unknown, unknown, unknown] = a;
 * }
 * ```
 *
 * With predicate function:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.UniformTupleOf(5, is.Number);
 * const a: unknown = [0, 1, 2, 3, 4];
 * if (isMyType(a)) {
 *   // a is narrowed to [number, number, number, number, number]
 *   const _: [number, number, number, number, number] = a;
 * }
 * ```
 */
export declare function isUniformTupleOf<T, N extends number>(n: N, pred?: Predicate<T>): Predicate<UniformTupleOf<T, N>> & WithMetadata<IsUniformTupleOfMetadata>;
type UniformTupleOf<T, N extends number, R extends readonly T[] = []> = R["length"] extends N ? R : UniformTupleOf<T, N, [T, ...R]>;
type IsUniformTupleOfMetadata = {
    name: "isUniformTupleOf";
    args: Parameters<typeof isUniformTupleOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Readonly<UniformTupleOf<T>>`.
 *
 * @deprecated Use `is.ReadonlyOf(is.UniformTupleOf(...))` instead.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ReadonlyUniformTupleOf(5);
 * const a: unknown = [0, 1, 2, 3, 4];
 * if (isMyType(a)) {
 *   // a is narrowed to readonly [unknown, unknown, unknown, unknown, unknown]
 *   const _: readonly [unknown, unknown, unknown, unknown, unknown] = a;
 * }
 * ```
 *
 * With predicate function:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ReadonlyUniformTupleOf(5, is.Number);
 * const a: unknown = [0, 1, 2, 3, 4];
 * if (isMyType(a)) {
 *   // a is narrowed to readonly [number, number, number, number, number]
 *   const _: readonly [number, number, number, number, number] = a;
 * }
 * ```
 */
export declare function isReadonlyUniformTupleOf<T, N extends number>(n: N, pred?: Predicate<T>): Predicate<Readonly<UniformTupleOf<T, N>>> & WithMetadata<IsReadonlyOfMetadata>;
/**
 * Return a type predicate function that returns `true` if the type of `x` is an Object instance that satisfies `Record<K, T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * Note that this function check if the `x` is an instance of `Object`.
 * Use `isRecordOf` instead if you want to check if the `x` satisfies the `Record<K, T>` type.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.RecordObjectOf(is.Number);
 * const a: unknown = {"a": 0, "b": 1};
 * if (isMyType(a)) {
 *   // a is narrowed to Record<PropertyKey, number>
 *   const _: Record<PropertyKey, number> = a;
 * }
 * ```
 *
 * With predicate function for keys:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.RecordObjectOf(is.Number, is.String);
 * const a: unknown = {"a": 0, "b": 1};
 * if (isMyType(a)) {
 *   // a is narrowed to Record<string, number>
 *   const _: Record<string, number> = a;
 * }
 * ```
 */
export declare function isRecordObjectOf<T, K extends PropertyKey = PropertyKey>(pred: Predicate<T>, predKey?: Predicate<K>): Predicate<Record<K, T>> & WithMetadata<IsRecordObjectOfMetadata>;
type IsRecordObjectOfMetadata = {
    name: "isRecordObjectOf";
    args: Parameters<typeof isRecordObjectOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` satisfies `Record<K, T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.RecordOf(is.Number);
 * const a: unknown = {"a": 0, "b": 1};
 * if (isMyType(a)) {
 *   // a is narrowed to Record<PropertyKey, number>
 *   const _: Record<PropertyKey, number> = a;
 * }
 * ```
 *
 * With predicate function for keys:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.RecordOf(is.Number, is.String);
 * const a: unknown = {"a": 0, "b": 1};
 * if (isMyType(a)) {
 *   // a is narrowed to Record<string, number>
 *   const _: Record<string, number> = a;
 * }
 * ```
 */
export declare function isRecordOf<T, K extends PropertyKey = PropertyKey>(pred: Predicate<T>, predKey?: Predicate<K>): Predicate<Record<K, T>> & WithMetadata<IsRecordOfMetadata>;
type IsRecordOfMetadata = {
    name: "isRecordOf";
    args: Parameters<typeof isRecordOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` satisfies `Record<K, T>`.
 *
 * @deprecated Use `is.RecordOf()` instead
 */
export declare function isRecordLikeOf<T, K extends PropertyKey = PropertyKey>(pred: Predicate<T>, predKey?: Predicate<K>): Predicate<Record<K, T>> & WithMetadata<IsRecordLikeOfMetadata>;
type IsRecordLikeOfMetadata = {
    name: "isRecordLikeOf";
    args: Parameters<typeof isRecordLikeOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Map<K, T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.MapOf(is.Number);
 * const a: unknown = new Map([["a", 0], ["b", 1]]);
 * if (isMyType(a)) {
 *   // a is narrowed to Map<unknown, number>
 *   const _: Map<unknown, number> = a;
 * }
 * ```
 *
 * With predicate function for keys:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.MapOf(is.Number, is.String);
 * const a: unknown = new Map([["a", 0], ["b", 1]]);
 * if (isMyType(a)) {
 *   // a is narrowed to Map<string, number>
 *   const _: Map<string, number> = a;
 * }
 * ```
 */
export declare function isMapOf<T, K>(pred: Predicate<T>, predKey?: Predicate<K>): Predicate<Map<K, T>> & WithMetadata<IsMapOfMetadata>;
type IsMapOfMetadata = {
    name: "isMapOf";
    args: Parameters<typeof isMapOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `ObjectOf<T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * If `is.OptionalOf()` is specified in the predicate function, the property becomes optional.
 *
 * The number of keys of `x` must be greater than or equal to the number of keys of `predObj`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.ObjectOf({
 *   a: is.Number,
 *   b: is.String,
 *   c: is.OptionalOf(is.Boolean),
 * });
 * const a: unknown = { a: 0, b: "a", other: "other" };
 * if (isMyType(a)) {
 *   // "other" key in `a` is ignored because of `options.strict` is `false`.
 *   // a is narrowed to { a: number; b: string; c?: boolean | undefined }
 *   const _: { a: number; b: string; c?: boolean | undefined } = a;
 * }
 * ```
 */
export declare function isObjectOf<T extends Record<PropertyKey, Predicate<unknown>>>(predObj: T): Predicate<ObjectOf<T>> & WithMetadata<IsObjectOfMetadata>;
/**
 * @deprecated The `option.strict` is deprecated. Use `isStrictOf()` instead.
 */
export declare function isObjectOf<T extends Record<PropertyKey, Predicate<unknown>>>(predObj: T, options: {
    strict?: boolean;
}): Predicate<ObjectOf<T>> & WithMetadata<IsObjectOfMetadata>;
type WithOptional = WithMetadata<GetMetadata<ReturnType<typeof isOptionalOf>>> | {
    optional: true;
};
type ObjectOf<T extends Record<PropertyKey, Predicate<unknown>>> = FlatType<{
    [K in keyof T as T[K] extends WithOptional ? never : K]: T[K] extends Predicate<infer U> ? U : never;
} & {
    [K in keyof T as T[K] extends WithOptional ? K : never]?: T[K] extends Predicate<infer U> ? U : never;
}>;
type IsObjectOfMetadata = {
    name: "isObjectOf";
    args: [Parameters<typeof isObjectOf>[0]];
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is strictly follow the `ObjectOf<T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * If `is.OptionalOf()` is specified in the predicate function, the property becomes optional.
 *
 * The number of keys of `x` must be equal to the number of non optional keys of `predObj`. This is equivalent to
 * the deprecated `options.strict` in `isObjectOf()`.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.StrictOf(is.ObjectOf({
 *   a: is.Number,
 *   b: is.String,
 *   c: is.OptionalOf(is.Boolean),
 * }));
 * const a: unknown = { a: 0, b: "a", other: "other" };
 * if (isMyType(a)) {
 *   // This block will not be executed because of "other" key in `a`.
 * }
 * ```
 */
export declare function isStrictOf<T extends Record<PropertyKey, unknown>>(pred: Predicate<T> & WithMetadata<IsObjectOfMetadata>): Predicate<T> & WithMetadata<IsStrictOfMetadata>;
type IsStrictOfMetadata = {
    name: "isStrictOf";
    args: Parameters<typeof isStrictOf>;
};
/**
 * Return `true` if the type of `x` is instance of `ctor`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.InstanceOf(Date);
 * const a: unknown = new Date();
 * if (isMyType(a)) {
 *   // a is narrowed to Date
 *   const _: Date = a;
 * }
 * ```
 */
export declare function isInstanceOf<T extends new (...args: any) => unknown>(ctor: T): Predicate<InstanceType<T>> & WithMetadata<IsInstanceOfMetadata>;
type IsInstanceOfMetadata = {
    name: "isInstanceOf";
    args: Parameters<typeof isInstanceOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is a literal type of `pred`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.LiteralOf("hello");
 * const a: unknown = "hello";
 * if (isMyType(a)) {
 *   // a is narrowed to "hello"
 *   const _: "hello" = a;
 * }
 * ```
 */
export declare function isLiteralOf<T extends Primitive>(literal: T): Predicate<T> & WithMetadata<IsLiteralOfMetadata>;
type IsLiteralOfMetadata = {
    name: "isLiteralOf";
    args: Parameters<typeof isLiteralOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is one of literal type in `preds`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.LiteralOneOf(["hello", "world"] as const);
 * const a: unknown = "hello";
 * if (isMyType(a)) {
 *   // a is narrowed to "hello" | "world"
 *   const _: "hello" | "world" = a;
 * }
 * ```
 */
export declare function isLiteralOneOf<T extends readonly Primitive[]>(literals: T): Predicate<T[number]> & WithMetadata<IsLiteralOneOfMetadata>;
type IsLiteralOneOfMetadata = {
    name: "isLiteralOneOf";
    args: Parameters<typeof isLiteralOneOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `UnionOf<T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.UnionOf([is.Number, is.String, is.Boolean]);
 * const a: unknown = 0;
 * if (isMyType(a)) {
 *   // a is narrowed to number | string | boolean
 *   const _: number | string | boolean = a;
 * }
 * ```
 *
 * Depending on the version of TypeScript and how values are provided, it may be necessary to add `as const` to the array
 * used as `preds`. If a type error occurs, try adding `as const` as follows:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const preds = [is.Number, is.String, is.Boolean] as const;
 * const isMyType = is.UnionOf(preds);
 * const a: unknown = 0;
 * if (isMyType(a)) {
 *   // a is narrowed to number | string | boolean
 *   const _: number | string | boolean = a;
 * }
 * ```
 */
export declare function isUnionOf<T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]]>(preds: T): Predicate<UnionOf<T>> & WithMetadata<IsUnionOfMetadata>;
type UnionOf<T> = T extends readonly [Predicate<infer U>, ...infer R] ? U | UnionOf<R> : never;
type IsUnionOfMetadata = {
    name: "isUnionOf";
    args: Parameters<typeof isUnionOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `IntersectionOf<T>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.IntersectionOf([
 *   is.ObjectOf({ a: is.Number }),
 *   is.ObjectOf({ b: is.String }),
 * ]);
 * const a: unknown = { a: 0, b: "a" };
 * if (isMyType(a)) {
 *   // a is narrowed to { a: number } & { b: string }
 *   const _: { a: number } & { b: string } = a;
 * }
 * ```
 *
 * Depending on the version of TypeScript and how values are provided, it may be necessary to add `as const` to the array
 * used as `preds`. If a type error occurs, try adding `as const` as follows:
 *
 * ```ts
 * import { is } from "@core/unknownutil";
 *
 * const preds = [
 *   is.ObjectOf({ a: is.Number }),
 *   is.ObjectOf({ b: is.String }),
 * ] as const
 * const isMyType = is.IntersectionOf(preds);
 * const a: unknown = { a: 0, b: "a" };
 * if (isMyType(a)) {
 *   // a is narrowed to { a: number } & { b: string }
 *   const _: { a: number } & { b: string } = a;
 * }
 * ```
 */
export declare function isIntersectionOf<T extends readonly [
    Predicate<unknown> & WithMetadata<IsObjectOfMetadata>,
    ...(Predicate<unknown> & WithMetadata<IsObjectOfMetadata>)[]
]>(preds: T): Predicate<IntersectionOf<T>> & WithMetadata<IsObjectOfMetadata>;
export declare function isIntersectionOf<T extends readonly [Predicate<unknown>]>(preds: T): T[0];
export declare function isIntersectionOf<T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]]>(preds: T): Predicate<IntersectionOf<T>> & WithMetadata<IsIntersectionOfMetadata>;
type IntersectionOf<T> = TupleToIntersection<TupleOf<T>>;
type IsIntersectionOfMetadata = {
    name: "isIntersectionOf";
    args: Parameters<typeof isIntersectionOf>;
};
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Required<ObjectOf<T>>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```typescript
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.RequiredOf(is.ObjectOf({
 *   a: is.Number,
 *   b: is.UnionOf([is.String, is.Undefined]),
 *   c: is.OptionalOf(is.Boolean),
 * }));
 * const a: unknown = { a: 0, b: "b", c: true, other: "other" };
 * if (isMyType(a)) {
 *   // 'a' is narrowed to { a: number; b: string | undefined; c: boolean }
 *   const _: { a: number; b: string | undefined; c: boolean } = a;
 * }
 * ```
 */
export declare function isRequiredOf<T extends Record<PropertyKey, unknown>>(pred: Predicate<T> & WithMetadata<IsObjectOfMetadata>): Predicate<FlatType<Required<T>>> & WithMetadata<IsObjectOfMetadata>;
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Partial<ObjectOf<T>>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```typescript
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.PartialOf(is.ObjectOf({
 *   a: is.Number,
 *   b: is.UnionOf([is.String, is.Undefined]),
 *   c: is.OptionalOf(is.Boolean),
 * }));
 * const a: unknown = { a: undefined, other: "other" };
 * if (isMyType(a)) {
 *   // The "other" key in `a` is ignored.
 *   // 'a' is narrowed to { a?: number | undefined; b?: string | undefined; c?: boolean | undefined }
 *   const _: { a?: number | undefined; b?: string | undefined; c?: boolean | undefined } = a;
 * }
 * ```
 */
export declare function isPartialOf<T extends Record<PropertyKey, unknown>>(pred: Predicate<T> & WithMetadata<IsObjectOfMetadata>): Predicate<FlatType<Partial<T>>> & WithMetadata<IsObjectOfMetadata>;
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Pick<ObjectOf<T>, K>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```typescript
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.PickOf(is.ObjectOf({
 *   a: is.Number,
 *   b: is.String,
 *   c: is.OptionalOf(is.Boolean),
 * }), ["a", "c"]);
 * const a: unknown = { a: 0, b: "a", other: "other" };
 * if (isMyType(a)) {
 *   // The "b" and "other" key in `a` is ignored.
 *   // 'a' is narrowed to { a: number; c?: boolean | undefined }
 *   const _: { a: number; c?: boolean | undefined } = a;
 * }
 * ```
 */
export declare function isPickOf<T extends Record<PropertyKey, unknown>, K extends keyof T>(pred: Predicate<T> & WithMetadata<IsObjectOfMetadata>, keys: K[]): Predicate<FlatType<Pick<T, K>>> & WithMetadata<IsObjectOfMetadata>;
/**
 * Return a type predicate function that returns `true` if the type of `x` is `Omit<ObjectOf<T>, K>`.
 *
 * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
 *
 * ```typescript
 * import { is } from "@core/unknownutil";
 *
 * const isMyType = is.OmitOf(is.ObjectOf({
 *   a: is.Number,
 *   b: is.String,
 *   c: is.OptionalOf(is.Boolean),
 * }), ["a", "c"]);
 * const a: unknown = { a: 0, b: "a", other: "other" };
 * if (isMyType(a)) {
 *   // The "a", "c", and "other" key in `a` is ignored.
 *   // 'a' is narrowed to { b: string }
 *   const _: { b: string } = a;
 * }
 * ```
 */
export declare function isOmitOf<T extends Record<PropertyKey, unknown>, K extends keyof T>(pred: Predicate<T> & WithMetadata<IsObjectOfMetadata>, keys: K[]): Predicate<FlatType<Omit<T, K>>> & WithMetadata<IsObjectOfMetadata>;
/**
 * Return a type predicate function that returns `true` if the type of `x` is `UnionOf<T>`.
 *
 * @deprecated Use `isUnionOf` instead.
 */
export declare function isOneOf<T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]]>(preds: T): Predicate<OneOf<T>>;
type OneOf<T> = T extends readonly [Predicate<infer U>, ...infer R] ? U | OneOf<R> : never;
/**
 * Return a type predicate function that returns `true` if the type of `x` is `IntersectionOf<T>`.
 *
 * @deprecated Use `isIntersectionOf` instead.
 */
export declare function isAllOf<T extends readonly [
    Predicate<unknown> & WithMetadata<IsObjectOfMetadata>,
    ...(Predicate<unknown> & WithMetadata<IsObjectOfMetadata>)[]
]>(preds: T): Predicate<AllOf<T>>;
type AllOf<T> = IntersectionOf<T>;
export declare const is: {
    AllOf: typeof isAllOf;
    Any: typeof isAny;
    Array: typeof isArray;
    ArrayOf: typeof isArrayOf;
    AsyncFunction: typeof isAsyncFunction;
    BigInt: typeof isBigInt;
    Boolean: typeof isBoolean;
    Function: typeof isFunction;
    InstanceOf: typeof isInstanceOf;
    IntersectionOf: typeof isIntersectionOf;
    LiteralOf: typeof isLiteralOf;
    LiteralOneOf: typeof isLiteralOneOf;
    Map: typeof isMap;
    MapOf: typeof isMapOf;
    Null: typeof isNull;
    Nullish: typeof isNullish;
    Number: typeof isNumber;
    ObjectOf: typeof isObjectOf;
    OmitOf: typeof isOmitOf;
    OneOf: typeof isOneOf;
    Optional: typeof isOptional;
    OptionalOf: typeof isOptionalOf;
    ParametersOf: typeof isParametersOf;
    PartialOf: typeof isPartialOf;
    PickOf: typeof isPickOf;
    Primitive: typeof isPrimitive;
    Readonly: typeof isReadonly;
    ReadonlyOf: typeof isReadonlyOf;
    ReadonlyTupleOf: typeof isReadonlyTupleOf;
    ReadonlyUniformTupleOf: typeof isReadonlyUniformTupleOf;
    Record: typeof isRecord;
    RecordLike: typeof isRecordLike;
    RecordLikeOf: typeof isRecordLikeOf;
    RecordObject: typeof isRecordObject;
    RecordObjectOf: typeof isRecordObjectOf;
    RecordOf: typeof isRecordOf;
    RequiredOf: typeof isRequiredOf;
    Set: typeof isSet;
    SetOf: typeof isSetOf;
    StrictOf: typeof isStrictOf;
    String: typeof isString;
    Symbol: typeof isSymbol;
    SyncFunction: typeof isSyncFunction;
    TupleOf: typeof isTupleOf;
    Undefined: typeof isUndefined;
    UniformTupleOf: typeof isUniformTupleOf;
    UnionOf: typeof isUnionOf;
    Unknown: typeof isUnknown;
    UnwrapOptionalOf: typeof isUnwrapOptionalOf;
    UnwrapReadonlyOf: typeof isUnwrapReadonlyOf;
};
export {};
//# sourceMappingURL=is.d.ts.map