Rozdzielne typy warunkowe

type Wrap<T> = T extends any ? { value: T } : never;
type R = Wrap<string | number>;
// = { value: string } | { value: number }

type Bare<T> = T extends string ? 'yes' : 'no';
type Wrapped<T> = [T] extends [string] ? 'yes' : 'no';
type B = Bare<'a' | 'b'>; // 'yes' | 'yes' = 'yes'
type W = Wrapped<'a' | 'b'>; // 'no' — treated as a tuple

type StringsOnly<T> = T extends string ? T : never;
type S = StringsOnly<string | number | boolean>; // string

type Extract<T, U> = T extends U ? T : never;
type E = Extract<string | number | boolean, string | number>; // string | number

type Exclude<T, U> = T extends U ? never : T;
type Ex = Exclude<string | number | boolean, boolean>; // string | number

type ToArray<T> = T extends any ? T[] : never;
type R = ToArray<string | number>; // string[] | number[]

type IsUnion<T> = [T] extends [T] ? [T] extends [Exclude<T, T>] ? false : true : false;

type PickByValue<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K]
};

type Fn = (() => string) | (() => number);
type R = ReturnType<Fn>; // string | number