let age: number = 25;
let name: string = "Alice";
let isActive: boolean = true;
let anything: any = "Could be anything";
let nothing: null = null;
let notDefined: undefined = undefined;

let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["Alice", "Bob"];
let tuple: [string, number] = ["Age", 30];

enum Direction {
  Up = 1,
  Down,
  Left,
  Right
}
let move: Direction = Direction.Up;

function add(a: number, b: number): number {
  return a + b;
}

const multiply = (a: number, b: number): number => a * b;

function greet(name: string, greeting: string = "Hello"): void {
  console.log(`${greeting}, ${name}`);
}

function optionalParam(a: number, b?: number): number {
  return b ? a + b : a;
}

interface User {
  id: number;
  name: string;
  email?: string; // optional
}

type Product = {
  id: number;
  name: string;
  price: number;
};

const user: User = { id: 1, name: "Alice" };

class Person {
  constructor(public name: string, private age: number) {}

  greet() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

const p1 = new Person("Bob", 25);

function identity<T>(value: T): T {
  return value;
}

let num = identity<number>(10);
let str = identity("Hello"); // type inferred

interface ApiResponse<T> {
  data: T;
  error?: string;
}

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

type PartialUser = Partial<User>;   // All optional
type ReadonlyUser = Readonly<User>; // Immutable
type PickUser = Pick<User, "id" | "name">;
type OmitUser = Omit<User, "email">;
type UserKeys = keyof User;         // "id" | "name" | "email"

function printLength(x: string | string[]) {
  if (typeof x === "string") {
    console.log(x.length);
  } else {
    console.log(x.length);
  }
}

let someValue: unknown = "Hello TS";
let strLength: number = (someValue as string).length;

// file: math.ts
export function add(a: number, b: number): number {
  return a + b;
}

// file: app.ts
import { add } from "./math";
console.log(add(2, 3));

declare module "some-library" {
  export function doSomething(): void;
}

type UnionType = "success" | "error";
type Intersection = { id: number } & { name: string };

type Conditional<T> = T extends string ? "text" : "other";
type Example = Conditional<"hello">; // "text"