interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

// All fields required — you must provide everything
const fullUser: User = { id: 1, name: 'Alice', email: 'alice@example.com', age: 30 };

// Partial — provide only what you want to update
function updateUser(id: number, changes: Partial<User>): User {
  const existing = getUserById(id);
  return { ...existing, ...changes };
}

updateUser(1, { name: 'Alicia' });           // OK
updateUser(1, { email: 'new@example.com' }); // OK
updateUser(1, { age: 31, name: 'Alicia' });  // OK

// Real-world: form state where fields are filled in gradually
type UserFormState = Partial<User>;
const formState: UserFormState = {}; // valid — all optional

interface Config {
  host?: string;
  port?: number;
  debug?: boolean;
}

// Required<Config> — all fields must be provided
type StrictConfig = Required<Config>;
// { host: string; port: number; debug: boolean }

// Useful for validating that a config has been fully resolved
function startServer(config: StrictConfig) {
  console.log(`Starting on ${config.host}:${config.port}`);
}

const defaults: Config = { host: 'localhost', port: 3000, debug: false };
const resolved = defaults as Required<Config>;
startServer(resolved); // OK

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

const origin: Readonly<Point> = { x: 0, y: 0 };
// origin.x = 5; // Error: Cannot assign to 'x' because it is a read-only property.

// Useful for configuration objects, constants, and immutable state
type ImmutableUser = Readonly<User>;

// Note: Readonly is shallow — nested objects are still mutable
interface Tree {
  value: number;
  children: Tree[];
}
const tree: Readonly<Tree> = { value: 1, children: [] };
tree.children.push({ value: 2, children: [] }); // Still works! Readonly is shallow.

// For deep immutability, use a recursive utility type or libraries like immer

// Simple dictionary
const cache: Record<string, unknown> = {};

// Typed dictionary with union key
type Country = 'US' | 'UK' | 'CA';
type CurrencyMap = Record<Country, string>;
const currencies: CurrencyMap = {
  US: 'USD',
  UK: 'GBP',
  CA: 'CAD',
};
// Missing 'CA' would be a type error

// Index-based lookup table
type HttpStatusMap = Record<number, string>;
const statusMessages: HttpStatusMap = {
  200: 'OK',
  404: 'Not Found',
  500: 'Internal Server Error',
};

// Nested Record
type Matrix = Record<string, Record<string, number>>;

// Record is equivalent to an index signature with a union key
// { [K in Country]: string } is the same as Record<Country, string>

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
  createdAt: Date;
}

// Only expose safe public fields
type PublicUser = Pick<User, 'id' | 'name' | 'email'>;
// { id: number; name: string; email: string }

// Pick for form types
type UserRegistrationForm = Pick<User, 'name' | 'email' | 'password'>;

// Works with function props too
interface ButtonProps {
  onClick: () => void;
  disabled?: boolean;
  label: string;
  variant: 'primary' | 'secondary';
  size: 'sm' | 'md' | 'lg';
}
type MinimalButtonProps = Pick<ButtonProps, 'onClick' | 'label'>;

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
  createdAt: Date;
}

// Remove sensitive fields for public API response
type SafeUser = Omit<User, 'password'>;
// { id: number; name: string; email: string; createdAt: Date }

// Remove auto-generated fields for creation payloads
type CreateUserPayload = Omit<User, 'id' | 'createdAt'>;
// { name: string; email: string; password: string }

// Useful when you want most fields but a few should change type
type UserUpdate = Omit<User, 'id' | 'createdAt'> & {
  id?: number; // make id optional for updates
};

type AllStatus = 'active' | 'inactive' | 'pending' | 'deleted';

// Remove 'deleted' from the usable statuses
type ActiveStatus = Exclude<AllStatus, 'deleted'>;
// 'active' | 'inactive' | 'pending'

// Remove multiple members
type VisibleStatus = Exclude<AllStatus, 'deleted' | 'inactive'>;
// 'active' | 'pending'

// Remove primitive types from a union
type OnlyStrings = Exclude<string | number | boolean, number | boolean>;
// string

// Exclude is used internally to implement Omit
// Omit<T, K> = Pick<T, Exclude<keyof T, K>>

// Useful for narrowing event handler types
type MouseEvents = 'click' | 'dblclick' | 'mousedown' | 'mouseup';
type ClickEvents = Exclude<MouseEvents, 'mousedown' | 'mouseup'>;
// 'click' | 'dblclick'

