TeoreticQuiz

TypeScript

Материал для подготовки к собеседованию (Middle / Senior). TypeScript — надмножество JavaScript со статической типизацией: любой валидный JS является валидным TS. Термины на английском там, где это принято.

Содержание


Что такое TypeScript и зачем

TypeScript (TS) — язык от Microsoft, надстройка над JavaScript, добавляющая статическую типизацию. Код на TS компилируется (транспилируется) в обычный JS компилятором tsc — в рантайме типов уже нет (type erasure, стирание типов).

Зачем нужен:

  • Ошибки типов ловятся на этапе компиляции, а не в рантайме.
  • Автодополнение и подсказки в IDE, безопасный рефакторинг.
  • Самодокументируемый код (типы = контракты).
  • Лучше масштабируется на больших командах/проектах.

Важно понимать: типы существуют только во время разработки/компиляции. Нельзя, например, проверить if (x is MyInterface) в рантайме — интерфейсы стираются. Для проверок в рантайме используют обычный JS (typeof, instanceof, наличие свойства) или библиотеки-валидаторы (zod, io-ts).

TypeScript использует структурную типизацию (duck typing): совместимость определяется по форме (набору свойств), а не по имени типа. Если объект имеет нужные свойства — он подходит, даже если явно не объявлен как этот тип.


Базовые типы

let isDone: boolean = false;
let count: number = 42;
let name: string = "Вася";
let big: bigint = 100n;
let sym: symbol = Symbol("id");
let nothing: null = null;
let notDefined: undefined = undefined;

Type inference (вывод типов). Часто тип указывать не нужно — TS выводит его сам:

let count = 42;        // TS выведет тип number
count = "text";        // ошибка: string не присваивается number

Хорошая практика: не аннотировать то, что TS выводит сам (переменные с инициализацией), но аннотировать границы (параметры функций, возвращаемые значения, публичные API).

strictNullChecks (включён в strict) — null и undefined не входят в другие типы по умолчанию, их нужно указывать явно (через union): string | null.


any, unknown, never, void

Четыре специальных типа, которые часто спрашивают:

  • any — «отключение типизации»: с этим значением можно делать что угодно, TS не проверяет. Использовать по минимуму — это дыра в безопасности типов.
  • unknown — «безопасный any»: значение может быть чем угодно, но перед использованием TS заставит сузить тип (проверить). Правильная замена any для внешних/непроверенных данных.
  • never — тип, у которого нет значений. Возвращают функции, которые никогда не завершаются нормально (бросают исключение или бесконечны). Также появляется при исчерпывающих проверках.
  • void — «функция ничего не возвращает» (возвращает undefined).
let a: any = 5;
a.foo.bar;              // OK для компилятора (но упадёт в рантайме)

let u: unknown = getData();
// u.trim();            // ошибка: сначала нужно проверить тип
if (typeof u === "string") {
  u.trim();             // OK — здесь u сужен до string
}

function fail(msg: string): never {
  throw new Error(msg); // никогда не возвращает значение
}

function log(msg: string): void {
  console.log(msg);
}

never полезен для исчерпывающих проверок (exhaustiveness check) — см. раздел про narrowing.


Массивы, кортежи, enum

let list: number[] = [1, 2, 3];
let list2: Array<number> = [1, 2, 3];   // эквивалентно

// Кортеж (tuple) — массив фиксированной длины с типами по позициям
let pair: [string, number] = ["age", 30];
let [key, value] = pair;                 // key: string, value: number

// Именованные кортежи и rest
type RGB = [red: number, green: number, blue: number];
type Args = [first: string, ...rest: number[]];

Enum — перечисление именованных констант:

enum Direction {
  Up,      // 0
  Down,    // 1
  Left,    // 2
  Right,   // 3
}
let d: Direction = Direction.Up;

enum Status {
  Active = "active",     // строковый enum
  Banned = "banned",
}

Нюанс: обычные enum (и числовые, и строковые) компилируются в объект в рантайме (в отличие от почти всего остального в TS); бесследно стирается только const enum — значения инлайнятся. Многие предпочитают union литеральных типов или as const-объекты вместо enum:

