TypeScript: Интерфейсы vs Типы

// Простой пример TypeScript
function greet(name: string): string {
    return `Привет, ${name}!`;
}
 
// Это вызовет ошибку при компиляции
const result = greet(42); // Аргумент типа 'number' не может быть присвоен параметру типа 'string'

// Пример интерфейса
interface User {
    id: number;
    name: string;
    age?: number; // Опциональное свойство
    getInfo(): string;
}
 
// Пример типа
type UserType = {
    id: number;
    name: string;
    age?: number;
    getInfo(): string;
};

// Пример гибкой типизации в TypeScript
let flexible: any = "строка";
flexible = 42; // Допустимо, хотя не рекомендуется
flexible = { key: "value" }; // Тоже допустимо
 
// Утверждение типа
const element = document.getElementById('root') as HTMLDivElement;

interface Milkshake {
  name: string;
  price: number;
  getIngredients(): string[];
}
 
// Использование интерфейса
const vanilla: Milkshake = {
  name: 'Vanilla',
  price: 399,
  getIngredients() {
    return ['vanilla', 'ice', 'milk'];
  }
};

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

const user: User = {
  id: 1,
  name: "Анна",
  createdAt: new Date()
};
 
// Ошибка: нельзя присвоить значение свойству "createdAt", т.к. оно доступно только для чтения
// user.createdAt = new Date();

interface Shape {
  color: string;
}
 
interface Square extends Shape {
  sideLength: number;
}
 
const redSquare: Square = {
  color: "red",
  sideLength: 10
};

interface MilkshakeBase {
  name: string;
  price: number;
}
 
interface WithToppings {
  toppings: string[];
}
 
interface Milkshake extends MilkshakeBase, WithToppings {
  getIngredients(): string[];
}
 
const chocolateMilkshake: Milkshake = {
  name: "Chocolate",
  price: 499,
  toppings: ['sprinkles', 'cherry'],
  getIngredients() {
    return ['chocolate', 'ice', 'milk', ...this.toppings];
  }
};

interface Milkshake {
  name: string;
  price: number;
}
 
// В другом файле или модуле
interface Milkshake {
  getIngredients(): string[];
}
 
// Результирующий интерфейс содержит все свойства:
// interface Milkshake {
//   name: string;
//   price: number;
//   getIngredients(): string[];
// }

// Оригинальное определение в библиотеке
interface Window {
  title: string;
}
 
// В вашем коде
interface Window {
  analytics: {
    trackEvent(name: string, properties?: object): void;
  }
}
 
// Теперь window содержит и title, и analytics
window.analytics.trackEvent('page_view');

interface StringMap {
  [key: string]: string;
}
 
const colors: StringMap = {
  red: "#FF0000",
  green: "#00FF00",
  blue: "#0000FF"
};
 
// Можно добавлять любые строковые ключи
colors.yellow = "#FFFF00";

interface ApiResponse {
  status: number;
  message: string;
  [key: string]: any; // Дополнительные поля с любым типом
}
 
const response: ApiResponse = {
  status: 200,
  message: "OK",
  data: { users: [{ id: 1, name: "Алексей" }] },
  pagination: { page: 1, totalPages: 5 }
};

// Типизация API для работы с пользователями
interface UserAPI {
  getUser(id: string): Promise<User>;
  listUsers(page?: number): Promise<User[]>;
  createUser(data: UserCreateData): Promise<User>;
  updateUser(id: string, data: Partial<User>): Promise<User>;
  deleteUser(id: string): Promise<void>;
}
 
interface User {
  id: string;
  username: string;
  email: string;
  createdAt: string;
}
 
interface UserCreateData {
  username: string;
  email: string;
  password: string;
}
 
// Реализация API
class UserService implements UserAPI {
  async getUser(id: string): Promise<User> {
    // Реализация запроса
    return { id, username: 'test', email: '[email protected]', createdAt: new Date().toISOString() };
  }
  
  // Остальные методы...
}

interface SearchFunction {
  (source: string, subString: string): boolean;
}
 
const mySearch: SearchFunction = function(src, sub) {
  return src.search(sub) > -1;
};

interface Counter {
  (start: number): string;
  interval: number;
  reset(): void;
}
 
