// Primitives
let name: string = 'Ali';
let age: number = 22;
let active: boolean = true;
let id: bigint = 100n;
let sym: symbol = Symbol('key');

// Any, unknown, never, void
let anything: any = 'whatever';       // opt out of type checking
let safe: unknown = 'check first';    // must narrow before using
function throws(): never { throw new Error(); }  // never returns
function log(): void { console.log('hi'); }

// Arrays and tuples
let nums: number[] = [1, 2, 3];
let strs: Array = ['a', 'b'];
let pair: [string, number] = ['Ali', 22];  // tuple: fixed types

// Type inference (TypeScript infers when obvious)
let x = 42;        // inferred as number
const msg = 'hi';  // inferred as 'hi' (literal type)

// Parameter and return types
function greet(name: string, age: number = 0): string {
  return `Hello ${name}, age ${age}`;
}

// Arrow function
const add = (a: number, b: number): number => a + b;

// Optional parameters
function log(msg: string, level?: string): void {
  console.log(`[${level ?? 'INFO'}] ${msg}`);
}

// Rest parameters
const sum = (...nums: number[]): number => nums.reduce((a,b) => a+b, 0);

// Function overloads
function format(val: string): string;
function format(val: number, decimals: number): string;
function format(val: string | number, decimals?: number): string {
  if (typeof val === 'number') return val.toFixed(decimals ?? 2);
  return val.toUpperCase();
}

// Callback typing
function fetchData(callback: (err: Error | null, data?: User) => void): void {}

// Interface
interface User {
  id: number;
  name: string;
  email?: string;           // optional
  readonly createdAt: Date; // can't be changed after creation
}

// Extend interface
interface AdminUser extends User {
  permissions: string[];
}

// Type alias
type Point = { x: number; y: number };
type ID = string | number;  // union type
type Status = 'active' | 'inactive' | 'pending';

// Index signature
interface StringMap {
  [key: string]: string;
}

// Interface for functions
interface Transformer {
  (input: string): string;
}
const upper: Transformer = (s) => s.toUpperCase();

class Animal {
  protected name: string;  // accessible in subclasses
  private age: number;      // only this class
  readonly species: string; // can't change after set

  constructor(name: string, age: number, species: string) {
    this.name = name;
    this.age = age;
    this.species = species;
  }

  // Getter/setter
  get info(): string { return `${this.name} (${this.age})`; }
  set setAge(age: number) { if (age > 0) this.age = age; }

  speak(): string { return `${this.name} makes a sound`; }
}

class Dog extends Animal {
  constructor(name: string, age: number) {
    super(name, age, 'Canis lupus');  // must call super first
  }
  speak(): string { return `${this.name} barks`; }
}

// Implement interface
interface Printable { print(): void; }
class Doc implements Printable {
  print() { console.log('printing...'); }
}

// Generic function
function identity(arg: T): T { return arg; }
identity('hello');  // explicit
identity(42);               // inferred

// Generic with constraint
function getLength(arg: T): number {
  return arg.length;
}

// Generic interface
interface ApiResponse {
  data: T;
  error: string | null;
  status: number;
}

// Generic class
class Stack {
  private items: T[] = [];
  push(item: T): void { this.items.push(item); }
  pop(): T | undefined { return this.items.pop(); }
  get size(): number { return this.items.length; }
}

// Multiple type params
function pair(key: K, val: V): [K, V] {
  return [key, val];
}

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

Partial         // all fields optional
Required        // all fields required
Readonly        // all fields readonly

Pick        // only id and name
Omit           // all except password

Record             // {[key: string]: User}
Record<'admin' | 'user', User>   // specific keys

Exclude<'a' | 'b' | 'c', 'a'>  // 'b' | 'c'
Extract<'a' | 'b' | 'c', 'a' | 'b'>  // 'a' | 'b'

NonNullable  // string

ReturnType     // get function return type
Parameters         // get function param types

Await>          // string

// Numeric enum (default)
enum Direction { Up, Down, Left, Right }  // Up=0, Down=1...
const d: Direction = Direction.Up;

// String enum (preferred — more debuggable)
enum Status {
  Active = 'ACTIVE',
  Inactive = 'INACTIVE',
  Pending = 'PENDING'
}

// Const enum (inlined at compile time — no JS object)
const enum Color { Red, Green, Blue }

// Alternative: use 'as const' instead of enum
const STATUS = {
  Active: 'ACTIVE',
  Inactive: 'INACTIVE'
} as const;

type Status = typeof STATUS[keyof typeof STATUS];  // 'ACTIVE' | 'INACTIVE'

// Union types
type ID = string | number;
type Result = { success: true; data: User } | { success: false; error: string };

// Intersection types
type Admin = User & { permissions: string[] };

// Type narrowing
function process(input: string | number) {
  if (typeof input === 'string') {
    return input.toUpperCase();  // TS knows it's string here
  }
  return input.toFixed(2);      // TS knows it's number here
}

// Discriminated unions
type Shape =
  | { kind: 'circle'; radius: number }
  | { kind: 'square'; side: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle': return Math.PI * shape.radius ** 2;
    case 'square': return shape.side ** 2;
  }
}

// Type guard
function isUser(obj: unknown): obj is User {
  return typeof obj === 'object' && obj !== null && 'id' in obj;
}

{
  "compilerOptions": {
    "target": "ES2020",           // output JS version
    "module": "commonjs",         // module system
    "lib": ["ES2020", "DOM"],      // available APIs
    "outDir": "./dist",            // output directory
    "rootDir": "./src",            // source directory
    "strict": true,               // enable all strict checks
    "noImplicitAny": true,         // no implicit any
    "strictNullChecks": true,      // null safety
    "esModuleInterop": true,       // better imports
    "skipLibCheck": true,          // skip .d.ts checking
    "forceConsistentCasingInFileNames": true,
    "declaration": true,           // generate .d.ts files
    "sourceMap": true              // source maps for debugging
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}