// Вариант 1: union литералов — полностью стирается
type StatusUnion = "active" | "banned";

// Вариант 2: as const-объект (остаётся в рантайме, но без reverse mapping) + тип того же имени
const Status = { Active: "active", Banned: "banned" } as const;
type Status = typeof Status[keyof typeof Status];        // "active" | "banned"

Объекты, interface и type

Описать форму объекта можно через interface или type:

interface User {
  id: number;
  name: string;
  email?: string;          // необязательное свойство
  readonly createdAt: Date; // только для чтения
}

type UserType = {
  id: number;
  name: string;
};

interface vs type

interface type (alias)
Объекты/формы да да
Union/intersection/примитивы/кортежи нет да (type A = B | C)
Расширение extends через & (intersection)
Слияние объявлений (declaration merging) да (два interface с одним именем сливаются) нет
Рекомендация для публичных API и объектов для union, функций, сложных типов
// Расширение
interface Admin extends User { role: string; }
type AdminType = UserType & { role: string };

// Declaration merging (только interface)
interface Window { myGlobal: string; }   // добавит свойство к Window — только в файле-скрипте (без import/export); в модуле нужен `declare global`

Правило по умолчанию: для описания объектов — interface, для всего остального (union, кортежи, функции, mapped/conditional) — type. На практике оба взаимозаменяемы для объектов.

Индексная сигнатура — когда ключи заранее неизвестны:

interface Dictionary {
  [key: string]: number;
}
const scores: Dictionary = { math: 5, physics: 4 };

Union и intersection типы

Union (|) — «одно из»: значение может быть одним из нескольких типов.

type Id = number | string;

function printId(id: Id) {
  if (typeof id === "string") {
    console.log(id.toUpperCase()); // здесь id: string
  } else {
    console.log(id.toFixed(2));    // здесь id: number
  }
}

Intersection (&) — «и то, и другое»: объединяет типы в один, требующий всех свойств.

type Person = { name: string };
type Employee = { company: string };
type Staff = Person & Employee;   // нужны и name, и company

const s: Staff = { name: "Вася", company: "ACME" };

Discriminated union (размеченное объединение) — мощный паттерн: union объектов с общим полем-дискриминатором. Позволяет TS сужать тип по этому полю:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle": return Math.PI * shape.radius ** 2; // shape: circle
    case "square": return shape.side ** 2;              // shape: square
  }
}

Литеральные типы и as const

Литеральные типы — конкретные значения как типы:

let dir: "left" | "right";     // только эти две строки
let one: 1 | 2 | 3;            // только эти числа
dir = "up";                    // ошибка

as const — превращает значения в литеральные и делает всё readonly (полезно для констант и вывода узких типов):

const config = { mode: "dark", version: 2 } as const;
// тип: { readonly mode: "dark"; readonly version: 2 }

const routes = ["home", "about"] as const;
// тип: readonly ["home", "about"], а не string[]
type Route = typeof routes[number]; // "home" | "about"

Сужение типов (narrowing) и type guards

Narrowing — TS сам сужает тип внутри проверок. Механизмы:

function example(x: string | number | Date | { prop: string } | null) {
  if (typeof x === "string") { /* x: string */ }
  if (x instanceof Date) { /* x: Date */ }
  if (typeof x === "object" && x !== null && "prop" in x) { /* x: { prop: string } — сужение по наличию свойства */ }
  if (x === null) { /* x: null */ }
  x = x ?? 0; // здесь убрали null
}

Пользовательский type guard — функция с типом-предикатом arg is Type:

interface Cat { meow(): void }
interface Dog { bark(): void }

function isCat(animal: Cat | Dog): animal is Cat {
  return (animal as Cat).meow !== undefined;
}

function speak(animal: Cat | Dog) {
  if (isCat(animal)) {
    animal.meow();   // TS знает: это Cat
  } else {
    animal.bark();   // это Dog
  }
}

Assertion functions — бросают ошибку, если условие ложно, и после вызова TS сужает тип:

function assert(condition: unknown, msg?: string): asserts condition {
  if (!condition) throw new Error(msg);
}

