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