function createCounter(): Counter {
  const counter = ((start: number) => `Счёт начат с ${start}`) as Counter;
  counter.interval = 123;
  counter.reset = function() { console.log('Сброс счётчика'); };
  return counter;
}
 
const c = createCounter();
console.log(c(10));       // Вызов как функции
console.log(c.interval);  // Доступ к свойству
c.reset();                // Вызов метода

interface Repository<T> {
  get(id: string): Promise<T>;
  list(): Promise<T[]>;
  create(item: Omit<T, 'id'>): Promise<T>;
  update(id: string, item: Partial<T>): Promise<T>;
  delete(id: string): Promise<void>;
}
 
// Использование с конкретным типом
interface Product {
  id: string;
  name: string;
  price: number;
}
 
class ProductRepository implements Repository<Product> {
  // Реализация методов репозитория для продуктов
  async get(id: string): Promise<Product> {
    // ...
    return { id, name: 'Продукт', price: 100 };
  }
  
  // Остальные методы...
}

interface Point {
  x: number;
  y: number;
}
 
class Coordinate {
  x: number;
  y: number;
  
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }
}
 
// Это допустимо, так как структуры совместимы
const point: Point = new Coordinate(10, 20);

type MilkshakeName = string;
 
type Milkshake = {
  name: MilkshakeName;
  price: number;
  getIngredients(): string[];
};

type UserId = string;
type Coordinates = [number, number]; // Тип кортежа
type Status = 'pending' | 'fulfilled' | 'rejected'; // Объединение строковых литералов
 
// Использование
const id: UserId = '12345';
const position: Coordinates = [50.4501, 30.5234]; // Координаты Киева
const orderStatus: Status = 'pending'; // Ограничивает возможные значения

// Примитивные типы
type Age = number;
 
// Объединения
type StringOrNumber = string | number;
 
// Кортежи с фиксированной длиной
type Point = [number, number, number?]; // Последний элемент опциональный
 
// Функциональные типы
type ClickHandler = (event: MouseEvent) => void;
 
// Рекурсивные типы
type TreeNode<T> = {
  value: T;
  left?: TreeNode<T>;
  right?: TreeNode<T>;
};

// Объединение типов (Union Types)
type Result<T> = { success: true; data: T } | { success: false; error: string };
 
// Использование объединения
function handleResult(result: Result<User>) {
  if (result.success) {
    // TypeScript знает, что здесь доступен result.data
    console.log(`Пользователь: ${result.data.name}`);
  } else {
    // TypeScript знает, что здесь доступен result.error
    console.log(`Ошибка: ${result.error}`);
  }
}
 
// Пересечение типов (Intersection Types)
type BaseAddress = {
  street: string;
  city: string;
};
 
type ContactInfo = {
  email: string;
  phone: string;
};
 
type FullAddress = BaseAddress & ContactInfo;
 
// Объект должен содержать все поля из обоих типов
const address: FullAddress = {
  street: "улица Пушкина",
  city: "Москва",
  email: "[email protected]",
  phone: "+7 123 456 78 90"
};

type IsArray<T> = T extends any[] ? true : false;
 
// Использование
type CheckString = IsArray<string>; // false
type CheckArray = IsArray<number[]>; // true
 
// Более практичный пример
type ArrayElementType<T> = T extends (infer U)[] ? U : never;
 
type NumberArrayElement = ArrayElementType<number[]>; // number
type StringArrayElement = ArrayElementType<string[]>; // string
type NotAnArray = ArrayElementType<string>; // never

// Partial<T> - делает все свойства типа T опциональными
interface User {
  id: number;
  name: string;
  email: string;
  role: string;
}
 
// Теперь все поля опциональны
type PartialUser = Partial<User>;
 
// Для обновления пользователя не нужно указывать все поля
function updateUser(id: number, data: PartialUser) {
  // ...
}
 
// Pick<T, K> - выбирает из T только свойства K
type UserCredentials = Pick<User, 'email' | 'id'>;
 
// Omit<T, K> - исключает из T свойства K
type UserWithoutId = Omit<User, 'id'>;
 
// Record<K, T> - создает тип с ключами K и значениями T
type RolePermissions = Record<string, boolean>;
 
const permissions: RolePermissions = {
  'create:user': true,
  'delete:user': false,
};
 
// ReturnType<T> - извлекает возвращаемый тип функции
function createUser(name: string, email: string): User {
  return { id: Date.now(), name, email, role: 'user' };
}
 
