Дженерик-типы и интерфейсы

type Box<T> = {
    value: T;
};

const stringBox: Box<string> = { value: 'hello' };
const numberBox: Box<number> = { value: 42 };

interface Box<T> {
    value: T;
}

type Pair<K, V> = {
    key: K;
    value: V;
};

const entry: Pair<string, number> = { key: 'age', value: 25 };

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

const r1: ApiResponse = { data: 'any', status: 200 };
const r2: ApiResponse<User> = { data: user, status: 200 };

type Repository<T extends { id: number }> = {
    find(id: number): T | undefined;
    save(item: T): void;
};

type Container<T> = {
    items: T[];
};

type Nested = Container<Container<string>>;
// { items: { items: string[] }[] }

type List<T> = T[];
type Dict<V> = Record<string, V>;

type Users = List<User>;
type UserById = Dict<User>;

type Mapper<Input, Output> = (input: Input) => Output;

const toString: Mapper<number, string> = (n) => n.toString();

type Result<T, E = Error> =
    | { ok: true; value: T }
    | { ok: false; error: E };

function parseNumber(s: string): Result<number> {
    const n = Number(s);
    return Number.isNaN(n)
        ? { ok: false, error: new Error('NaN') }
        : { ok: true, value: n };
}

type Paginated<T> = {
    data: T[];
    total: number;
    page: number;
    perPage: number;
};

type PaginatedUsers = Paginated<User>;

type AsyncState<T> =
    | { status: 'idle' }
    | { status: 'loading' }
    | { status: 'success'; data: T }
    | { status: 'error'; error: Error };

type UserState = AsyncState<User>;

type TreeNode<T> = {
    value: T;
    children: TreeNode<T>[];
};

type WithLoading<T> = T & { loading: boolean };

const user: WithLoading<User> = {
    name: 'Алиса',
    loading: false,
};

type UpdatePayload<T> = Partial<Omit<T, 'id' | 'createdAt'>>;

type UserUpdate = UpdatePayload<User>;