Объясните type-level programming в TypeScript: что это, как работает и когда применять.

type NonNull<T> = T extends null | undefined ? never : T;
type A = NonNull<string | null>; // string  ← ran per-member, never dropped out

type IsNever<T> = [T] extends [never] ? true : false; // [ ] disables distribution

type Mutable<T> = { -readonly [K in keyof T]: T[K] };        // strip readonly
type Getters<T> = { [K in keyof T & string as `get${Capitalize<K>}`]: () => T[K] };

type ElementOf<T> = T extends readonly (infer E)[] ? E : never;
type Un = ElementOf<number[]>; // number

// Split a route string into its segments — string parsing at the type level
type Split<S extends string> =
  S extends `${infer Head}/${infer Tail}` ? [Head, ...Split<Tail>] : [S];
type R = Split<'users/:id/posts'>; // ['users', ':id', 'posts']

// A recursive DeepReadonly — mapped + conditional + recursion together
type DeepReadonly<T> = T extends (infer E)[]
  ? ReadonlyArray<DeepReadonly<E>>
  : T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T; // primitives bottom out the recursion

type Config = { db: { host: string; ports: number[] } };
type Frozen = DeepReadonly<Config>;
// { readonly db: { readonly host: string; readonly ports: readonly number[] } }

// Template-literal + infer as a typed string parser (real use: typed i18n keys)
type Params<S extends string> =
  S extends `${string}:${infer P}/${infer Rest}` ? P | Params<Rest>
  : S extends `${string}:${infer P}` ? P
  : never;
type P = Params<'/users/:userId/posts/:postId'>; // 'userId' | 'postId'