Продвинутые утилиты

type DeepPartial<T> = T extends object
    ? { [K in keyof T]?: DeepPartial<T[K]> }
    : T;

type DeepReadonly<T> = {
    readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

type DeepRequired<T> = T extends object
    ? { [K in keyof T]-?: DeepRequired<T[K]> }
    : T;

type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

type User = { name: string; age: number; email: string };
type UserWithOptionalEmail = Optional<User, 'email'>;

type RequireAtLeastOne<T, K extends keyof T = keyof T> =
    Omit<T, K> & {
        [P in K]-?: Required<Pick<T, P>> & Partial<Omit<T, P>>;
    }[K];

type Filters = RequireAtLeastOne<{ name?: string; age?: number }>;

const f1: Filters = { name: 'Алиса' };
const f2: Filters = { age: 25 };
const f3: Filters = {}; // ошибка

type Mutable<T> = {
    -readonly [K in keyof T]: T[K];
};

type Nullable<T> = { [K in keyof T]: T[K] | null };

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

const Status = {
    Idle: 'idle',
    Loading: 'loading',
} as const;

type Status = ValueOf<typeof Status>;
// 'idle' | 'loading'

type NonEmptyArray<T> = [T, ...T[]];

function head<T>(arr: NonEmptyArray<T>): T {
    return arr[0];
}

head([1, 2, 3]); // ок
head([]);        // ошибка

type UserId = string & { __brand: 'UserId' };

function getUser(id: UserId) {}

getUser('abc' as UserId); // ок

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

type TupleToUnion<T extends readonly any[]> = T[number];

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

type Paths<T> = T extends object
    ? {
          [K in keyof T]: K | `${string & K}.${string & Paths<T[K]>}`;
      }[keyof T]
    : never;

type At<T, P extends string> =
    P extends `${infer K}.${infer R}`
        ? K extends keyof T
            ? At<T[K], R>
            : never
        : P extends keyof T
            ? T[P]
            : never;