type Mixed = string | number | boolean | null | undefined;

// Keep only the falsy types
type Falsy = Extract<Mixed, null | undefined | false | 0 | ''>;
// null | undefined (false/0/'' are not in Mixed)

// Extract only string or number types
type Primitives = Extract<Mixed, string | number>;
// string | number

// Extract discriminated union members
type Action =
  | { type: 'fetch'; url: string }
  | { type: 'save'; data: unknown }
  | { type: 'delete'; id: number };

type FetchAction = Extract<Action, { type: 'fetch' }>;
// { type: 'fetch'; url: string }

type MutatingActions = Extract<Action, { type: 'save' | 'delete' }>;
// { type: 'save'; data: unknown } | { type: 'delete'; id: number }

type MaybeString = string | null | undefined;
type DefiniteString = NonNullable<MaybeString>; // string

// Practical use: after filtering out nulls
function compact<T>(arr: (T | null | undefined)[]): NonNullable<T>[] {
  return arr.filter((x): x is NonNullable<T> => x != null);
}

const items = ['Alice', null, 'Bob', undefined, 'Charlie'];
const names = compact(items); // string[]

// Useful with mapped types to remove nullability from all fields
type DeNullified<T> = {
  [K in keyof T]: NonNullable<T[K]>;
};

function createUser(name: string, age: number) {
  return { id: Math.random(), name, age, createdAt: new Date() };
}

// Instead of duplicating the return type definition:
type CreatedUser = ReturnType<typeof createUser>;
// { id: number; name: string; age: number; createdAt: Date }

// Works great with factory functions
function makeStore() {
  return {
    count: 0,
    increment() { this.count++; },
    decrement() { this.count--; },
  };
}
type Store = ReturnType<typeof makeStore>;

// Works with async functions
async function fetchUser(id: number) {
  const response = await fetch(`/api/users/${id}`);
  return response.json() as Promise<{ id: number; name: string }>;
}
type FetchUserResult = Awaited<ReturnType<typeof fetchUser>>;
// { id: number; name: string }

function createUser(name: string, age: number, email: string): void {}

type CreateUserParams = Parameters<typeof createUser>;
// [name: string, age: number, email: string]

// Access individual parameters
type NameParam = Parameters<typeof createUser>[0]; // string
type AgeParam  = Parameters<typeof createUser>[1]; // number

// Use case: creating a memoize wrapper
function memoize<T extends (...args: unknown[]) => unknown>(fn: T) {
  const cache = new Map<string, ReturnType<T>>();
  return (...args: Parameters<T>): ReturnType<T> => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key) as ReturnType<T>;
    const result = fn(...args) as ReturnType<T>;
    cache.set(key, result);
    return result;
  };
}

// Spread parameters from a tuple
type Fn = (a: string, b: number) => boolean;
type FnArgs = Parameters<Fn>; // [string, number]
declare function callWith(fn: Fn, args: FnArgs): boolean;

class HttpClient {
  constructor(
    private baseUrl: string,
    private timeout: number = 5000,
    private headers: Record<string, string> = {}
  ) {}
}

type HttpClientArgs = ConstructorParameters<typeof HttpClient>;
// [baseUrl: string, timeout?: number, headers?: Record<string, string>]

// Use case: factory that forwards constructor args
function createWithLogging<T extends new (...args: unknown[]) => unknown>(
  Cls: T,
  ...args: ConstructorParameters<T>
): InstanceType<T> {
  console.log(`Creating ${Cls.name}`);
  return new Cls(...args) as InstanceType<T>;
}

const client = createWithLogging(HttpClient, 'https://api.example.com');

class Database {
  query(sql: string): unknown[] { return []; }
  close(): void {}
}

type DbInstance = InstanceType<typeof Database>;
// Database (the instance type, same as the class name in simple cases)

// More useful with generic factory patterns
function instantiate<T extends new (...args: unknown[]) => unknown>(
  Cls: T
): InstanceType<T> {
  return new Cls() as InstanceType<T>;
}

const db = instantiate(Database); // type: Database

// Useful for class registries / dependency injection
type Constructor<T = unknown> = new (...args: unknown[]) => T;
const registry = new Map<string, Constructor>();
registry.set('db', Database);