type CreatedUser = ReturnType<typeof createUser>; // User

type EventName = 'click' | 'scroll' | 'mousemove';
 
// С помощью шаблонного литерала создаем новые строковые типы
type EventHandler = `on${Capitalize<EventName>}`; // 'onClick' | 'onScroll' | 'onMousemove'
 
// Создание типов для CSS свойств
type CSSValue = number | string;
 
type CSSProperty = 'margin' | 'padding' | 'border';
type CSSDirection = 'Top' | 'Right' | 'Bottom' | 'Left';
 
// Комбинирование для получения всех возможных CSS свойств
type CSSPropertyWithDirection = `${CSSProperty}${CSSDirection}`;
// 'marginTop' | 'marginRight' | ... и т.д.
 
// Для создания типа объекта с этими свойствами
type CSSProperties = {
  [K in CSSPropertyWithDirection]?: CSSValue;
};
 
const styles: CSSProperties = {
  marginTop: 10,
  paddingLeft: '15px',
};

type Greeting = 'Hello, world!';
type ShoutedGreeting = Uppercase<Greeting>; // 'HELLO, WORLD!'
type QuietGreeting = Lowercase<Greeting>; // 'hello, world!'

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};
 
type Optional<T> = {
  [P in keyof T]?: T[P];
};
 
interface User {
  id: number;
  name: string;
  email: string;
}
 
// Все свойства становятся только для чтения
const readonlyUser: Readonly<User> = {
  id: 1,
  name: "Михаил",
  email: "[email protected]"
};
 
// readonlyUser.name = "Иван"; // Ошибка: нельзя изменить свойство "name"

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
 
const user = {
  id: 123,
  name: "Светлана",
  role: "admin"
};
 
// TypeScript знает, что результат будет типа string
const userName = getProperty(user, "name");
 
// Ошибка компиляции: "age" не существует в типе объекта user
// const age = getProperty(user, "age");

type JSONValue = 
  | string 
  | number 
  | boolean 
  | null 
  | JSONValue[] 
  | { [key: string]: JSONValue };
 
// Корректный JSON-объект
const data: JSONValue = {
  name: "Антон",
  age: 30,
  isActive: true,
  hobbies: ["программирование", "музыка"],
  address: {
    city: "Санкт-Петербург",
    zip: 198097
  }
};

type UserID = string & { readonly __brand: unique symbol };
type OrderID = string & { readonly __brand: unique symbol };
 
function createUserID(id: string): UserID {
  return id as UserID;
}
 
function createOrderID(id: string): OrderID {
  return id as OrderID;
}
 
function getUser(id: UserID) {
  // Получение пользователя
}
 
const userId = createUserID("user-123");
const orderId = createOrderID("order-456");
 
getUser(userId); // Работает
// getUser(orderId); // Ошибка типа! OrderID не присваивается к UserID
// getUser("some-string"); // Ошибка типа! string не присваивается к UserID

// С использованием интерфейса
interface User {
  id: number;
  name: string;
  email: string;
}
 
// С использованием типа
type User = {
  id: number;
  name: string;
  email: string;
};

// Наследование интерфейсов
interface BaseUser {
  id: number;
  name: string;
}
 
interface AdminUser extends BaseUser {
  privileges: string[];
}
 
// Композиция типов
type BaseUser = {
  id: number;
  name: string;
}
 
type AdminUser = BaseUser & {
  privileges: string[];
};

interface Window {
  title: string;
}
 
// В другом файле
interface Window {
  analytics: object;
}
 
// Результат: Window имеет оба свойства

type Window = {
  title: string;
};
 
// Ошибка: Дублирующее определение типа 'Window'
type Window = {
  analytics: object;
};

// Примитивный тип
type ID = string;
 
// Объединение
type Status = "pending" | "approved" | "rejected";
 
// Кортеж
type Coordinates = [number, number];

type Keys = "id" | "name";
type UserRecord = { [K in Keys]: string };
// Результат: { id: string; name: string; }

// Ошибка
interface NumericId extends number {}
 
// Работает
type NumericId = number & { __brand: 'numericId' };

// Пример с большим интерфейсом
interface HugeInterface {
  // Сотни свойств...
  prop1: string;
  prop2: number;
  // ...
  prop999: boolean;
}
 