Exhaustiveness check через never — гарантирует, что обработаны все варианты union:

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle": return Math.PI * shape.radius ** 2;
    case "square": return shape.side ** 2;
    default:
      const _exhaustive: never = shape; // ошибка компиляции, если добавили новый kind и забыли обработать
      return _exhaustive;
  }
}

Функции

// Аннотация параметров и возвращаемого значения
function add(a: number, b: number): number {
  return a + b;
}

// Необязательные и параметры по умолчанию
function greet(name: string, greeting: string = "Привет"): string {
  return `${greeting}, ${name}`;
}
function log(msg: string, level?: string): void {}

// Rest-параметры
function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0);
}

// Тип функции
type BinaryOp = (a: number, b: number) => number;
const multiply: BinaryOp = (a, b) => a * b;

Перегрузки функций (overloads) — несколько сигнатур для одной реализации:

function parse(value: string): string[];
function parse(value: number): number[];
function parse(value: string | number): string[] | number[] {
  return typeof value === "string" ? value.split("") : [value];
}

Нюанс с колбэками: тип возврата void в сигнатуре не запрещает колбэку возвращать значение (оно просто игнорируется).


Дженерики (Generics)

Дженерики — «параметры типа»: позволяют писать переиспользуемый код, сохраняя связь между входными и выходными типами.

function identity<T>(value: T): T {
  return value;
}
identity<string>("hello"); // явно
identity(42);              // T выведется как number

// Дженерик-интерфейс и класс
interface Box<T> {
  value: T;
}
class Container<T> {
  constructor(public item: T) {}
}

Ограничения (constraints) через extends — сузить, какие типы допустимы:

function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}
longest([1, 2], [1, 2, 3]); // OK — у массивов есть length
longest("ab", "abc");        // OK — у строк есть length
// longest(1, 2);            // ошибка — у number нет length

Значения по умолчанию для параметров типа:

interface ApiResponse<T = unknown> {
  data: T;
  status: number;
}

Дженерики — основа utility-типов, коллекций (Array<T>, Map<K, V>, Promise<T>) и типобезопасных API.


keyof, typeof, indexed access

Инструменты для работы с типами «программно»:

interface User {
  id: number;
  name: string;
}

// keyof — union ключей типа
type UserKeys = keyof User;         // "id" | "name"

// typeof — получить ТИП из значения (переменной)
const defaults = { retries: 3, timeout: 1000 };
type Defaults = typeof defaults;    // { retries: number; timeout: number }

// Indexed access — получить тип свойства
type IdType = User["id"];           // number
type ValueType = Defaults[keyof Defaults]; // number

Пример типобезопасного доступа к свойству:

function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
getProp({ id: 1, name: "a" }, "name"); // тип результата: string

Mapped types

Mapped types — создать новый тип, «пройдясь» по ключам существующего (как map для типов):

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

type Optional<T> = {
  [K in keyof T]?: T[K];
};

// Модификаторы можно снимать: -readonly, -?
type Mutable<T> = {
  -readonly [K in keyof T]: T[K];
};

Key remapping (переименование ключей через as):

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};
// { name: string } → { getName: () => string }

Conditional types и infer

Conditional types — «тип-условие»: T extends U ? X : Y.

type IsString<T> = T extends string ? true : false;
type A = IsString<"hi">;   // true
type B = IsString<42>;     // false

// Распределяются по union (distributive)
type NonNull<T> = T extends null | undefined ? never : T;
type C = NonNull<string | null>;  // string

infer — «вытащить» тип из другого типа внутри условия:

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

type R = ReturnType<() => number>;    // number
type E = ElementType<string[]>;       // string

Это то, как устроены встроенные utility-типы (ReturnType, Parameters, Awaited и др.).


Template literal types

Строковые литеральные типы можно комбинировать как шаблонные строки:

type Color = "red" | "blue";
type Shade = "light" | "dark";
type Variant = `${Shade}-${Color}`;   // "light-red" | "light-blue" | "dark-red" | "dark-blue"

type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventName<"click">;  // "onClick"

Встроенные intrinsic-типы для строк: Uppercase, Lowercase, Capitalize, Uncapitalize.


