import { A, B, C, F, I, L, M, N, O, S, T, U } from 'ts-toolbelt';
import { RuntimeError } from './RuntimeError';
export * from 'ts-toolbelt';
export { T, L, B, A, U, C, N, F, M, I, O, S };
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; } & (T[number] extends "list" ? {
    __list: T[number][];
} : {
    list: T[number][];
}) & (T[number] extends "enum" ? {
    __enum: T[number];
} : {
    enum: T[number];
});
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];
}>;
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 ExtendListDeep<Dest, Extends> = Extends extends [] ? Dest : Extends extends [infer Item, ...infer Rest] ? ExtendListDeep<Merge<Dest, Item>, Rest> : never;
export declare type ExtendList<Dest extends unknown[], Extends extends unknown[]> = [
    ...Dest,
    ...Extends
];
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;
export declare type IsKnown<T> = IsAny<T> extends true ? 0 : IsNever<T> extends true ? 0 : IsUnknown<T> extends true ? 0 : 1;
export declare type BinKnown<T, True, False> = {
    0: False;
    1: True;
}[IsKnown<T>];
export declare type BinAny<T, True, False> = {
    0: False;
    1: True;
}[IsAny<T> extends true ? 0 : 1];
export declare const A_Z: ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "_"];
export declare type A_Z = typeof A_Z[number];
export declare type Name = `${A_Z}${string}`;
export * from './IterationMap';
export declare class TypeAssertionError extends RuntimeError {
    constructor(message?: string, details?: any);
}
export declare type As<T, L> = A.Cast<T, L>;
export declare type Cast<T, L> = A.Cast<T, L>;