infer и извлечение типов

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<string[]>; // string
type B = ElementType<number[]>; // number

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type A = ReturnType<() => string>;         // string
type B = ReturnType<(x: number) => void>;  // void

type Parameters<T> = T extends (...args: infer P) => any ? P : never;

type A = Parameters<(a: number, b: string) => void>;
// [number, string]

type Unwrap<T> = T extends Promise<infer U> ? U : T;

type A = Unwrap<Promise<string>>; // string
type B = Unwrap<number>;          // number

type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never;

type A = First<[string, number, boolean]>; // string

type Last<T extends any[]> = T extends [...any[], infer L] ? L : never;

type A = Last<[string, number, boolean]>; // boolean

type GetProp<T, K extends keyof T> = T extends { [P in K]: infer V } ? V : never;

type UnwrapPromise<T> = T extends Promise<infer U> ? UnwrapPromise<U> : T;

type IsArray<T> = T extends any[] ? true : false;
type ArrayElement<T> = T extends (infer U)[] ? U : never;

type PropsOf<T> = T extends React.Component<infer P> ? P : never;

type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;

type A = Awaited<Promise<Promise<string>>>; // string

type UnpackPromise<T> = T extends Promise<infer U> ? U : T;
type UnpackArray<T> = T extends (infer U)[] ? U : T;
type UnpackFunction<T> = T extends (...args: any[]) => infer R ? R : T;

type Flatten<T> = T extends (infer U)[] ? Flatten<U> : T;

type A = Flatten<string[][]>; // string
type B = Flatten<number[][][]>; // number

type EventType<T> = T extends { type: infer U } ? U : never;

type LoginEvent = { type: 'login'; userId: number };
type LogoutEvent = { type: 'logout'; userId: number };

type A = EventType<LoginEvent>; // 'login'
type B = EventType<LogoutEvent>; // 'logout'

type InferSchema<T> = T extends { parse: (input: unknown) => infer U } ? U : never;