Mapped Types

type Keys = "a" | "b" | "c";

type Mapped = {
  [K in Keys]: number;
};
// { a: number; b: number; c: number; }

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

// Все свойства становятся boolean
type UserFlags = {
  [K in keyof User]: boolean;
};
// { name: boolean; age: boolean; email: boolean; }

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

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

type PartialUser = MyPartial<User>;
// { name?: string; age?: number; }

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

type Optional<T> = {
  [K in keyof T]?: T[K];  // добавляет ?
};

type Immutable<T> = {
  readonly [K in keyof T]: T[K];  // добавляет readonly
};

type Required<T> = {
  [K in keyof T]-?: T[K];  // удаляет ?
};

type Mutable<T> = {
  -readonly [K in keyof T]: T[K];  // удаляет readonly
};

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

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

type UserGetters = Getters<User>;
// { getName: () => string; getAge: () => number; }

type OnlyStrings<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

interface Mixed {
  name: string;
  age: number;
  email: string;
}

type StringProps = OnlyStrings<Mixed>;
// { name: string; email: string; }

type Nullable<T> = {
  [K in keyof T]: T[K] | null;
};

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

type NullableUser = Nullable<User>;
// { name: string | null; age: number | null; }

type EventHandlers<T> = {
  [K in keyof T as `on${Capitalize<string & K>}Change`]: (value: T[K]) => void;
};

interface Form {
  name: string;
  email: string;
}

type FormHandlers = EventHandlers<Form>;
// { onNameChange: (value: string) => void; onEmailChange: (value: string) => void; }