export declare const assertType: <A, B>(..._TYPE: IsEqualType<A, B, [], [TYPE_ERROR: [first: Print<A>, second: Print<B>]]>) => void;
export declare const assertNotType: <A, B>(..._TYPE: IsEqualType<A, B, [A], []>) => void;
export declare type IsEqualType<A, B, True = true, False = false> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? ((<T>() => T extends B ? 1 : 2) extends (<T>() => T extends A ? 1 : 2) ? True : False) : False;
export declare type Print<T> = T extends λ<infer A, infer R> ? λ<A, R> : T extends infer I ? {
    [K in keyof I]: I[K];
} : T;
export declare type λ<TA extends any[] = any[], TR = any> = (...args: TA) => TR;
export declare type Fn<TA extends any[] = any[], TR = any> = (...args: TA) => TR;
/** @deprecated use `Fn` or `λ` instead */
export declare type Fun = λ;
export declare type Primitive = string | number | boolean | symbol | null | undefined;
export declare type FilterKeys<T, F> = Extract<keyof T, keyof {
    [K in keyof T as T[K] extends F ? K : never]: 0;
}>;
export declare type RequiredKeys<T> = Exclude<{
    [K in keyof T]: T[K] extends Required<T>[K] ? K : never;
}[keyof T], undefined>;
export declare type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
/** Any list of the `n`-first elements of `T`. */
export declare type PartialList<T extends any[]> = T extends [infer L, ...infer R] ? [] | [Widen<L>] | [Widen<L>, ...PartialList<R>] : [];
export declare type NarrowList<TStrict extends any[], TLoose extends any[]> = {
    [I in keyof TLoose]: I extends keyof TStrict ? TStrict[I] extends TLoose[I] ? TStrict[I] : TLoose[I] : TLoose[I];
};
export declare type Length<T extends any[]> = T extends {
    length: infer I;
} ? I : never;
export declare type IsLength<T extends any[], N extends number> = T extends {
    length: infer I;
} ? I extends N ? true : false : false;
/**
 * Return a tuple containing the `N` first elements from `T`. If `T` is a tuple
 * its labels will be preserved unless it contains variadic elements.
 */