Utility types

Встроенные вспомогательные типы (построены на mapped/conditional):

interface User {
  id: number;
  name: string;
  email: string;
}

Partial<User>;            // все свойства необязательные
Required<User>;           // все обязательные
Readonly<User>;           // все readonly
Pick<User, "id" | "name">;// только id и name
Omit<User, "email">;      // все, кроме email
Record<string, User>;     // объект: строковый ключ → User

// Для union
Exclude<"a" | "b" | "c", "a">;   // "b" | "c"
Extract<"a" | "b", "a" | "z">;   // "a"
NonNullable<string | null>;      // string

// Для функций
ReturnType<() => number>;        // number
Parameters<(a: string) => void>; // [a: string]

// Для промисов
Awaited<Promise<string>>;        // string

Часто используемая связка: Omit + & для «создать тип на основе другого, заменив поле».


Классы

TS расширяет классы JS модификаторами доступа и типами:

class Animal {
  public name: string;              // доступно везде (по умолчанию)
  protected age: number;            // класс и наследники
  private secret: string;           // только этот класс
  readonly species: string;         // только чтение

  constructor(name: string, age: number, species: string) {
    this.name = name;
    this.age = age;
    this.species = species;
    this.secret = "hidden";
  }

  // Сокращённое объявление свойств через параметры конструктора
}

// Короткая форма: модификатор в конструкторе создаёт и присваивает свойство
class Point {
  constructor(
    public x: number,
    public y: number,
    private readonly id: string,
  ) {}
}