function resolve<T extends Constructor>(key: string): InstanceType<T> {
  const Cls = registry.get(key) as T;
  return new Cls() as InstanceType<T>;
}

interface PluginMethods {
  greet(): void;
  farewell(): void;
}

interface Plugin {
  name: string;
  methods: PluginMethods & ThisType<{ name: string } & PluginMethods>;
}

const plugin: Plugin = {
  name: 'MyPlugin',
  methods: {
    greet() {
      console.log(`Hello from ${this.name}`); // 'this' is typed
    },
    farewell() {
      console.log(`Goodbye from ${this.name}`);
    },
  },
};

// ThisType is most commonly seen in framework/library internal code
// like Vue 2's Options API or Vuex's action context

// Basic usage
type A = Awaited<Promise<string>>;        // string
type B = Awaited<Promise<Promise<number>>>; // number (nested unwrap)
type C = Awaited<string>;                  // string (non-promise passthrough)
type D = Awaited<Promise<string | null>>;  // string | null

// Practical: extract resolved type from async functions
async function fetchUsers() {
  return [{ id: 1, name: 'Alice' }];
}

type Users = Awaited<ReturnType<typeof fetchUsers>>;
// { id: number; name: string }[]

// Useful in generic async utilities
async function withTimeout<T>(
  promise: Promise<T>,
  ms: number
): Promise<T> {
  const timeout = new Promise<never>((_, reject) =>
    setTimeout(() => reject(new Error('Timeout')), ms)
  );
  return Promise.race([promise, timeout]);
}

type TimeoutResult<P extends Promise<unknown>> = Awaited<P>;

// Problem: TypeScript infers T from both arguments
function createState<T>(initial: T, fallback: T): T {
  return initial ?? fallback;
}

// This infers T as string | number (from both args)
const state = createState('hello', 42); // T = string | number

// With NoInfer: T is inferred only from 'initial'
// 'fallback' must be assignable to T but doesn't drive inference
function createStateSafe<T>(initial: T, fallback: NoInfer<T>): T {
  return initial ?? fallback;
}

// Now T = string (inferred from first arg), and 42 is a type error
// createStateSafe('hello', 42); // Error: 42 not assignable to string

// Practical use: default values in generic functions
function getOrDefault<T>(value: T | undefined, defaultValue: NoInfer<T>): T {
  return value !== undefined ? value : defaultValue;
}

interface User {
  name: string;
  greet(this: User): string;
}

type BoundGreet = OmitThisParameter<User['greet']>;
// () => string  (this parameter removed)

// Practical use: binding methods
const user: User = {
  name: 'Alice',
  greet() { return `Hello, I am ${this.name}`; },
};

const boundGreet: BoundGreet = user.greet.bind(user);
boundGreet(); // OK — no 'this' needed anymore

type A = Uppercase<'hello'>;    // 'HELLO'
type B = Lowercase<'WORLD'>;    // 'world'
type C = Capitalize<'alice'>;   // 'Alice'
type D = Uncapitalize<'Alice'>; // 'alice'

// Most useful in template literal types and mapped types
type EventKey<T extends string> = `on${Capitalize<T>}`;
type ClickEvent = EventKey<'click'>; // 'onClick'
type FocusEvent = EventKey<'focus'>; // 'onFocus'

// Building a full event handler object type
type Events = 'click' | 'focus' | 'blur' | 'change';
type EventHandlers = {
  [K in Events as `on${Capitalize<K>}`]: (event: Event) => void;
};
// { onClick: ..., onFocus: ..., onBlur: ..., onChange: ... }

// Uppercase over union distributes
type UpperEvents = Uppercase<Events>;
// 'CLICK' | 'FOCUS' | 'BLUR' | 'CHANGE'

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
  role: 'admin' | 'user';
  createdAt: Date;
}

// Public view: no password, readonly
type PublicUser = Readonly<Omit<User, 'password'>>;

// Create payload: no auto-generated fields
type CreateUser = Omit<User, 'id' | 'createdAt'>;

// Update payload: all fields optional except id
type UpdateUser = Partial<Omit<User, 'id'>> & Pick<User, 'id'>;

// Admin-only view: extra admin fields
type AdminUserView = Required<PublicUser> & { lastLoginAt: Date };

// Only string-valued fields
type StringFields<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};
type UserStringFields = StringFields<User>;
// { name: string; email: string; password: string; role: string }

// Deep partial (recursive utility)
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
};