const foo = {
  x: [1, 2, 3], // number[]
  bar: {
    name: 'fred',
  },
};

   const x: never = 12; //Type 'number' is not assignable to type 'never'.

  type A = 'A';

type AB = 'A' | 'B';
const ab: AB = Math.random() < 0.5 ? 'A' : 'B';
const c:AB="C" // Type '"C"' is not assignable to type 'AB'

interface dogPerson {
  loveDog: true;
}

interface catPerson {
  loveCat: true;
}

type Both = dogPerson & catPerson;
const person1: Both = {
  loveDog: true,
  loveCat: true,
};

interface dogPerson {
  loveDog: true;
}

interface catPerson {
  loveCat: true;
}

interface Both = dogPerson & catPerson;

type K = keyof (dogPerson | catPerson); //  (keyof A) & (keyof B) 
type T= keyof(dogPerson & catPerson) //  (keyof A) | (keyof B)

const a: K = "loveDog"; // Type 'string' is not assignable to type 'never'.
const b: T = 'loveDog'; 

interface dogPerson {
  loveDog: true;
}

interface catPerson {
  loveCat: true;
}

interface Both extends dogPerson{
    loveCat: true
}

interface Point {
  x: number;
  y: number;
}

type PointKeys = keyof Point; // "x"|"y"

function sortBy<K extends keyof T, T>(vals: T[], key: K): T[] {
  // ..
  return [];
}

const pts: Point[] = [{ x: 1, y: 1 }];
sortBy(pts, 'x'); // T: Point[] K:"x"
sortBy(pts, 'y'); // T: Point[] K:"y"
sortBy(pts, 'z'); // T: Point[] K:"z" // Argument of type '"z"' is not assignable to parameter of type 'keyof Point'.

interface Cylinder {
  radius: number;
  height: number;
}

const Cylinder = (radius: number, height: number) => ({ radius, height }); 
// Cannot redeclare block-scoped variable 'Cylinder'.

interface Cylinder {
  radius: number;
  height: number;
}

function calculateVolume(shape: unknown) {
  if (shape instanceof Cylinder) { // 'Cylinder' only refers to a type, but is being used as a value here.
    shape.radius;
  }
}

class Cylinder {
  radius: number;
  height: number;
}

function calculateVolume(shape: unknown) {
  if (shape instanceof Cylinder) { // 'Cylinder' only refers to a type, but is being used as a value here.
    shape.radius;
  }
}

const v = typeof Cylinder; 
console.log(v)// function

type C = InstanceType<typeof Cylinder>; // Cylinder

// type InstanceType<T extends abstract new (...args: any) => any> =
//   T extends abstract new (...args: any) => infer R ? R : any;

interface Person {
  first: string;
  last: string;
}

type PersonEl = Person['first' | 'last'];
type Person2 = Person.first; // Cannot access 'Person.first' because 'Person' is a type, but not a namespace.

type Tuple = [string, number, Date];
type TupleEl = Tuple[number];

type AdminDescriptionItemType = {
  item: DescriptionType;
  name: DescriptionNameType;
  onDelete: (name: DescriptionNameType, id: string) => void;
  onChange: (name: DescriptionNameType, value: string, id: string) => void;
};

export default function AdminDescriptionItem({
  item,
  name,
  onDelete,
  onChange,
}: AdminDescriptionItemType) {
    // ...생략
}

interface Person {
  name: string;
}

const alice: Person = { name: 'Alice' };
const bob = {} as Person;

const alice: Person = {
  name: 'Alice',
  occupation: 'td',
}; // Type '{ name: string; occupation: string; }' is not assignable to type 'Person'.

const bob = {
  name: 'bob',
  occupation: 'js',
} as Person;

const people = ['alice', 'bob', 'jan'].map((name) => ({ name })); // {name:string}[]

const people: Person[] = ['alice', 'bob', 'jan'].map(
  (name): Person => ({ name })
);

document.querySelector('#myButton')?.addEventListener('click', (e) => {
  e.currentTarget;
  const button = e.currentTarget as HTMLButtonElement;
  button;
});

const today = new Date();
const day = today.toLocaleDateString('en', {
  weekday: 'short',
}) as EnKeys;

const Days = {
  Mon: '월',
  Tue: '화',
  Wed: '수',
  Thu: '목',
  Fri: '금',
  Sat: '토',
  Sun: '일',
  Temp: '당일',
} as const;

export type EnKeys = keyof typeof Days;

interface Person {
  name: string;
}
const body = document.body;
const el = body as Person;
// Conversion of type 'HTMLElement' to type 'Person' may be a mistake because neither type sufficiently overlaps with the other. // If this was intentional, convert the expression to 'unknown' first.
const el = body as unkown as Person;