// Аналогичный тип
type HugeType = {
  // Сотни свойств...
  prop1: string;
  prop2: number;
  // ...
  prop999: boolean;
};

// Версия 1.0
interface ApiResponse {
  data: unknown;
  status: number;
}
 
// Версия 2.0 - добавляем новое свойство без поломки
interface ApiResponse {
  pagination?: {
    page: number;
    totalPages: number;
  };
}

// Тесты производительности для сложных структур
interface DeepNestedInterface {
  a: {
    b: {
      c: {
        d: {
          value: string;
        }
      }
    }
  }
}
 
type DeepNestedType = {
  a: {
    b: {
      c: {
        d: {
          value: string;
        }
      }
    }
  }
}

// Библиотечное API с использованием интерфейсов
export interface HTTPClient {
  get<T>(url: string): Promise<T>;
  post<T>(url: string, data: unknown): Promise<T>;
}
 
// Потребители могут расширять интерфейс
declare module 'your-http-library' {
  interface HTTPClient {
    // Добавляем новый метод
    delete<T>(url: string): Promise<T>;
  }
}

interface UserProfile {
  id: string;
  username: string;
  email: string;
  preferences: {
    theme: 'light' | 'dark';
    notifications: boolean;
  };
}

// Библиотека для работы с REST API
interface RestClient {
  get<T>(url: string): Promise<T>;
  post<T>(url: string, data: unknown): Promise<T>;
  put<T>(url: string, data: unknown): Promise<T>;
  delete<T>(url: string): Promise<T>;
}

// В базовом модуле
interface Config {
  apiUrl: string;
}
 
// В модуле аутентификации
interface Config {
  authTokenKey: string;
}
 
// Результат: объединенный интерфейс с обоими свойствами
const config: Config = {
  apiUrl: 'https://api.example.com',
  authTokenKey: 'auth_token'
};

interface Repository<T> {
  find(id: string): Promise<T>;
  findAll(): Promise<T[]>;
  create(entity: Omit<T, 'id'>): Promise<T>;
  update(id: string, entity: Partial<T>): Promise<T>;
  delete(id: string): Promise<void>;
}
 
class UserRepository implements Repository<User> {
  // Реализация методов...
}

// Для примитивов
type UserId = string;
 
// Для объединений
type Status = 'pending' | 'processing' | 'completed' | 'failed';
 
// Для перечислений с вычисляемыми значениями
type HttpStatusCode = 200 | 201 | 400 | 401 | 403 | 404 | 500;

// Преобразования типов
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
 
interface User {
  id: string;
  name: string;
}
 
// Результат: { getId: () => string; getName: () => string }
type UserGetters = Getters<User>;

// Тупел координат
type Coordinates = [number, number];
 
// RGB цвет
type RGB = [number, number, number];
 
// Время в формате [часы, минуты, секунды]
type Time = [number, number, number];

type RequestHandler<T> = (req: Request, res: Response) => Promise<T>;
 
type AsyncValidator<T> = (value: T) => Promise<boolean | string>;
 
type EventCallback = (event: Event) => void;

// Тип, зависящий от значения другого свойства
type ApiResponse<T extends 'success' | 'error'> = T extends 'success' 
  ? { status: 200; data: unknown; message: string }
  : { status: 400 | 401 | 403 | 404 | 500; error: string };
 
function handleResponse<T extends 'success' | 'error'>(response: ApiResponse<T>) {
  if ('data' in response) {
    // TypeScript знает, что это успешный ответ
    console.log(response.data);
  } else {
    // TypeScript знает, что это ответ с ошибкой
    console.error(response.error);
  }
}

// Создаем "брендированные" версии примитивных типов
type CardNumber = string & { __brand: 'CardNumber' };
type CVV = string & { __brand: 'CVV' };
 
function validateCardNumber(card: string): CardNumber {
  if (!/^\d{16}$/.test(card)) {
    throw new Error('Неверный формат номера карты');
  }
  return card as CardNumber;
}
 
function validateCVV(cvv: string): CVV {
  if (!/^\d{3,4}$/.test(cvv)) {
    throw new Error('Неверный формат CVV');
  }
  return cvv as CVV;
}
 
function processPayment(cardNumber: CardNumber, cvv: CVV) {
  // Обработка платежа...
}
 
