export declare function isObject(data: unknown): data is Record<string, unknown>;
export declare function isString(data: unknown): data is string;
export declare function isNumber(data: unknown): data is number;
export declare function isNull(data: unknown): data is null;
export declare function isFunction(data: unknown): data is () => unknown;
export declare function isUndefined(data: unknown): data is undefined;
export declare function isBoolean(data: unknown): data is boolean;
export declare function isArrayBuffer(data: unknown): data is ArrayBuffer;
export declare function isArrayBufferView(data: unknown): data is ArrayBufferView;
export declare function isBufferSource(data: unknown): data is BufferSource;
export declare function isStringArray(data: unknown): data is string[];
export declare function assertNumber(data: unknown, name?: string): asserts data is number;
export declare function assertString(data: unknown, name?: string): asserts data is string;
export declare function assertOptionalString(data: unknown, name?: string): asserts data is string | undefined;
export declare function assertBoolean(data: unknown, name?: string): asserts data is boolean;
export declare function assertObject(data: unknown, name?: string): asserts data is Record<string, unknown>;
export declare function assertArray(data: unknown, name?: string): asserts data is unknown[];
export declare function assertArrayBuffer(data: unknown, name?: string): asserts data is ArrayBuffer;
export declare function assertOptionalArrayBuffer(data: unknown, name?: string): asserts data is ArrayBuffer | undefined;
export type TypeDefFunction = (data: unknown) => boolean;
export type TypeDefArray = ["array", TypeDef] | ["array", TypeDef, number] | ["array", TypeDef, {
    min?: number;
    max?: number;
}];
export type TypeDef = (() => TypeDef) | "boolean" | "function" | "null" | "number" | "string" | "undefined" | "unknown" | ["custom", TypeDefFunction] | ["number", {
    min?: number;
    max?: number;
}] | ["|", ...TypeDef[]] | ["?", TypeDef] | TypeDefArray | ["map", TypeDef] | ["tuple", ...TypeDef[]] | ["tuple...", ...TypeDef[], TypeDef] | ["literal", ...string[]] | ["partial", {
    [name: string]: TypeDef;
}] | {
    [name: string]: TypeDef;
};
type RealType<T extends TypeDef> = T extends "boolean" ? boolean : T extends "function" ? () => unknown : T extends "null" ? null : T extends "number" ? number : T extends "string" ? string : T extends "undefined" ? undefined : T extends "unknown" ? unknown : T extends ["?", TypeDef] ? RealType<T[1]> | undefined : T extends ["tuple", TypeDef] ? Array<RealType<T[1]>> : T extends ["array", TypeDef] ? Array<RealType<T[1]>> : T extends {
    [name: string]: TypeDef;
} ? {
    [key in keyof T]: RealType<T[key]>;
} : T extends ["partial", {
    [name: string]: TypeDef;
}] ? Partial<{
    [key in keyof T[1]]: RealType<T[1][key]>;
}> : T extends ["map", TypeDef] ? Record<string, RealType<T[1]>> : T extends ["literal", ...string[]] ? NonNullable<T[1] | T[2] | T[3] | T[4] | T[5] | T[6] | T[7] | T[8] | T[9] | T[10] | T[11] | T[12] | T[13] | T[14] | T[15] | T[16] | T[17] | T[18] | T[19] | T[20]> : unknown;
export declare function isType<T extends TypeDef>(data: unknown, type: T, logErrors?: string | null): data is RealType<T>;
export declare function isType$<T>(data: unknown, type: TypeDef, logErrors?: string | null): data is T;
export declare function assertType<T extends TypeDef>(data: unknown, type: T, prefix?: string): asserts data is RealType<T>;
export declare function assertType$<T>(data: unknown, type: TypeDef, prefix?: string): asserts data is T;
/**
 * Basically, this function checks a `data` against a `type` and returns a `defaultValue`
 * if `data` is not of the expected type.
 *
 * But if the `defaultValue` is a function returning the expected `type`, then `ensureType`
 * can be use to update old data that you have retrieved from local storage, for example.
 *
 * @example
 * ```
 * interface Complex { r: number, i: number }
 * const complex = ensureType<Complex>(data, {r: "number", i: "number"}, { r: 1, i: 0 })
 * ```
 *
 * @example
 * ```
 * interpace PersonVersion1 {
 *   name: string
 *   female: boolean
 * }
 * interpace PersonVersion2 {
 *   name: string
 *   gender: "male" | "female" | "nonbinary" | "unknown"
 * }
 *
 * const data = JSON.parse(LocalStorate.getItem("person") ?? "null")
 * const TypePersonVersion1 = {
 *   name: "string",
 *   female: "boolean"
 * }
 * const TypePersonVersion2 = {
 *   name: "string",
 *   gender: ["literal", "male", "female", "nonbinary", "unknown"]
 * }
 * const person = ensureType<PersonVersion2>(
 *   data,
 *   TypePersonVersion2,
 *   (value: unknown) => {
 *     if (isType<PersonVersion2>(value, TypePersonVersion2)) {
 *       return value
 *     }
 *     if (isType<PersonVersion1>(value, TypePersonVersion1)) {
 *       return {
 *         name: value.name,
 *         gender: value.female === true ? "female" : "unknown"
 *       }
 *     }
 *     return { name: "Anonymous", gender: "unknown" }
 *   }
 * )
 * ```
 *
 * @param data Value with unknown type.
 * @param type The type to check against.
 * @param defaultValue If the type doesn't check, we can return `defaultValue`, or call it if this is a function.
 * @returns A value that is of the expected type.
 */
export declare function ensureType<T>(data: unknown, type: TypeDef, defaultValue: T | ((v: unknown) => T)): T;
export declare function ensureBoolean(data: unknown, defaultValue: boolean): boolean;
export declare function ensureNumber(data: unknown, defaultValue: number): number;
export declare function ensureString(data: unknown, defaultValue: string): string;
export {};
//# sourceMappingURL=guards.d.ts.map