My used TypeScript advanced types

utils.d.ts

type Maybe<T> = T | null | undefined;

/**
 * Позволяет переопределить тип свойства {PropertyName} у типа {T} на новое значение {NewValue}
 */
type Override<T, PropertyName extends keyof T, NewValue> = Omit<T, PropertyName> &
  { [K in keyof T]: K extends PropertyName ? NewValue : T[K] };


interface FixedLengthArray<T extends unknown, L extends number> extends Array<T> {
  0: T;
  length: L;
}

type FilterFlags<Base, Condition> = {
  [Key in keyof Base]: Base[Key] extends Condition ? Key : never;
};

type ValueOf<T> = T[keyof T];

type KeyofType<Base, Type> = ValueOf<FilterFlags<Base, Type>>;

// for getting constructor arguments from abstract class
type AbstractContructorParameters<T> = ConstructorParameters<(new (...args: any) => { [x: string]: any; }) & T>;



export type Tuple<T = unknown> = [T] | [T, ...T[]];
export type NoInfer<T> = T extends infer R ? R : never;
export type Branded<K> = K & { readonly __brand: unique symbol };

type Opaque<K extends symbol | string, T> 
	= T & { [X in K]: never };


export type GetKeysByType<T extends Record<string, unknown>, V extends unknown> = ValueOf<{
  [K in keyof T]: T[K] extends V ? K : never;
}>
export type PickType<T extends Record<string, unknown>, V extends unknown> = Pick<T, GetKeysByType<T, V>>
export type OmitType<T extends Record<string, unknown>, V extends unknown> = Omit<T, GetKeysByType<T, V>>
	
type ExtractEnumKeys<T> = ValueOf<
  { [key in keyof T]: key extends string ? key : never }
>

type UnionToIntersection<U> = (
    (
        U extends any ? (k: U) => void : never
    ) extends (
        (k: infer I) => void
    ) ? I : never
);


type KeysOfType<T, SelectedType> = {
  [key in keyof T]: SelectedType extends T[key] ? key : never;
}[keyof T];

type Optional<T> = Partial<Pick<T, KeysOfType<T, undefined>>>;
type Required<T> = Omit<T, KeysOfType<T, undefined>>;




type CommonKeys<T extends object> = keyof T;

type AllKeys<T> = T extends any ? keyof T : never;

type Subtract<A, C> = A extends C ? never : A;
type NonCommonKeys<T extends object> = Subtract<AllKeys<T>, CommonKeys<T>>;

type Merge<T extends object> = {
  [k in CommonKeys<T>]: PickTypeOf<T, k>;
} &
  {
    [k in NonCommonKeys<T>]?: PickTypeOf<T, k>;
  };

  type PickType<T, K extends AllKeys<T>> = T extends { [k in K]?: any }
  ? T[K]
  : undefined;

type PickTypeOf<T, K extends string | number | symbol> = K extends AllKeys<T>
  ? PickType<T, K>
  : never;

// not working
type MergeUnion<T extends object> = {
  [k in AllKeys<T>]: PickType<T, k>;
};


export type UnionToIntersection<Union> = (
	// `extends unknown` is always going to be the case and is used to convert the
	// `Union` into a [distributive conditional
	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
	Union extends unknown
		// The union type is used as the only argument to a function since the union
		// of function arguments is an intersection.
		? (distributedUnion: Union) => void
		// This won't happen.
		: never
		// Infer the `Intersection` type since TypeScript represents the positional
		// arguments of unions of functions as an intersection of the union.
	) extends ((mergedIntersection: infer Intersection) => void)
		? Intersection
		: never;


type AnyObject = Record<string, any>;

type Constructor<T> = new (...args: ConstructorParameters<T>) => InstanceType<T>;

interface AsyncVoidFunction {
  (): Promise<void>;
}

type ExtractEnumKeys<T> = ValueOf<{ [key in keyof T]: key extends string ? key : never }>;

type BeanValue = null | string | number | boolean | Bean[];

type Bean = Record<string, BeanValue>;

type Maybe<T> = Nullable<T> | undefined;

type Nullable<T> = T | null;

type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;