// ❌ `as User` is a compile-time silencer — it does nothing at runtime
const response = await fetch('/api/user')
const user = (await response.json()) as User

// If the API returns { error: 'Not found' }, user.name is undefined at runtime.
// TypeScript does not know. TypeScript cannot know — the types were erased.
console.log(user.name.toUpperCase())  // 💥 TypeError: Cannot read properties of undefined

// ❌ Validate — a boolean tells you nothing; the value is still `unknown`
function validateUser(data: unknown): boolean {
  return typeof (data as any).name === 'string' && typeof (data as any).age === 'number'
}

if (validateUser(data)) {
  // data is still `unknown` here — you have to cast
  const user = data as User  // The cast is no safer than before the check
}

// ✅ Parse — the function returns `User` or throws; knowledge is encoded in the type
function parseUser(data: unknown): User {
  if (
    typeof data !== 'object' || data === null ||
    typeof (data as any).name !== 'string' ||
    typeof (data as any).age !== 'number'
  ) {
    throw new Error(`Invalid user: ${JSON.stringify(data)}`)
  }
  return data as User  // One cast, contained inside the parser — safe
}

const user = parseUser(await response.json())
// user: User — the parse either succeeds or throws; no ambiguity

import { z } from 'zod'

const UserSchema = z.object({
  id:    z.string().uuid(),
  name:  z.string().min(1),
  email: z.string().email(),
  age:   z.number().int().positive().optional(),
  role:  z.enum(['admin', 'user', 'moderator']),
})

// Derive the TypeScript type from the schema — single source of truth
type User = z.infer<typeof UserSchema>
// {
//   id: string;
//   name: string;
//   email: string;
//   age?: number | undefined;
//   role: 'admin' | 'user' | 'moderator';
// }

// .parse() — throws ZodError on invalid input; use in environments where throws are acceptable
try {
  const user = UserSchema.parse(await response.json())
  // user: User — guaranteed valid
} catch (err) {
  if (err instanceof z.ZodError) {
    console.error(err.issues)  // Structured error list with paths and messages
  }
}

// ✅ .safeParse() — never throws; returns a discriminated union
const result = UserSchema.safeParse(await response.json())

if (result.success) {
  const user = result.data  // User — fully typed
  console.log(user.name)
} else {
  const errors = result.error.issues  // ZodIssue[] — structured field errors
  console.error(errors)
}

const BaseItemSchema = z.object({
  id:        z.string().uuid(),
  createdAt: z.string().datetime(),
})

// .extend() — add fields
const UserSchema = BaseItemSchema.extend({
  name:  z.string(),
  email: z.string().email(),
})

// .pick() / .omit() — subset or exclusion
const PublicUserSchema = UserSchema.omit({ email: true })

// .refine() — custom validation with a message
const AgeSchema = z.number().int().refine(n => n >= 0 && n <= 150, {
  message: 'Age must be between 0 and 150',
})

// .superRefine() — multiple issues, access to the full context
const PasswordSchema = z.string().superRefine((val, ctx) => {
  if (val.length < 8) ctx.addIssue({ code: 'too_small', minimum: 8, type: 'string', inclusive: true, message: 'Min 8 chars' })
  if (!/[A-Z]/.test(val)) ctx.addIssue({ code: 'custom', message: 'Must contain uppercase' })
})

// Zod — one import, full library bundled
import { z } from 'zod'
const schema = z.object({ name: z.string() })

// Valibot — modular imports; unused validators are tree-shaken out
import * as v from 'valibot'
const schema = v.object({ name: v.string() })

// Valibot also supports named imports for maximum tree-shaking
import { object, string, parse, safeParse } from 'valibot'
const schema = object({ name: string() })
const result = safeParse(schema, rawData)

// src/env.ts
import { z } from 'zod'

const EnvSchema = z.object({
  NODE_ENV:     z.enum(['development', 'staging', 'production']),
  DATABASE_URL: z.string().url(),
  API_KEY:      z.string().min(1),
  PORT:         z.coerce.number().int().positive().default(3000),
})

// Parse at module initialization — throws on startup if env is invalid
export const env = EnvSchema.parse(process.env)

// Usage — fully typed, no `|| ''` workarounds needed
const db = createConnection(env.DATABASE_URL)  // string
const port = env.PORT  // number (coerced from string)