// Теперь невозможно случайно перепутать аргументы
const card = validateCardNumber('1234567890123456');
const code = validateCVV('123');
processPayment(card, code); // OK
// processPayment(code, card); // Ошибка типа

// Рекурсивный тип для древовидной структуры
type TreeNode<T> = {
  value: T;
  children: TreeNode<T>[];
};
 
// Тип для JSON с поддержкой любого уровня вложенности
type JSONValue = 
  | string 
  | number 
  | boolean 
  | null 
  | JSONValue[] 
  | { [key: string]: JSONValue };

// users.d.ts
declare module 'users-lib' {
  export interface User {
    id: string;
    name: string;
    email: string;
  }
  
  export function getUsers(): Promise<User[]>;
  export function getUserById(id: string): Promise<User>;
}

import { getUserById } from 'users-lib';
 
async function main() {
  const user = await getUserById('123');
  console.log(user.name); // Типобезопасный доступ
}

interface Product {
  name: string;
  price: number;
}
 
interface Creator<T extends Product> {
  createProduct(): T;
}
 
interface Electronics extends Product {
  warranty: number; // месяцы гарантии
}
 
interface Clothing extends Product {
  size: 'S' | 'M' | 'L' | 'XL';
}
 
class ElectronicsCreator implements Creator<Electronics> {
  createProduct(): Electronics {
    return {
      name: 'Smartphone',
      price: 999,
      warranty: 12
    };
  }
}
 
class ClothingCreator implements Creator<Clothing> {
  createProduct(): Clothing {
    return {
      name: 'T-Shirt',
      price: 29.99,
      size: 'M'
    };
  }
}

class Database {
 private static instance: Database | null = null;
 
 // Приватный конструктор не позволяет создавать экземпляры напрямую
 private constructor(
   public readonly uri: string
 ) {}
 
 static connect(uri: string): Database {
   if (!Database.instance) {
     Database.instance = new Database(uri);
   }
   return Database.instance;
 }
 
 query<T>(sql: string): Promise<T[]> {
   console.log(`Выполняется запрос: ${sql}`);
   return Promise.resolve([]) as Promise<T[]>;
 }
}
 
// Использование
const db = Database.connect("mongodb://localhost:27017");
// Повторный вызов вернет тот же экземпляр
const sameDb = Database.connect("sqlite://memory");
console.log(db === sameDb); // true
console.log(db.uri); // "mongodb://localhost:27017"

type EventMap = {
 'login': { username: string; timestamp: Date };
 'logout': { username: string; timestamp: Date };
 'purchase': { productId: string; amount: number; timestamp: Date };
}
 
class EventEmitter<T extends Record<string, any>> {
 private listeners: { [K in keyof T]?: ((data: T[K]) => void)[] } = {};
 
 on<K extends keyof T>(event: K, callback: (data: T[K]) => void): void {
   if (!this.listeners[event]) {
     this.listeners[event] = [];
   }
   this.listeners[event]?.push(callback);
 }
 
 emit<K extends keyof T>(event: K, data: T[K]): void {
   this.listeners[event]?.forEach(callback => callback(data));
 }
}
 
// Использование
const eventBus = new EventEmitter<EventMap>();
 
eventBus.on('login', ({ username, timestamp }) => {
 console.log(`Пользователь ${username} вошел в ${timestamp.toISOString()}`);
});
 
eventBus.emit('login', { 
 username: 'user123', 
 timestamp: new Date() 
});
 
// Типовая ошибка при неправильных данных
// eventBus.emit('purchase', { username: 'user123' }); // Ошибка типа

interface ButtonProps {
 text: string;
 onClick?: () => void;
 variant?: 'primary' | 'secondary' | 'danger';
 disabled?: boolean;
}
 
// Функциональный компонент
const Button: React.FC<ButtonProps> = ({ 
 text, 
 onClick, 
 variant = 'primary', 
 disabled = false 
}) => {
 return (
   <button 
     className={`btn btn-${variant}`}
     onClick={onClick}
     disabled={disabled}
   >
     {text}
   </button>
 );
};
 
// Компонент класса
class ClassButton extends React.Component<ButtonProps, { isHovered: boolean }> {
 state = {
   isHovered: false
 };
 
