Mapped Types

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

type Partial<T> = {
  [P in keyof T]?: T[P];
};

type Required<T> = {
  [P in keyof T]-?: T[P]; // Remove optional modifier
};

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

type ReadonlyUser = Readonly<User>;
// { readonly name: string; readonly age?: number }

type CompleteUser = Required<User>;
// { name: string; age: number }

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

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

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

type PickByType<T, U> = {
  [P in keyof T as T[P] extends U ? P : never]: T[P];
};

interface Mixed {
  name: string;
  age: number;
  active: boolean;
  score: number;
}

type StringProps = PickByType<Mixed, string>;
// { name: string }

type NumberProps = PickByType<Mixed, number>;
// { age: number; score: number }

// Remove readonly
type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

// Remove optional
type Concrete<T> = {
  [P in keyof T]-?: T[P];
};

// Add both
type Frozen<T> = {
  readonly [P in keyof T]-?: T[P];
};

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object
    ? DeepPartial<T[P]>
    : T[P];
};

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? DeepReadonly<T[P]>
    : T[P];
};

interface Config {
  database: {
    host: string;
    port: number;
    credentials: {
      username: string;
      password: string;
    };
  };
}

type PartialConfig = DeepPartial<Config>;
// All properties at all levels are optional

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

interface Form {
  username: string;
  email: string;
  age: number;
}

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

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

type NullableStrings<T> = {
  [P in keyof T]: T[P] extends string ? T[P] | null : T[P];
};

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

type Result = NullableStrings<Data>;
// {
//   name: string | null;
//   age: number;
//   email: string | null;
// }

type Proxied<T> = {
  [P in keyof T]: {
    get(): T[P];
    set(value: T[P]): void;
  };
};

type Prefix<T, P extends string> = {
  [K in keyof T as `${P}${Capitalize<string & K>}`]: T[K];
};

type User = { name: string; age: number };
type OldUser = Prefix<User, 'old'>;
// { oldName: string; oldAge: number }

type OmitByType<T, U> = {
  [P in keyof T as T[P] extends U ? never : P]: T[P];
};

interface Mixed {
  name: string;
  age: number;
  active: boolean;
}

type NoStrings = OmitByType<Mixed, string>;
// { age: number; active: boolean }

type ReadonlyKeys<T> = {
  [P in keyof T]-?: (<F>() => F extends { [Q in P]: T[P] } ? 1 : 2) extends
    (<F>() => F extends { -readonly [Q in P]: T[P] } ? 1 : 2)
    ? never
    : P;
}[keyof T];

type RequiredKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
}[keyof T];

type OptionalKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
}[keyof T];

type FormState<T> = {
  [P in keyof T]: {
    value: T[P];
    error?: string;
    touched: boolean;
  };
};

type Promisify<T> = {
  [P in keyof T]: T[P] extends (...args: infer A) => infer R
    ? (...args: A) => Promise<R>
    : T[P];
};

type Builder<T> = {
  [P in keyof T as `set${Capitalize<string & P>}`]: (value: T[P]) => Builder<T>;
} & {
  build(): T;
};