Types and Interfaces

// Type annotations — added with a colon after the variable name
let name:    string  = "Priya";
let age:     number  = 28;
let active:  boolean = true;
let nothing: null    = null;
let unknown: undefined = undefined;

// TypeScript infers types when you initialise
let inferred = "Hello";   // type: string — no annotation needed
inferred = 42;            // Error: Type 'number' is not assignable to type 'string'

// Arrays
let names:   string[]      = ["Priya", "Rahul"];
let scores:  Array<number> = [95, 88, 72];   // generic syntax

// Tuple — fixed length, fixed types at each position
let pair: [string, number] = ["Priya", 95];
let rgb:  [number, number, number] = [255, 128, 0];

// Union — one of several types
let id: string | number = "user-42";
id = 42;   // also valid

// Literal types — only specific values
let direction: "north" | "south" | "east" | "west" = "north";
let statusCode: 200 | 404 | 500 = 200;

// any — opts out of type checking (avoid in new code)
let flexible: any = "hello";
flexible = 42;      // no error — any disables checking
flexible.xyz();     // no error — dangerous

// unknown — safer alternative to any
let value: unknown = fetchFromAPI();
value.toUpperCase();              // Error — must narrow first
if (typeof value === "string") {
    value.toUpperCase();          // OK — narrowed to string
}

// Interface — describes the shape of an object
interface User {
    readonly id:   number;    // readonly — cannot reassign after creation
    name:          string;
    email:         string;
    age?:          number;    // optional — may or may not be present
    role:          "admin" | "user" | "guest";
}

// Any object matching this shape is a valid User (structural typing)
const priya: User = {
    id:    1,
    name:  "Priya",
    email: "priya@example.com",
    role:  "admin",
};

// priya.id = 99;   // Error: Cannot assign to 'id' because it is a read-only property

// Interface for a function
interface Formatter {
    (input: string, options?: { uppercase?: boolean }): string;
}

const format: Formatter = (input, opts) =>
    opts?.uppercase ? input.toUpperCase() : input;

// Extending interfaces
interface AdminUser extends User {
    permissions: string[];
    lastLogin:   Date;
}

// Merging — interfaces with the same name are merged (declaration merging)
interface Window {
    myCustomProp: string;   // adds to the existing Window interface
}

// type alias — can name any type, including unions and primitives
type ID      = string | number;
type Point   = { x: number; y: number };
type Status  = "pending" | "active" | "inactive";

// Intersection — combine types with &
type AdminUser = User & { permissions: string[] };

// Interface and type aliases are often interchangeable for objects
// Key differences:
// 1. type can express unions and intersections directly
// 2. interface supports declaration merging
// 3. interface extends uses extends keyword; type uses &
// 4. Error messages often mention interface names, not type alias names

// Prefer interface for object shapes (especially public APIs)
// Prefer type for unions, intersections, and complex type expressions

// Discriminated union — a union where a common field acts as a tag
type Shape =
    | { kind: "circle";    radius: number }
    | { kind: "rectangle"; width: number; height: number }
    | { kind: "triangle";  base: number;  height: number };

function area(s: Shape): number {
    switch (s.kind) {
        case "circle":    return Math.PI * s.radius ** 2;
        case "rectangle": return s.width * s.height;
        case "triangle":  return 0.5 * s.base * s.height;
    }
    // TypeScript knows this switch is exhaustive — no default needed
}