keyof и typeof

type User = {
    name: string;
    age: number;
    email: string;
};

type UserKeys = keyof User;
// 'name' | 'age' | 'email'

function getValue<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user = { name: 'Алиса', age: 25 };
getValue(user, 'name'); // string
getValue(user, 'age');  // number
getValue(user, 'xxx');  // ошибка

function hasKey<T extends object>(obj: T, key: string): key is keyof T {
    return key in obj;
}

function update<T, K extends keyof T>(obj: T, key: K, value: T[K]): T {
    return { ...obj, [key]: value };
}

update(user, 'name', 'Боб'); // ок
update(user, 'name', 42);    // ошибка

type Arr = string[];
type Keys = keyof Arr;
// number | 'length' | 'push' | 'pop' | ...

type A = { a: string };
type B = { b: number };

type Keys = keyof (A | B); // never

type Keys = keyof (A & B);
// 'a' | 'b'

const user = { name: 'Алиса', age: 25 };

type User = typeof user;
// { name: string; age: number }

function add(a: number, b: number) {
    return a + b;
}

type Add = typeof add;
// (a: number, b: number) => number

const config = {
    apiUrl: 'https://api.example.com',
    timeout: 5000,
};

type Config = typeof config;
type ConfigKey = keyof typeof config;
// 'apiUrl' | 'timeout'

const STATUS = {
    IDLE: 'idle',
    LOADING: 'loading',
    SUCCESS: 'success',
} as const;

type Status = typeof STATUS[keyof typeof STATUS];
// 'idle' | 'loading' | 'success'

export const Role = {
    Admin: 'admin',
    User: 'user',
    Guest: 'guest',
} as const;

export type Role = typeof Role[keyof typeof Role];

type Form = {
    name: string;
    email: string;
    password: string;
};

function validateField(field: keyof Form, value: string) {
    // ...
}

validateField('name', 'Алиса'); // ок
validateField('xxx', 'А');      // ошибка