/// <reference types="node" />
/** Makes specified properties required in a type */
export type WithRequired<T, K extends keyof T> = T & {
    [P in K]-?: T[P];
};
/** Makes specified properties optional in a type */
export type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
/** Signifies that the value can be undefined */
export type Optional<T> = T | undefined;
/**
 * Native `Omit` has some known bugs which are not going to be fixed, as it can break backward compatibility, so here
 * is a modern fixed version (https://stackoverflow.com/questions/76616163/omit-seems-broken-on-type-extending-record)
 */
export type Omit<T, K extends PropertyKey> = {
    [P in keyof T as Exclude<P, K>]: T[P];
};
/**
 * Creates a type as one of const array elements.
 *
 * @example
 * const TIME_UNITS = ['hours', 'minutes', 'seconds'] as const;
 * type TimeUnit = OneOf<typeof TIME_UNITS>;
 */
export type OneOf<T extends readonly unknown[]> = T extends readonly (infer K)[] ? K : never;
/** Deeply replaces `Date` and `Buffer` fields to their JSON representation in a type */
export type Serialized<T> = {
    [P in keyof T]: T[P] extends Date ? string : T[P] extends Buffer ? {
        type: 'Buffer';
        data: number[];
    } : Serialized<T[P]>;
};
/** Signifies that a type can be wrapped in a promise */
export type PromiseOrNot<T> = Promise<T> | T;
/** Constructor function */
export type Constructor<T, Args extends any[] = any[]> = {
    new (...args: Args): T;
};
/** Extracts method names of a class */
export type MethodNames<T> = {
    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
}[keyof T];
/**
 * Replaces a key type
 *
 * @example
 * type ExampleType = {a: number, b: string};
 * type ReplacedType = Replace<ExampleType, {b: Date}>;
 */
export type Replace<T, Replacements extends {
    [Key in keyof T]?: Replacements[Key];
}> = {
    [P in keyof T]: P extends keyof Replacements ? Replacements[P] : T[P];
};
/** Like `Partial` but deep */
export type DeepPartial<T> = T extends object ? T extends Date ? T : {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;
/** Like `Required` but deep */
export type RequiredDeep<T> = T extends object ? T extends Date ? T : {
    [P in keyof T]-?: RequiredDeep<T[P]>;
} : T;
/** Selects only public members of a class */
export type Public<T> = {
    [K in keyof T]: T[K];
};
/** Shortened `Record` where keys are always strings */
export type Dict<T> = Record<string, T>;
type TupleSplit<T extends readonly any[], N extends number, Acc extends readonly any[] = []> = Acc['length'] extends N ? [Acc, T] : T extends readonly [infer Head, ...infer Tail] ? TupleSplit<Tail, N, [...Acc, Head]> : [Acc, []];
/** Skips the first N elements of a tuple */
export type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[1];
/**
 * Calls `bind` on function saving original function type
 * @param func function to bind
 * @param thisArg `this` argument
 * @returns bound function
 */
export declare function typedBind<T extends Function>(func: T, thisArg: any): T;
export {};