Ежедневные типы

// Вам лучше не видеть реализацию этого типа...
// Тут используется много всего, что мы пока что не знаем, то обязательно к этому вернёмся
 
type Awaited<T> = T extends null | undefined
  ? T
  : T extends object & { then(onfulfilled: infer F, ...args: infer _): any; }
    ? F extends (value: infer V, ...args: infer _) => any
      ? Awaited<V>
      : never
    : T;

type A = Awaited<Promise<string>>;
type B = Awaited<Promise<Promise<number>>>;
type C = Awaited<boolean | Promise<number>>;
type D = Awaited<Promise<{
  hello: Promise<string>,
  world: string
}>>

// Сам тип выглядит так
type Partial<T> = {
  [P in keyof T]?: T[P] | undefined;
};

interface User {
  username: string;
  description: string;
};
 
const updateUser = (user: User, update: Partial<User>): User => {
  return { ...user, ...update };
};
 
const user: User = {
  username: "FOCKUSTY",
  description: ""
};
 
const updatedUser = updateUser(user, { description: "CEO, Backend-developer" });

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

interface ICreateUser {
  username: string;
  description?: string
};
 
const createUser = (user: ICreateUser): Required<ICreateUser> => {
  /* some code */
  return {} as Required<ICreateUser>
};
 
const user = createUser({ username: "FOCKUSTY" });

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

type Photo = {
  name: string
  camera: string
  date: string
  location: string
}
 
const DEFAULT_PHOTO: Photo = {
  name: "Some name",
  camera: "Nikon D3500",
  date: new Date().toISOString(),
  location: "Russian, Ufa"
};
 
// Плохо, потому что можно изменять значения

type Photo = {
  name: string
  camera: string
  date: string
  location: string
}
 
const DEFAULT_PHOTO: Readonly<Photo> = {
  name: "Some name",
  camera: "Nikon D3500",
  date: new Date().toISOString(),
  location: "Russian, Ufa"
};
 
DEFAULT_PHOTO.name = "New name";
Cannot assign to 'name' because it is a read-only property.

type Record<K extends keyof any, T> = {
  [P in K]: T
}

type Language = "ru" | "en" | "es";
type TranslationKeys =
  | "title"
  | "description";
type Translation = Record<TranslationKeys, string>;
type Translations = Record<Language, Translation>;
 
const translations: Translations = {
  ru: {
    title: "Заголовок",
    description: "Описание"
  },
  en: {
    title: "Title",
    description: "Description"
  },
  es: {
    title: "Título",
    description: "Descripción"
  }
};
 
const getTranslation = <L extends Language, K extends TranslationKeys>(lang: L, key: K): Translations[L][K] => {
  return translations[lang][key];
};

type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};

interface User {
  id: string;
  name: string;
  created_at: string;
  updated_at?: string;
}
 
type CreateUser = Pick<User, "name">;
 
const user: CreateUser = {
  name: "FOCKUSTY"
};

type Exclude<T, U> = T extends U ? never : T;

type AllConfigs =
  | "date"
  | "name"
  | "dir"
  | "root"
 
type DirConfigs =
  | "dir"
  | "root"
 
type InfoConfigs = Exclude<AllConfigs, DirConfigs>;

type MaybeArray<T> = T | T[];
type MyArray<T> = Exclude<MaybeArray<T>, T>;
 
declare const a: MyArray<"hello">;

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; x: number }
  | { kind: "triangle"; x: number; y: number };
 
type MyType = Exclude<Shape, { kind: "circle" }>

type Omit<T, K extends keyof any> = { // Хотя было бы лучше использовать keyof T
  [P in Exclude<keyof T, K>]: T[P]
};

interface User {
  id: string;
  name: string;
  created_at: string;
  updated_at?: string;
}
 
type UpdateUser = Omit<User, "created_at"|"updated_at">;
 
const user: UpdateUser = {
  id: "123",
  name: "FOCKUSTY",
};