Interfaces & type aliases.
Describe the shape of your data.

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

const alice: User = {
name: 'Alice',
age: 28,
email: 'alice@example.com'
};

const bob: User = {
name: 'Bob',
age: 34,
email: 'bob@example.com'
};

// ❌ Missing 'email' — compile error before any code runs
// const broken: User = { name: 'X', age: 30 };

function greet(user: User): string {
return ${user.name}, ${user.age};
}

console.log(greet(alice));

interface Profile {
readonly id: string; // can't be reassigned
name: string; // required
bio?: string; // optional — string | undefined
age?: number;
}

const p: Profile = {
id: 'u_123',
name: 'Alice'
// bio and age omitted — allowed because they're optional
};

p.name = 'Alicia'; // ✅ allowed — name is mutable
// p.id = 'u_999'; // ❌ Cannot assign to 'id' because it is a read-only property

// Optional fields require narrowing before use:
// p.bio.toUpperCase() // ❌ 'p.bio' is possibly 'undefined'
if (p.bio) {
console.log(p.bio.toUpperCase()); // ✅ narrowed to string
}

// ─── readonly is shallow ───────────────────────
interface Tagged {
readonly tags: string[];
}
const t: Tagged = { tags: ['a', 'b'] };
t.tags.push('c'); // ✅ readonly blocks reassignment, not mutation
// t.tags = ['x']; // ❌ Cannot assign to 'tags' (the reference is readonly)

// ─── interface extends ────────────────────────
interface User {
id: string;
name: string;
}

interface Admin extends User {
role: 'admin';
permissions: string[];
}

const a: Admin = {
id: 'u_1',
name: 'Alice',
role: 'admin',
permissions: ['read', 'write']
};

// An Admin is assignable everywhere a User is expected:
function printName(u: User) {
console.log(u.name);
}
printName(a); // ✅ Admin has every property User has

// ─── Multiple extends ─────────────────────────
interface Timestamps {
createdAt: Date;
updatedAt: Date;
}
interface Post extends User, Timestamps {
title: string;
body: string;
}

// ─── Intersection with & ─────────────────────
type Base = { id: string };
type Named = { name: string };
type Both = Base & Named; // { id: string; name: string }

// ─── Composition over inheritance ────────────
// The modern preference: build small pieces and intersect them.
type Entity = { id: string } & Timestamps;
type Article = Entity & { title: string; body: string };

// ─── Primitives with a name ───────────────────
type UserID = string;
type Score = number;

// ─── Unions (interface cannot do this) ────────
type ID = string | number;
type Status = 'idle' | 'loading' | 'success' | 'error';

// ─── Function signatures ─────────────────────
type Handler = (event: MouseEvent) => void;
type Comparator = (a: T, b: T) => number;

// ─── Tuples ──────────────────────────────────
type Point = [number, number];
type RGB = [number, number, number];

const p: Point = [10, 20];
// const bad: Point = [10, 20, 30]; // ❌ too many elements

// ─── Object shape (interface & type both work) ─
type User = {
id: ID;
name: string;
status: Status;
};

// ─── Union of literals — the discriminator pattern
type Result =
| { status: 'ok'; data: User }
| { status: 'error'; message: string };