export declare type Take<T extends any[], N extends number> = Countable<N> extends never ? never : Take_<T, N>;
/** Same as `Take` but doesn't validate that `N` is a valid length. */
export declare type Take_<T extends any[], N extends number> = IsTuple<T> extends false ? TupleOfSize<N, T[number]> : TupleOfSize<N, any> extends Required<[...T, ...any[]]> ? T : number extends T["length"] ? TakeFromVariadic<T, N> : TakeFromTuple<T, N>;
declare type TakeFromTuple<T extends any[], N extends number> = T extends [] ? T : Length<Required<T>> extends N ? T : T extends [...infer H, any?] ? TakeFromTuple<H, N> : never;
declare type TakeFromVariadic<T extends any[], N extends number, F extends any[] = []> = T extends [] ? F : Length<F> extends N ? F : T extends [infer A, ...infer B] ? TakeFromVariadic<B, N, [...F, A]> : never;
declare type Countable<T extends number> = IfElse<OnlyContains<`${T}`, "0123456789">, TrimFront<`${T}`, 0>, never>;
export declare type TakeLast<T extends any[], I extends number> = Length<T> extends I ? T : T extends [any, ...infer S] ? TakeLast<S, I> : never;
export declare type IsTuple<T extends unknown[]> = T[number][] extends Required<T> ? false : true;
export declare type IsUnion<T, U extends T = T> = T extends unknown ? [U] extends [T] ? false : true : false;
export declare type SplitAt<Front extends any[], I extends number, End extends any[] = []> = Length<Front> extends I ? [Front, End] : Front extends [...infer F_, infer L] ? SplitAt<F_, I, [L, ...End]> : never;
export declare type Slice<T extends any[], N extends number, D extends "front" | "back" = "front", S extends any[] = []> = Length<S> extends N ? T : T extends (D extends "front" ? [infer F, ...infer R] : [...infer R, infer F]) ? Slice<R, N, D, [...S, F]> : T;
declare type Widen<T> = T extends string ? string : T extends number ? number : T;
/** Inverse of `Readonly` */
export declare type Mutable<T> = {
    -readonly [K in keyof T]: T[K];
};
/** If `T` is promise then the type it resolves to, otherwise `T`. */
export declare type PromType<T> = T extends PromiseLike<infer I> ? I : T;
export declare type MakeProm<T> = Promise<T extends PromiseLike<infer I> ? I : T>;
export declare type Async<T extends λ> = (...args: Parameters<T>) => MakeProm<ReturnType<T>>;
export declare type StringCase = "camel" | "kebab" | "pascal" | "screaming-snake" | "snake";
export declare type Prefix<STR extends string, PRE extends string, CASE extends StringCase | void = void> = `${PRE}${CASE extends "snake" ? "_" : ""}${CASE extends "camel" ? Capitalize<STR> : STR}`;
export declare type Suffix<STR extends string, SUF extends string, CASE extends StringCase | void = void> = Prefix<SUF, STR, CASE>;
export declare type CamelCase<T extends string> = T extends `_${infer R}` ? `_${CamelCase<R>}` : T extends `-${infer R}` ? `-${CamelCase<R>}` : _Camel<Uncapitalize<T>>;
declare type _Camel<T extends string> = T extends `${infer A}${infer B}${infer C}` ? A extends "_" | "-" ? B extends "_" | "-" ? `${A}${_Camel<`${B}${C}`>}` : `${Uppercase<B>}${_Camel<C>}` : `${A}${_Camel<`${B}${C}`>}` : T;
export declare type PascalCase<T extends string> = Capitalize<CamelCase<T>>;
export declare type SnakeCase<T extends string> = DelimitedCase<T, "_">;
export declare type ScreamingSnakeCase<T extends string> = Uppercase<SnakeCase<T>>;
export declare type KebabCase<T extends string> = DelimitedCase<T, "-">;
declare type DelimitedCase<T extends string, D extends string> = T extends `${infer A}${infer B}${infer C}${infer R}` ? Lowercase<A> extends A ? A extends ("_" | "-") ? `${D}${Lowercase<B>}${DelimitedCase<`${C}${R}`, D>}` : Lowercase<B> extends B ? `${A}${DelimitedCase<`${B}${C}${R}`, D>}` : Lowercase<C> extends C ? `${A}${D}${Lowercase<B>}${C}${DelimitedCase<R, D>}` : `${A}${D}${InvertDelimited<`${B}${C}${R}`, D>}` : `${Lowercase<A>}${DelimitedCase<`${B}${C}${R}`, D>}` : T;
declare type InvertDelimited<T extends string, D extends string> = T extends `${infer A}${infer B}` ? Uppercase<A> extends A ? `${A}${InvertDelimited<B, D>}` : `${D}${DelimitedCase<`${A}${B}`, D>}` : T;
export declare type IsEvenLength<T extends string> = T extends `${string}${string}${infer S}` ? (S extends "" ? true : IsEvenLength<S>) : false;
export declare type Surround<T extends string, S extends string> = SplitEven<S> extends [
    infer A,
    infer B
] ? `${A extends string ? A : never}${T}${B extends string ? B : never}` : never;
export declare type SplitString<T extends string, A extends string[] = []> = T extends `${infer H}${infer T}` ? SplitString<T, [...A, H]> : A;
export declare type SplitEven<T extends string> = EvenLength<SplitString<T>> extends [
    infer A,
    infer B
] ? [
    Join<A extends unknown[] ? A : never, "">,
    Join<B extends unknown[] ? B : never, "">
] : never;
declare type EvenLength<A extends unknown[], B extends unknown[] = []> = A extends [] ? (B extends [] ? [B, A] : never) : (A extends {
    length: infer LA;
} ? (B extends {
    length: infer LB;
} ? (LA extends LB ? [B, A] : (A extends [infer H, ...infer T] ? EvenLength<T, [...B, H]> : never)) : never) : never);
export declare type TupleOfSize<Length extends number, Type = any> = TupleOfSize_<Length, Type>;
declare type TupleOfSize_<L extends number, T, R extends unknown[] = []> = Length<R> extends L ? R : TupleOfSize_<L, T, [...R, T]>;
declare type Contains<T extends string, C extends string> = T extends `${any}${C}${any}` ? true : false;
declare type TrimFront<T extends string, C extends string | number> = T extends `${C}${infer R}` ? TrimFront<R, C> : T;
declare type Chars<T extends string, C extends string = never> = T extends `${infer A}${infer B}` ? Chars<B, C | A> : C;
declare type OnlyContains<T extends string, C extends string | number> = OnlyContains_<T, Chars<`${C}`>>;
declare type OnlyContains_<T extends string, C extends string | number> = T extends `${C}${infer R}` ? OnlyContains_<R, C> : T extends "" ? true : false;
export declare type IsNumberString<T extends string> = IsNumberString_<T extends `-${infer R}` ? R : T>;
declare type IsNumberString_<T extends string> = T extends `-${any}` ? false : T extends `${number}` ? true : false;
export declare type IsIntegerString<T extends string> = IsNumberString<T> extends false ? false : BitNot<Contains<T, ".">>;
export declare type IsNegative<T extends number> = number extends T ? never : IfElse<IsUnion<T>, never, Extends<`${T}`, `-${string}`>>;
/** Create a union containing the integers 0..`T` */
export declare type IntRange<T extends number> = IsNegative<T> extends true ? never : ConstructIntRange<T extends `${"0"}${infer R}` ? R : T>;
declare type ConstructIntRange<L extends number, U extends number = 0, T extends any[] = [any]> = L extends U ? U : ConstructIntRange<L, U | T["length"], [...T, any]>;
/** Parse `T` into number if `T` is a positive base 10 integer. */
export declare type ParseInt<T extends string, MAX extends number = never> = T extends "" ? never : OnlyContains<T, "0123456789"> extends true ? ParseInt_<TrimFront<T, 0>, MAX, []> : never;
declare type ParseInt_<T extends string, M extends number, L extends any[] = []> = `${L["length"]}` extends T ? L["length"] : L["length"] extends M ? never : ParseInt_<T, M, [...L, any]>;
export declare type NOT<T> = boolean extends T ? T : BitNot<T>;
export declare type BitNot<T> = T extends true ? false : true;
export declare type AND<A, B> = Switch<[
    [
        BitOr<LogicFalse<A>, LogicFalse<B>>,
        false
    ],
    [
        BitOr<LogicNull<A>, LogicNull<B>>,
        boolean
    ],
    true
]>;
export declare type BitAnd<A, B> = A extends false ? false : B;
export declare type OR<A extends boolean, B extends boolean> = Switch<[
    [
        BitOr<LogicTrue<A>, LogicTrue<B>>,
        true
    ],
    [
        BitOr<LogicNull<A>, LogicNull<B>>,
        boolean
    ],
    false
]>;
export declare type BitOr<A, B> = A extends true ? true : B;
export declare type XOR<A, B> = Switch<[
    [
        BitOr<LogicNull<A>, LogicNull<B>>,
        boolean
    ],
    BitXor<A, B>
]>;
export declare type BitXor<A, B> = A extends B ? false : true;
export declare type XNOR<A, B> = Switch<[
    [
        BitOr<LogicNull<A>, LogicNull<B>>,
        boolean
    ],
    BitXnor<A, B>
]>;
export declare type BitXnor<A, B> = A extends B ? true : false;
export declare type NOR<A, B> = Switch<[
    [
        BitAnd<LogicFalse<A>, LogicFalse<B>>,
        true
    ],
    [
        BitOr<LogicTrue<A>, LogicTrue<B>>,
        false
    ],
    boolean
]>;
export declare type BitNor<A, B> = A extends true ? false : BitNot<B>;
export declare type NAND<A, B> = Switch<[
    [
        BitOr<LogicFalse<A>, LogicFalse<B>>,
        true
    ],
    [
        BitOr<LogicNull<A>, LogicNull<B>>,
        boolean
    ],
    false
]>;
export declare type BitNand<A, B> = A extends false ? true : BitNot<B>;
export declare type LogicTrue<T> = boolean extends T ? false : T;
export declare type LogicFalse<T> = boolean extends T ? false : BitNot<T>;
export declare type LogicNull<T> = boolean extends T ? true : T extends boolean ? false : true;
/** Equivalent to `A extends B ? true : false` */
export declare type Extends<A, B> = IfElse<IsUnion<A>, [
    A
] extends [B] ? true : false, A extends B ? true : false>;
/** Returns `A` if `T` is `true`, `B` if `false`, and `A` | `B` otherwise. */
export declare type IfElse<T, A, B> = T extends true ? A : B;
export declare type Switch<T extends any[]> = T extends [infer A, ...infer B] ? (A extends [boolean, any] ? (A[0] extends true ? A[1] : Switch<B extends any[] ? B : never>) : A) : never;
export declare type Join<Array extends unknown[], Separator extends string> = Array extends [infer A, ...infer B] ? (B extends [] ? ToString<A> : `${ToString<A>}${Separator}${Join<B, Separator>}`) : "";
declare type JoinInnerArray<T extends unknown[]> = Join<T, ",">;
export declare type ToString<T> = T extends undefined | null | [] ? "" : T extends PositiveInfinity ? "Infinity" : T extends NegativeInfinity ? "-Infinity" : T extends string | number | boolean ? `${T}` : T extends Map<unknown, unknown> ? "[object Map]" : T extends Set<unknown> ? "[object Set]" : T extends Set<unknown> ? "[object Set]" : T extends unknown[] ? JoinInnerArray<T> : T extends WeakMap<any, unknown> ? "[object WeakMap]" : T extends WeakSet<any> ? "[object WeakSet]" : T extends TypedArray | bigint | symbol | ((...args: unknown[]) => unknown) | RegExp | Error | Intl.NumberFormat | typeof globalThis ? string : T extends Promise<unknown> ? "[object Promise]" : T extends DataView ? "[object DataView]" : T extends SharedArrayBuffer ? "[object SharedArrayBuffer]" : T extends ArrayBuffer ? "[object ArrayBuffer]" : T extends Atomics ? "[object Atomics]" : T extends Intl.Collator ? "[object Intl.Collator]" : T extends Intl.DateTimeFormat ? "[object Intl.DateTimeFormat]" : T extends Intl.ListFormat ? "[object Intl.ListFormat]" : T extends Intl.NumberFormat ? "[object Intl.NumberFormat]" : T extends Intl.PluralRules ? "[object Intl.PluralRules]" : T extends Intl.RelativeTimeFormat ? "[object Intl.RelativeTimeFormat]" : T extends {
    toString(): infer R;
} ? (string extends R ? "[object Object]" : ReturnType<T["toString"]>) : T extends object ? "[object Object]" : never;
export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
export declare type PositiveInfinity = 1e999;
export declare type NegativeInfinity = -1e999;
export {};