private (#) vs private. Модификатор private в TS — только на этапе компиляции (в рантайме поле доступно). Нативные приватные поля JS с # действительно скрыты в рантайме:

class Bank {
  #balance = 0;          // настоящий приватный (рантайм)
  private pin = "1234";  // приватный только для TS
}

Абстрактные классы — нельзя создать напрямую, служат базой:

abstract class Shape {
  abstract area(): number;         // должен реализовать наследник
  describe(): string { return `Площадь: ${this.area()}`; }
}
class Circle extends Shape {
  constructor(private r: number) { super(); }
  area(): number { return Math.PI * this.r ** 2; }
}

Реализация интерфейса — implements:

interface Comparable<T> {
  compareTo(other: T): number;
}
class Money implements Comparable<Money> {
  constructor(public amount: number) {}
  compareTo(other: Money): number { return this.amount - other.amount; }
}

Декораторы

Декораторы — функции, которые изменяют/аннотируют классы, методы, свойства (широко используются в Angular, NestJS, TypeORM). Есть «legacy»-декораторы (флаг experimentalDecorators) и современный стандарт декораторов (Stage 3), поддержанный в TS 5.

// Пример декоратора метода (Stage 3)
function log<This, Args extends any[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext,
) {
  return function (this: This, ...args: Args): Return {
    console.log(`Вызов ${String(context.name)}`);
    return target.call(this, ...args);
  };
}

class Service {
  @log
  doWork(x: number) { return x * 2; }
}

На собеседовании достаточно понимать: декоратор — обёртка над объявлением; типичные применения — DI (@Injectable), маршруты (@Get), ORM-маппинг (@Entity, @Column), валидация.


Модификаторы: readonly, ковариантность, вариантность

readonly — свойство нельзя переприсвоить после инициализации (проверка на этапе компиляции):

interface Config {
  readonly apiUrl: string;
}
const c: Config = { apiUrl: "/api" };
// c.apiUrl = "/v2"; // ошибка

// ReadonlyArray / readonly T[]
const nums: readonly number[] = [1, 2, 3];
// nums.push(4); // ошибка

Ковариантность/контравариантность (кратко). TS проверяет совместимость типов структурно. При наследовании функций:

  • Возвращаемые типы ковариантны — наследник может вернуть более узкий тип.
  • Типы аргументов формально бивариантны для методов (историческое послабление), но при strictFunctionTypes для функций-выражений — контравариантны (аргумент можно расширить).

На практике это редко спрашивают глубоко; достаточно понимать, что подтип можно использовать там, где ожидается супертип (Liskov), и что TS проверяет совместимость по форме.

Пример ковариантности возврата и контравариантности аргумента:

class Animal {} class Dog extends Animal {}

type GetAnimal = () => Animal;
const getDog: () => Dog = () => new Dog();
const g: GetAnimal = getDog;           // OK: Dog — подтип Animal (ковариантность возврата)

type HandleDog = (d: Dog) => void;
const handleAnimal = (a: Animal) => {};
const h: HandleDog = handleAnimal;     // OK при strictFunctionTypes (контравариантность аргумента)

Типизация this

В функциях можно объявить тип this первым «фейковым» параметром (в компиляцию не попадает) — полезно для колбэков/методов, где важен контекст:

interface Button {
  label: string;
  onClick(this: Button): void;   // внутри this гарантированно Button
}

ThisParameterType<T> и OmitThisParameter<T> — utility-типы для работы с типом this. Стрелочные функции своего this не имеют — берут из окружения (как в JS).

Module augmentation (расширение модулей)

Иногда нужно дописать типы к существующему модулю/библиотеке (например, добавить поле в объект Express Request или свойство в глобальный Window). Делается через declare module / declare global (работает благодаря declaration merging для интерфейсов):

// расширяем тип из библиотеки
import "express";
declare module "express" {
  interface Request {
    user?: { id: number; role: string };   // теперь req.user типизирован
  }
}

// расширяем глобальный тип
declare global {
  interface Window {
    analytics: { track(event: string): void };
  }
}
export {};   // делает файл модулем (нужно для declare global)

Это частый приём при интеграции с JS-библиотеками и добавлении своих полей в чужие типы, не трогая исходники.


Type assertions и приведение

Type assertion — «я знаю тип лучше компилятора» (не проверка в рантайме, только подсказка TS):

const el = document.getElementById("app") as HTMLDivElement;
const el2 = <HTMLDivElement>document.getElementById("app"); // старый синтаксис (не в .tsx)

// Non-null assertion — «точно не null/undefined»
const value = maybeNull!;

Важно: assertion не преобразует значение в рантайме (в отличие от type guard, который реально проверяет). Злоупотребление as и ! — способ «обмануть» типизацию и получить рантайм-ошибку.

satisfies (TS 4.9) — проверить, что значение соответствует типу, сохранив его точный (узкий) выведенный тип:

const palette = {
  red: [255, 0, 0],
  green: "#00ff00",
} satisfies Record<string, string | number[]>;
// palette.green — точно string (а не string | number[])

Declaration files и модули

Declaration files (.d.ts) — файлы только с объявлениями типов (без реализации). Описывают типы для JS-библиотек. Многие пакеты поставляют типы через @types/* (DefinitelyTyped):

npm install --save-dev @types/node @types/lodash
// types/global.d.ts — глобальное объявление
declare global {
  interface Window {
    myApp: { version: string };
  }
}
export {};

// объявление модуля без типов
declare module "some-untyped-lib" {
  export function doStuff(x: number): string;
}

Модули: TS использует ES-модули (import/export). import type импортирует только тип (стирается при компиляции):

import type { User } from "./models";   // импорт только для типов
import { fetchUser } from "./api";

tsconfig и компиляция

tsconfig.json управляет компилятором. Ключевые опции:

{
  "compilerOptions": {
    "target": "ES2022",           // в какую версию JS компилировать
    "module": "ESNext",           // система модулей
    "strict": true,               // включает набор строгих проверок
    "noImplicitAny": true,        // запретить неявный any
    "strictNullChecks": true,     // null/undefined учитываются в типах
    "esModuleInterop": true,      // совместимость с CommonJS
    "moduleResolution": "Bundler",
    "outDir": "./dist",
    "sourceMap": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}
  • strict: true — «золотой стандарт»: включает noImplicitAny, strictNullChecks, strictFunctionTypes и др. На собеседовании ожидается, что вы работаете в strict.
  • Компиляция — tsc (или через сборщики: esbuild/swc/Vite — они обычно только транспилируют, а проверку типов делает tsc --noEmit).
  • Type erasure — типы удаляются при компиляции, в рантайме их нет.

Практические паттерны

Частые приёмы, которые ждут на собеседовании Middle/Senior:

Типизация ответа API + сужение неизвестных данных:

interface ApiUser { id: number; name: string; }

async function loadUser(id: number): Promise<ApiUser> {
  const res = await fetch(`/api/users/${id}`);
  const data: unknown = await res.json();   // именно unknown, не any
  // здесь стоит провалидировать data (zod/ручная проверка) перед as
  return data as ApiUser;
}

Утилита «сделать часть полей обязательными/опциональными»:

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

Брендированные (nominal) типы — эмулировать номинальную типизацию поверх структурной, чтобы не перепутать, например, UserId и OrderId:

type UserId = number & { readonly __brand: "UserId" };
const toUserId = (n: number) => n as UserId;

Discriminated unions для состояний (загрузка/успех/ошибка) — типобезопасная работа с UI-состоянием:

type State<T> =
  | { status: "loading" }
  | { status: "success"; data: T }
  | { status: "error"; error: string };

Вероятные вопросы

Чем TypeScript отличается от JavaScript? TS — надмножество JS со статической типизацией; компилируется в JS; типы стираются в рантайме (type erasure).

Что такое структурная типизация? Совместимость типов по форме (набору свойств), а не по имени. Если объект имеет нужные свойства — он подходит.

any vs unknown? any отключает проверки (опасно); unknown — «безопасный any», требует сузить тип перед использованием.

Что такое never? Тип без значений: функции, которые не возвращают (бросают/бесконечны); используется для exhaustiveness check.

interface vs type? Оба описывают объекты. interface умеет declaration merging и extends; type умеет union/intersection/кортежи/примитивы. Для объектов — обычно interface, для остального — type.

Union vs intersection? | — «одно из» (нужно сужать перед использованием); & — «и то, и другое» (все свойства сразу).

Что такое discriminated union? Union объектов с общим полем-дискриминатором (kind), по которому TS сужает тип в switch/if.

Что такое narrowing и type guard? Narrowing — сужение типа внутри проверок (typeof, instanceof, in). Type guard — функция с предикатом arg is Type, помогающая TS сузить тип.

Зачем дженерики? Переиспользуемый типобезопасный код, сохраняющий связь входных/выходных типов; ограничения через extends.

Что делает keyof и typeof (в типах)? keyof T — union ключей типа; typeof value — получить тип из значения.

Что такое mapped type? Тип, построенный обходом ключей другого типа ([K in keyof T]); так сделаны Partial, Readonly и др.

Что такое conditional type и infer? T extends U ? X : Y — тип-условие; infer вытаскивает тип изнутри (например, тип возврата функции). На них построены ReturnType, Parameters, Awaited.

Назови несколько utility types. Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, NonNullable, ReturnType, Parameters, Awaited.

enum — стоит ли использовать? Обычный enum (числовой и строковый) оставляет объект в рантайме, стирается только const enum; часто предпочитают union литералов (стирается полностью) или as const-объект (обычный JS-объект, без reverse mapping).

private (TS) vs # (JS)? private — проверка только на компиляции (в рантайме доступно); # — настоящий приватный член в рантайме.

Что такое as const? Делает значение литеральным и readonly — узкие типы для констант.

Type assertion vs type guard? Assertion (as, !) — только подсказка компилятору без рантайм-проверки; type guard реально проверяет тип в рантайме.

Что такое satisfies? Проверяет соответствие значения типу, но сохраняет точный выведенный тип значения (в отличие от аннотации, которая расширяет).

Что такое .d.ts и @types? Файлы объявлений типов (без реализации) для JS-кода/библиотек; @types/* — типы из DefinitelyTyped.

Что даёт strict: true? Набор строгих проверок (noImplicitAny, strictNullChecks, strictFunctionTypes и др.) — стандарт для качественного TS-кода.

Существуют ли типы в рантайме? Нет — type erasure. Для проверок в рантайме используют typeof/instanceof/наличие свойств или валидаторы (zod).

Что такое брендированные типы? Приём эмуляции номинальной типизации поверх структурной, чтобы различать одинаковые по форме типы (UserId vs OrderId).