function format(value: string | number) {
  if (typeof value === 'string') {
    return value.toUpperCase()  // string으로 좁혀짐
  }
  return value.toFixed(2)       // number로 좁혀짐
}

class ApiError extends Error {
  constructor(public code: number, message: string) {
    super(message)
  }
}

function handleError(err: unknown) {
  if (err instanceof ApiError) {
    console.error(`API 오류 ${err.code}: ${err.message}`)
  } else if (err instanceof Error) {
    console.error(err.message)
  } else {
    console.error('알 수 없는 오류')
  }
}

interface Cat { meow(): void }
interface Dog { bark(): void }

function makeSound(animal: Cat | Dog) {
  if ('meow' in animal) {
    animal.meow()  // Cat으로 좁혀짐
  } else {
    animal.bark()  // Dog으로 좁혀짐
  }
}

interface User   { type: 'user';  name: string }
interface Admin  { type: 'admin'; name: string; permissions: string[] }

type Person = User | Admin

function isAdmin(person: Person): person is Admin {
  return person.type === 'admin'
}

function greet(person: Person) {
  if (isAdmin(person)) {
    // Admin으로 좁혀짐
    console.log(`관리자 ${person.name}, 권한: ${person.permissions.join(', ')}`)
  } else {
    // User로 좁혀짐
    console.log(`사용자 ${person.name}`)
  }
}

interface ApiUser {
  id: number
  name: string
  email: string
}

function isApiUser(data: unknown): data is ApiUser {
  return (
    typeof data === 'object' &&
    data !== null &&
    typeof (data as any).id === 'number' &&
    typeof (data as any).name === 'string' &&
    typeof (data as any).email === 'string'
  )
}

async function fetchUser(id: number) {
  const res = await fetch(`/api/users/${id}`)
  const data: unknown = await res.json()

  if (!isApiUser(data)) {
    throw new Error('잘못된 API 응답')
  }

  // 여기서부터 data는 ApiUser
  return data
}

function assertIsString(val: unknown): asserts val is string {
  if (typeof val !== 'string') {
    throw new TypeError(`Expected string, got ${typeof val}`)
  }
}

function processInput(input: unknown) {
  assertIsString(input)
  // 여기서부터 input은 string
  console.log(input.toUpperCase())
}

import { z } from 'zod'

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
})

type User = z.infer<typeof UserSchema>  // 스키마에서 타입 자동 추출

const parsed = UserSchema.safeParse(apiResponse)
if (parsed.success) {
  console.log(parsed.data.name)  // User 타입으로 좁혀짐
}