type Void<T> = T | void;
type Optional<T> = T | null | undefined;
type Nullable<T> = { [P in keyof T]: T[P] | null; };
type Writable<T> = { -readonly [P in keyof T]: T[P] };
type KeyOfType<T, U = any, V = any> = { [K in keyof T]: K extends U ? T[K] extends V ? K : never : never }[keyof T];
type MapOfType<T, U = any, V = any> = { [K in KeyOfType<T, U, V>]: K extends U ? T[K] extends V ? T[K] : never : never };

type Constructor<out T> = new(...args: any[]) => T;
type ConstructorDerived<T> = Pick<T, { [K in keyof T]: T[K] extends new() => any ? never : K }[keyof T]>;

type FunctionType<out T = unknown, in U = unknown> = (...args: U[]) => T;
type FunctionReturn<out T = unknown, in U = any> = (...args: U[]) => T;
type FunctionArgs<in T extends unknown[], out U = unknown> = (...args: T) => U;

type IntBool = boolean | 0 | 1;
type ArrayOf<T> = T | T[];
type FirstOf<T, U = boolean> = T extends U ? [T, ...T[]] : T[] | [U, T, ...T[]];
type Bufferable = string | Buffer;

type AnyObject = Record<string, unknown>;
type PlainObject = Record<string | number | symbol, unknown>;

type StandardMap = Record<string, any>;
type StringMap = Record<string, string | undefined>;
type ObjectMap<T> = Record<string, T | undefined>;
type IterableMap<T> = Record<string, T>;

type PropertyAction<T, U extends string, V extends boolean = false> = {
    [K in keyof T as `${U}${V extends true ? string & K : Capitalize<string & K>}`]: T[K];
};