 render() {
   const { text, onClick, variant = 'primary', disabled = false } = this.props;
   return (
     <button 
       className={`btn btn-${variant} ${this.state.isHovered ? 'hovered' : ''}`}
       onClick={onClick}
       disabled={disabled}
       onMouseEnter={() => this.setState({ isHovered: true })}
       onMouseLeave={() => this.setState({ isHovered: false })}
     >
       {text}
     </button>
   );
 }
}

interface User {
 id: string;
 name: string;
 email: string;
}
 
@Injectable({
 providedIn: 'root'
})
class UserService {
 getUsers(): Observable<User[]> {
   return this.http.get<User[]>('/api/users');
 }
 
 getUserById(id: string): Observable<User> {
   return this.http.get<User>(`/api/users/${id}`);
 }
 
 constructor(private http: HttpClient) {}
}
 
@Component({
 selector: 'app-user-list',
 template: `
   <div *ngFor="let user of users$ | async">
     {{ user.name }} ({{ user.email }})
   </div>
 `
})
class UserListComponent implements OnInit {
 users$: Observable<User[]>;
 
 constructor(private userService: UserService) {}
 
 ngOnInit(): void {
   this.users$ = this.userService.getUsers();
 }
}

interface User {
 id: string;
 name: string;
 email: string;
}
 
// Определение хука с типизацией
function useUsers() {
 const users = ref<User[]>([]);
 const loading = ref(false);
 const error = ref<string | null>(null);
 
 const fetchUsers = async () => {
   loading.value = true;
   try {
     const response = await fetch('/api/users');
     users.value = await response.json();
   } catch (err) {
     error.value = err instanceof Error ? err.message : 'Неизвестная ошибка';
   } finally {
     loading.value = false;
   }
 };
 
 return { users, loading, error, fetchUsers };
}
 
// Использование в компоненте
const UserList = defineComponent({
 setup() {
   const { users, loading, error, fetchUsers } = useUsers();
   
   onMounted(fetchUsers);
   
   return { users, loading, error };
 },
 template: `
   <div v-if="loading">Загрузка...</div>
   <div v-else-if="error">Ошибка: {{ error }}</div>
   <ul v-else>
     <li v-for="user in users" :key="user.id">
       {{ user.name }} ({{ user.email }})
     </li>
   </ul>
 `
});

// Шаг 1: Создайте файлы типов для вашего JavaScript кода
// user.d.ts
interface User {
 id: string;
 name: string;
 email: string;
}
 
// Шаг 2: Включите проверку JavaScript файлов в tsconfig.json
// {
//   "compilerOptions": {
//     "allowJs": true,
//     "checkJs": true
//   }
// }
 
// Шаг 3: Добавляйте JSDoc аннотации в JavaScript файлы
// user-service.js
/**
* @param {string} id
* @returns {Promise<import('./user').User>}
*/
async function getUser(id) {
 const response = await fetch(`/api/users/${id}`);
 return response.json();
}
 
// Шаг 4: Постепенно переименовывайте .js файлы в .ts

// До миграции (JavaScript):
function processUser(user) {
 console.log(`Обработка пользователя: ${user.name}`);
 // ...
}
 
// После добавления типов:
interface User {
 id: string;
 name: string;
 email: string;
}
 
function processUser(user: User) {
 console.log(`Обработка пользователя: ${user.name}`);
 // ...
}

interface UserCreateData {
 name: string;
 email: string;
 password: string;
}
 
interface UserUpdateData {
 name?: string;
 email?: string;
 password?: string;
}
 
// Старый подход (неявно принимает частичные данные)
function updateUser(id, userData) {
 // ...
}
 
// Новый типизированный подход
function updateUser(id: string, userData: Partial<UserCreateData>) {
 // ...
}

// Для объектных структур данных → интерфейсы
interface UserProfile {
  id: string;
  name: string;
  email: string;
}
 
// Для примитивов, объединений, кортежей → типы
type UserId = string;
type Status = 'active' | 'inactive' | 'pending';
type Coordinates = [number, number];

// Пример руководства по стилю кода для команды
/**
 * 1. Используйте интерфейсы для:
 *    - Публичных API
 *    - Объектов, которые будут реализованы классами
 *    - Объектов, которые могут расширяться в будущем
 * 
 * 2. Используйте типы для:
 *    - Объединений, пересечений и сложных типовых конструкций
 *    - Функциональных типов
 *    - Примитивов и их комбинаций
 */