export declare const tuple: <T extends string[]>(...args: T) => T;
export declare type Serializable = null | undefined | Stringifiable | SerializableList;
export interface Stringifiable {
    toString(): string;
}
export interface SerializableList extends Array<Serializable> {
}
export declare const tupleNum: <T extends number[]>(...args: T) => T;
export declare const tupleEnum: <T extends string[]>(...values: T) => { readonly [K in T[number]]: K; };
export declare type ObjectKey<T> = T extends Record<string, any> ? T[keyof T] : never;
export declare type IsAny<T> = 0 extends 1 & T ? true : false;
export declare type IsNever<T> = [T] extends [never] ? true : false;
export declare type IsNullable<T> = Extract<T, null | undefined> extends never ? false : true;
export declare type IsOptional<T> = Extract<T, undefined> extends never ? false : true;
export declare type IsUnknown<T> = IsNever<T> extends false ? T extends unknown ? unknown extends T ? IsAny<T> extends false ? true : false : false : false : false;
export declare type OnlyKnown<T> = IsAny<T> extends true ? never : IsNever<T> extends true ? never : IsUnknown<T> extends true ? never : T;
export declare type MaybePromise<T> = T | Promise<T>;
export declare type PromiseType<P> = P extends Promise<infer T> ? T : never;
export declare type MaybeArray<T> = T | T[];
export declare type ArrayType<T> = T extends Array<infer N> ? N : T;
export declare type AnyRecord = Record<string, any>;
export declare type IfExtends<Param, Type, IfTrue, IfFalse> = Param extends Type ? IfTrue : IfFalse;
export declare type ObjectUnion<A, B> = {
    [K in keyof (A & B)]: (A & B)[K];
};
export declare type Entries<T> = {
    [K in Extract<keyof T, string>]-?: [K, T[K]];
}[Extract<keyof T, string>][];
export declare type AnyFunction = (...args: any[]) => any;
export declare type Writeable<T> = {
    -readonly [P in keyof T]: T[P];
};
export declare type ForceString<T> = T extends string ? T : never;
export declare type NotString<T> = string extends T ? never : T;
export declare type NullableToPartial<T> = UnionToIntersection<{
    [K in keyof T as IsOptional<T[K]> extends true ? never : K]-?: T[K];
} | {
    [K in keyof T as IsOptional<T[K]> extends true ? K : never]?: T[K];
}>;
export declare type Join<L, R> = {
    [K in keyof ({
        [K in keyof L]: L[K];
    } & {
        [K in keyof R]: R[K];
    })]: ({
        [K in keyof L]: L[K];
    } & {
        [K in keyof R]: R[K];
    })[K];
};
export declare type Merge<L, R> = Omit<L, keyof R> extends infer P ? Join<P, R> : never;
export declare type ExtendList<Dest, Extends> = Extends extends [] ? Dest : Extends extends [infer Item, ...infer Rest] ? ExtendList<Merge<Dest, Item>, Rest> : never;
export declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? {
    [K in keyof R]: R[K];
} : never;
export declare type Simplify<T> = {
    [KeyType in keyof T]: T[KeyType];
};
export declare type ArrayKeys<T> = T extends any[] | ReadonlyArray<any> ? T extends [any, ...infer Tail] ? ArrayKeys<Tail> | Tail['length'] : never : never;
export declare type DeepArrayKeys<T extends any[]> = {
    [K in keyof T]: `${Extract<K, string>}.${ObjectDotNotations<T[K]>}`;
}[number];
export declare type ObjectDotNotations<Obj, Level extends string[] = [], Limit = 3> = Level['length'] extends Limit ? never : Obj extends {
    [K: string]: any;
} ? {
    [K in keyof Obj]: K extends string ? Obj[K] extends {
        [K: string]: any;
    } ? Obj[K] extends any[] ? K | `${K}.${ArrayKeys<Obj[K]>}` | `${K}.${DeepArrayKeys<Obj[K]>}` : K | `${K}.${ObjectDotNotations<Obj[K], [...Level, K]>}` : K : never;
}[keyof Obj] : never;
export declare type TypeLike<T, Level extends ReadonlyArray<number> = [0]> = T extends {
    [K: string]: any;
} ? {
    [K in keyof T]: T[K] extends {
        [K: string]: any;
    } ? Level['length'] extends 2 ? any : T[K] extends AnyFunction ? AnyFunction : TypeLike<T[K], [...Level, 0]> : any;
} : any;