import type { Keys } from "./objects/keys";
export declare type Cast<A, B> = A extends B ? A : B;
export declare type Expand<T> = T extends T ? {
    [P in keyof T]: T[P];
} : never;
export declare type UnionToIntersection<U> = (U extends U ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
export declare type Merge<A, B> = {
    [K in Keys<A> | Keys<B>]: A[K & Keys<A>] | B[K & Keys<B>];
};
export declare type AssignableToType<T, V> = {
    [K in Keys<T>]-?: T[K] extends V ? K : never;
};
export declare type KeysAssignableToType<T, V> = AssignableToType<T, V>[Keys<T>];
export declare type OmitByType<T, V> = Omit<T, KeysAssignableToType<T, V>>;
export declare type RequiredOnly<T> = {
    [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
};
export declare type OptionalOnly<T> = Omit<T, Keys<RequiredOnly<T>>>;
export declare type Constructor<P extends Array<any>, R> = new (...args: P) => R;
export declare type AbstractConstructor<P extends Array<any>, R> = abstract new (...args: P) => R;
export * as C from "./crypto";
export * as F from "./functions";
export * as M from "./math";
export * as O from "./objects";
export * as R from "./random";