export type IsAnyOrUnknown<T> = false extends (any extends T ? true : false) ? false : true;
export type IsExactOptionalPropertyTypes = Required<{
    e?: string | undefined;
}>['e'] extends string ? false : true;
export type LoopOver<T> = {
    [K in keyof T]: T[K];
};
type KeyOfMap<T extends Map<unknown, unknown>> = T extends Map<infer U, unknown> ? U : never;
export type KeyOf<T> = T extends Map<any, any> ? KeyOfMap<T> : keyof T;
export type ValueOf<T> = T extends Map<unknown, infer U> ? U : T[keyof T];
export type NonUndefined<T> = T extends undefined ? never : T;
export type Entries<T> = {
    [K in KeyOf<T>]: (T extends Map<unknown, infer U> ? [K, U] : [
        K extends number ? `${K}` : K,
        IsExactOptionalPropertyTypes extends false ? T[K] : T extends {
            [k in K]: unknown;
        } ? T[K] : Required<T>[K] extends NonUndefined<T[K]> ? NonUndefined<T[K]> : T[K]
    ]);
}[KeyOf<T>][];
export type KeyOfUnion<T> = T extends unknown ? keyof T : never;
export type TheSame<T, U> = (T extends U ? U extends T ? true : false : false);
export declare function ObjEntries<T>(obj: T): Entries<T>;
export declare function ObjFromEntries<T, U extends PropertyKey>(entries: Array<readonly [U, T]>): Record<U, T>;
type IsNotRecordOrUnknown<T> = (T extends Record<string, unknown> ? false : unknown extends T ? false : true);
type IsBadParamForObjKeys<T> = (null extends T ? IsNotRecordOrUnknown<T> : undefined extends T ? IsNotRecordOrUnknown<T> : false);
export declare function ObjKeys<T extends true extends IsBadParamForObjKeys<T> ? never : unknown>(obj: T): (IsAnyOrUnknown<T> extends true ? ReturnType<typeof Object.keys> : T extends Map<unknown, unknown> ? KeyOf<T>[] : T extends Record<string, any> ? Array<KeyOf<T> extends infer U ? U extends KeyOf<T> ? U extends string ? U : `${U}` : never : never> : ReturnType<typeof Object.keys>);
export declare function ObjValues<T>(obj: T): ValueOf<T>[];
export declare const twoDigitsMin: (value: string | number) => string;
export declare function trimMultiline(strings: TemplateStringsArray, ...params: unknown[]): string;
export declare function round(n: number, precision?: number): number;
export declare function getRandom(max: number): number;
export declare function getRandom(from: number, to: number): number;
export declare function getRandom(str: string): string;
export declare function getRandom<T>(arr: T[]): T;
export type ThenArg<T> = T extends PromiseLike<infer U> ? ThenArg<U> : T;
export type ExtractGeneric<T> = T extends Array<infer U> ? U : never;
export type ExtractSet<T> = T extends Set<infer U> ? U : never;
export type GeneratorParams<T> = T extends Generator<infer U, infer M, infer A> ? [U, M, A] : never;
export type GuardedType<T> = T extends (e: any) => e is infer U ? U : never;
export declare const wait: (seconds: number) => Promise<void>;
export * from './ExactShape';
export * from './makeUnderLangPropsCreator';
export type NonExactOptional<T> = ({
    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
} & {
    [K in keyof T as undefined extends T[K] ? K : never]: T[K] | undefined;
});
export type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
export * from './branded';
export declare const typeOf: (e: unknown) => string;
export type IsNegative<T extends number> = `${T}` extends `-${string}` ? true : false;
export type IsPositive<T extends number> = (T extends 0 ? false : `${T}` extends `-${string}` ? false : true);
export * from './isArrayLength';
export * from './isArrayIncludes';
export * from './MinTupleLength';
export * from './isTruthy';
export * from './DeepPartial';
export type Combine<T1 extends object, T2 extends object, TKeys extends keyof T2> = (Omit<T1, TKeys> & Pick<T2, TKeys>);
export declare const tuple: <T extends unknown[]>(...params: T) => T;
export * from './Union';
export * from './Unionize';
export * from './unionObject';
export * from './OptionalKeys';
export * from './null-undefined';