// Explicit annotation
let count: number = 10;
let message: string = "Hello";

// Type inference (recommended when obvious)
let inferredCount = 10;        // number
let inferredMsg = "Hello";     // string

// Function with annotations
function add(a: number, b: number): number {
    return a + b;
}

// Contextual typing in callbacks
const numbers = [1, 2, 3];
numbers.map(num => num * 2);  // num inferred as number

// String types
let username: string = "Alice";
let template: string = `Hello ${username}`;

// Number types
let age: number = 30;
let price: number = 19.99;
let hex: number = 0xf00d;
let binary: number = 0b1010;

// Boolean
let isActive: boolean = true;
let hasPermission: boolean = false;

// Null and undefined
let nothing: null = null;
let notAssigned: undefined = undefined;

// Symbol
let uniqueId: symbol = Symbol("id");

// BigInt
let huge: bigint = 9007199254740991n;

// String literals
type Direction = "north" | "south" | "east" | "west";
let move: Direction = "north";

// Numeric literals
type HttpCode = 200 | 201 | 400 | 404 | 500;
let response: HttpCode = 200;

// Template literal types
type EventName = `on${Capitalize<string>}`;
type UserId = `user-${number}`;
type CSSProperty = `--${string}`;

// Practical template literal usage
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE";
type Endpoint = `/${string}`;
type APIRoute = `${HTTPMethod} ${Endpoint}`;

let route: APIRoute = "GET /api/users";

// Basic arrays
let numbers: number[] = [1, 2, 3, 4];
let strings: Array<string> = ["a", "b", "c"];

// Multi-dimensional arrays
let matrix: number[][] = [[1, 2], [3, 4]];

// Readonly arrays
let immutable: readonly string[] = ["a", "b"];
// immutable.push("c"); // Error!

// Tuples
let coordinate: [number, number] = [10, 20];
let user: [string, number, boolean] = ["Alice", 30, true];

// Optional tuple elements
let response: [number, string?] = [200];
let fullResponse: [number, string?] = [200, "OK"];

// Rest elements in tuples
let data: [string, ...number[]] = ["label", 1, 2, 3];

// Labeled tuples
type Point = [x: number, y: number];
let point: Point = [10, 20];

// Basic object type
let user: { name: string; age: number } = {
    name: "John",
    age: 30
};

// Optional and readonly properties
let config: {
    host: string;
    port?: number;
    readonly apiKey: string;
} = {
    host: "localhost",
    apiKey: "abc123"
};

// Index signatures
let scores: { [student: string]: number } = {
    "Alice": 95,
    "Bob": 87
};

// Mixed: defined properties + index signature
type Dictionary = {
    count: number;  // known property
    [key: string]: number;  // dynamic keys
};

// Nested objects
let company: {
    name: string;
    address: {
        street: string;
        city: string;
    };
} = {
    name: "TechCorp",
    address: { street: "Main St", city: "NYC" }
};

// Basic union
let id: string | number;
id = "ABC123";  // OK
id = 42;        // OK

// Union with null
function find(name: string): User | null {
    return database.find(name) ?? null;
}

// Discriminated union (tagged union)
type Success = { status: "success"; data: any };
type Error = { status: "error"; message: string };
type Result = Success | Error;

function handle(result: Result) {
    if (result.status === "success") {
        console.log(result.data);  // Type narrowed to Success
    } else {
        console.log(result.message); // Type narrowed to Error
    }
}

// Basic intersection
type Person = { name: string; age: number };
type Employee = { employeeId: string; department: string };
type Worker = Person & Employee;

let worker: Worker = {
    name: "John",
    age: 30,
    employeeId: "E123",
    department: "IT"
};

// Mixin pattern with intersections
type Timestamped = { createdAt: Date; updatedAt: Date };
type Versioned = { version: number };
type Document = { id: string; content: string };

type FullDocument = Document & Timestamped & Versioned;

// any - no type safety
let data: any = getUserInput();
data.anything();        // No error, dangerous!
data.toUpperCase();     // Runtime error if not string

// unknown - type-safe
let safeData: unknown = getUserInput();
// safeData.anything(); // Error! Must check first

if (typeof safeData === "string") {
    safeData.toUpperCase(); // OK, narrowed to string
}

// void - function completes but returns nothing
function log(message: string): void {
    console.log(message);
    // implicitly returns undefined
}

// never - function never returns
function throwError(message: string): never {
    throw new Error(message);
    // execution stops here
}

function infiniteLoop(): never {
    while (true) {
        // never exits
    }
}

// never in exhaustive checks
type Shape = "circle" | "square";
function assertNever(x: never): never {
    throw new Error("Unexpected: " + x);
}

function getArea(shape: Shape): number {
    switch (shape) {
        case "circle": return 1;
        case "square": return 2;
        default: return assertNever(shape); // Compile error if not exhaustive
    }
}

// Type alias - flexible for any type
type StringOrNumber = string | number;
type Coordinate = [number, number];
type UserID = string;

// Interface - best for object shapes
interface Person {
    name: string;
    age: number;
}

interface Employee extends Person {
    employeeId: string;
    department: string;
}

// Declaration merging (interfaces only)
interface Window {
    customProperty: string;
}
interface Window {
    anotherProperty: number;
}
// Window now has both properties

// Type composition
type WithTimestamp = { timestamp: Date };
type TrackedPerson = Person & WithTimestamp;

// Numeric enum
enum Direction {
    Up,      // 0
    Down,    // 1
    Left,    // 2
    Right    // 3
}

// String enum (preferred)
enum Status {
    Pending = "PENDING",
    Active = "ACTIVE",
    Completed = "COMPLETED"
}

// Custom numeric values
enum HttpStatus {
    OK = 200,
    NotFound = 404,
    ServerError = 500
}

// Const enum (performance optimization)
const enum Colors {
    Red = "#FF0000",
    Green = "#00FF00",
    Blue = "#0000FF"
}

// Usage
let status: Status = Status.Active;
let color = Colors.Red;  // Inlined to "#FF0000" at compile time

// as syntax (preferred)
let input = document.getElementById("input") as HTMLInputElement;
input.value = "Hello";

// Angle bracket syntax (avoid in JSX)
let element = <HTMLElement>document.querySelector(".item");

// Double assertion (escape hatch)
let num = "123" as unknown as number;  // Dangerous!

// Const assertion - deep readonly
let config = {
    host: "localhost",
    port: 3000,
    flags: ["debug", "verbose"]
} as const;
// Type: { readonly host: "localhost"; readonly port: 3000; readonly flags: readonly ["debug", "verbose"] }

// Array as const
let arr = [1, 2, 3] as const;  // Type: readonly [1, 2, 3]

// Non-null assertion
function process(value: string | null) {
    let length = value!.length;  // Assert value is not null
}

function process(value: string | number) {
    // typeof guard
    if (typeof value === "string") {
        console.log(value.toUpperCase());  // string
    } else {
        console.log(value.toFixed(2));     // number
    }
}

// instanceof guard
function handle(x: Date | string) {
    if (x instanceof Date) {
        console.log(x.getFullYear());  // Date
    } else {
        console.log(x.length);         // string
    }
}

// in operator
type Fish = { swim: () => void };
type Bird = { fly: () => void };

function move(animal: Fish | Bird) {
    if ("swim" in animal) {
        animal.swim();  // Fish
    } else {
        animal.fly();   // Bird
    }
}

// Truthiness narrowing
function print(text: string | null) {
    if (text) {
        console.log(text.toUpperCase());  // string
    }
}

// Type predicate function
function isString(value: unknown): value is string {
    return typeof value === "string";
}

function process(input: unknown) {
    if (isString(input)) {
        console.log(input.toUpperCase());  // Narrowed to string
    }
}

// Complex type guard
interface Cat { meow: () => void; }
interface Dog { bark: () => void; }

function isCat(animal: Cat | Dog): animal is Cat {
    return (animal as Cat).meow !== undefined;
}

function speak(animal: Cat | Dog) {
    if (isCat(animal)) {
        animal.meow();
    } else {
        animal.bark();
    }
}

// Define discriminated union
type Result<T> =
    | { status: "loading" }
    | { status: "success"; data: T }
    | { status: "error"; error: Error };

function handle<T>(result: Result<T>) {
    switch (result.status) {
        case "loading":
            console.log("Loading...");
            break;
        case "success":
            console.log(result.data);  // Type: T
            break;
        case "error":
            console.log(result.error.message);  // Type: Error
            break;
    }
}

// Shape discriminated union
type Shape =
    | { kind: "circle"; radius: number }
    | { kind: "rectangle"; width: number; height: number }
    | { kind: "triangle"; base: number; height: number };

function area(shape: Shape): number {
    switch (shape.kind) {
        case "circle":
            return Math.PI * shape.radius ** 2;
        case "rectangle":
            return shape.width * shape.height;
        case "triangle":
            return 0.5 * shape.base * shape.height;
    }
}

// Exhaustiveness check
function assertNever(x: never): never {
    throw new Error("Unexpected: " + x);
}

function getArea(shape: Shape): number {
    switch (shape.kind) {
        case "circle": return Math.PI * shape.radius ** 2;
        case "rectangle": return shape.width * shape.height;
        case "triangle": return 0.5 * shape.base * shape.height;
        default: return assertNever(shape);  // Compile error if case missing
    }
}

// Basic mapped type
type Nullable<T> = {
    [K in keyof T]: T[K] | null;
};

type User = { name: string; age: number };
type NullableUser = Nullable<User>;
// Result: { name: string | null; age: number | null }

// Add/remove modifiers
type Mutable<T> = {
    -readonly [K in keyof T]: T[K];
};

type Required<T> = {
    [K in keyof T]-?: T[K];
};

// Key remapping with template literals
type Getters<T> = {
    [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type Person = { name: string; age: number };
type PersonGetters = Getters<Person>;
// Result: { getName: () => string; getAge: () => number }

// Filter properties by type
type StringKeys<T> = {
    [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type Data = { id: number; name: string; email: string; count: number };
type StringProps = StringKeys<Data>;
// Result: { name: string; email: string }

// Basic conditional type
type IsString<T> = T extends string ? true : false;
type A = IsString<string>;   // true
type B = IsString<number>;   // false

// Extract return type with infer
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type Func = () => string;
type Result = ReturnType<Func>;  // string

// Extract array element type
type ElementType<T> = T extends (infer U)[] ? U : never;
type Items = ElementType<number[]>;  // number

// Distributive conditional (union)
type ToArray<T> = T extends any ? T[] : never;
type Arrays = ToArray<string | number>;
// Result: string[] | number[] (distributed)

// Non-distributive (tuple)
type ToArrayNonDist<T> = [T] extends [any] ? T[] : never;
type TupleArray = ToArrayNonDist<string | number>;
// Result: (string | number)[] (not distributed)

// Complex conditional - function overloads
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
type Value1 = UnwrapPromise<Promise<string>>;  // string
type Value2 = UnwrapPromise<number>;           // number

// Recursive conditional type
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type Deep = Flatten<number[][][]>;  // number

// Basic generic function
function identity<T>(arg: T): T {
    return arg;
}

// Usage with explicit type
let output1 = identity<string>("hello");

// Usage with type inference (preferred)
let output2 = identity("hello");  // T inferred as string

// Generic with array
function firstElement<T>(arr: T[]): T | undefined {
    return arr[0];
}

let first = firstElement([1, 2, 3]);  // number | undefined

// Multiple type parameters
function pair<T, U>(first: T, second: U): [T, U] {
    return [first, second];
}

let p = pair("age", 30);  // [string, number]

// Generic arrow function
const map = <T, U>(arr: T[], fn: (item: T) => U): U[] => {
    return arr.map(fn);
};

// Generic with constraints
function merge<T, U>(obj1: T, obj2: U): T & U {
    return { ...obj1, ...obj2 };
}

class DataStore {
    private data: any[] = [];
    
    // Generic method
    add<T>(item: T): void {
        this.data.push(item);
    }
    
    get<T>(index: number): T {
        return this.data[index];
    }
    
    filter<T>(predicate: (item: T) => boolean): T[] {
        return this.data.filter(predicate);
    }
}

const store = new DataStore();
store.add<string>("hello");
store.add<number>(42);

// Generic interface
interface Container<T> {
    value: T;
    getValue(): T;
    setValue(val: T): void;
}

// Implement with specific type
class StringContainer implements Container<string> {
    constructor(public value: string) {}
    
    getValue(): string {
        return this.value;
    }
    
    setValue(val: string): void {
        this.value = val;
    }
}

// Generic function interface
interface Transformer<T, U> {
    (input: T): U;
}

const toNumber: Transformer<string, number> = (str) => parseInt(str);

// Generic interface with multiple type parameters
interface KeyValuePair<K, V> {
    key: K;
    value: V;
}

// Generic class
class Box<T> {
    private contents: T;
    
    constructor(value: T) {
        this.contents = value;
    }
    
    get(): T {
        return this.contents;
    }
    
    set(value: T): void {
        this.contents = value;
    }
}

const stringBox = new Box<string>("hello");
const numberBox = new Box(42);  // Type inferred

// Generic class with multiple parameters
class Pair<T, U> {
    constructor(
        public first: T,
        public second: U
    ) {}
    
    swap(): Pair<U, T> {
        return new Pair(this.second, this.first);
    }
}

// Generic collection class
class Collection<T> {
    private items: T[] = [];
    
    add(item: T): void {
        this.items.push(item);
    }
    
    get(index: number): T {
        return this.items[index];
    }
    
    findFirst(predicate: (item: T) => boolean): T | undefined {
        return this.items.find(predicate);
    }
}

// Basic constraint - ensure property exists
interface Lengthwise {
    length: number;
}

function logLength<T extends Lengthwise>(arg: T): T {
    console.log(arg.length);  // OK - length guaranteed
    return arg;
}

logLength("hello");        // OK - string has length
logLength([1, 2, 3]);      // OK - array has length
// logLength(10);          // Error - number has no length

// keyof constraint for type-safe property access
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

let person = { name: "Alice", age: 30 };
let name = getProperty(person, "name");    // string
let age = getProperty(person, "age");      // number
// let x = getProperty(person, "invalid"); // Error

// Multiple constraints
interface Named { name: string; }
interface Aged { age: number; }

function describe<T extends Named & Aged>(obj: T): string {
    return `${obj.name} is ${obj.age} years old`;
}

// Constructor constraint
function create<T>(constructor: new () => T): T {
    return new constructor();
}

class Person {
    name = "Unknown";
}

let person = create(Person);  // Person instance

// Basic default
interface Container<T = string> {
    value: T;
}

let c1: Container = { value: "hello" };        // T defaults to string
let c2: Container<number> = { value: 42 };     // T explicitly number

// Multiple parameters with defaults
class Request<TData = any, TError = Error> {
    data?: TData;
    error?: TError;
}

// Use all defaults
let req1 = new Request();                      // Request<any, Error>

// Override first, use second default
let req2 = new Request<string>();              // Request<string, Error>

// Override both
let req3 = new Request<string, CustomError>(); // Request<string, CustomError>

// Dependent default - U defaults to T
function create<T, U = T>(value: T): [T, U] {
    return [value, value as unknown as U];
}

// Default from conditional
type APIResponse<T = never> = T extends never
    ? { status: "idle" }
    : { status: "success"; data: T } | { status: "error"; error: string };

let response1: APIResponse = { status: "idle" };
let response2: APIResponse<string> = { status: "success", data: "hello" };

// Extract return type
type GetReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type Func1 = () => string;
type Return1 = GetReturnType<Func1>;  // string

// Extract parameter types
type GetParameters<T> = T extends (...args: infer P) => any ? P : never;

type Func2 = (a: string, b: number) => void;
type Params = GetParameters<Func2>;  // [string, number]

// Extract array element type
type ElementType<T> = T extends (infer E)[] ? E : never;

type Numbers = ElementType<number[]>;  // number

// Unwrap Promise
type Unpromise<T> = T extends Promise<infer U> ? U : T;

type Resolved = Unpromise<Promise<string>>;  // string
type NotPromise = Unpromise<number>;         // number

// Deep unwrap nested Promises
type DeepUnpromise<T> = T extends Promise<infer U> 
    ? DeepUnpromise<U> 
    : T;

type Deep = DeepUnpromise<Promise<Promise<number>>>;  // number

// Extract first array element type
type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never;

type FirstType = First<[string, number, boolean]>;  // string

// Extract last array element type
type Last<T extends any[]> = T extends [...any[], infer L] ? L : never;

type LastType = Last<[string, number, boolean]>;  // boolean

// Extract constructor parameter types
type ConstructorParams<T> = T extends new (...args: infer P) => any ? P : never;

class MyClass {
    constructor(name: string, age: number) {}
}

type Params2 = ConstructorParams<typeof MyClass>;  // [string, number]

class Animal {
    name: string = "";
}

class Dog extends Animal {
    breed: string = "";
}

// Covariance in return types
type Producer<T> = () => T;

let animalProducer: Producer<Animal> = () => new Animal();
let dogProducer: Producer<Dog> = () => new Dog();

// Covariant - Dog producer is subtype of Animal producer
animalProducer = dogProducer;  // OK - Dog extends Animal

// Readonly arrays are covariant (safe)
let animals: readonly Animal[] = [];
let dogs: readonly Dog[] = [new Dog()];

animals = dogs;  // OK - readonly, so safe

// Contravariance in function parameters
type Consumer<T> = (arg: T) => void;

let animalConsumer: Consumer<Animal> = (animal: Animal) => {
    console.log(animal.name);
};

let dogConsumer: Consumer<Dog> = (dog: Dog) => {
    console.log(dog.breed);
};

// Contravariant - Animal consumer is subtype of Dog consumer
dogConsumer = animalConsumer;  // OK - can handle Dog since it's an Animal
// animalConsumer = dogConsumer; // Error - cannot handle all Animals

// Mutable arrays are technically covariant but unsafe
let animals: Animal[] = [];
let dogs: Dog[] = [new Dog()];

animals = dogs;  // OK in TypeScript (unsound)

// This is why it's unsafe:
animals.push(new Animal());  // Runtime error! Added Animal to Dog[]

// Solution: Use readonly for true covariance
function printAnimals(animals: readonly Animal[]) {
    animals.forEach(a => console.log(a.name));
}

printAnimals(dogs);  // Safe - cannot modify array

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

// All properties optional
type PartialUser = Partial<User>;
// Result: { id?: number; name?: string; email?: string; age?: number; }

// Update function accepts partial data
function updateUser(id: number, updates: Partial<User>): User {
    const user = getUserById(id);
    return { ...user, ...updates };
}

updateUser(1, { name: "Alice" });           // OK
updateUser(2, { email: "alice@email.com" }); // OK
updateUser(3, {});                           // OK - no updates

// Partial for default configs
interface Config {
    host: string;
    port: number;
    ssl: boolean;
    timeout: number;
}

function createConfig(overrides: Partial<Config> = {}): Config {
    const defaults: Config = {
        host: "localhost",
        port: 3000,
        ssl: false,
        timeout: 5000
    };
    return { ...defaults, ...overrides };
}

interface Settings {
    theme?: "light" | "dark";
    fontSize?: number;
    notifications?: boolean;
}

// Make all required for validation
type CompleteSettings = Required<Settings>;
// Result: { theme: "light" | "dark"; fontSize: number; notifications: boolean; }

function validateSettings(settings: CompleteSettings): boolean {
    // All properties guaranteed to exist
    return settings.theme !== undefined &&
           settings.fontSize > 0 &&
           settings.notifications !== undefined;
}

// Readonly for immutable state
const config: Readonly<Config> = {
    host: "localhost",
    port: 3000,
    ssl: false,
    timeout: 5000
};

// config.port = 8080; // Error: Cannot assign to readonly property

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

// Pick only public-facing fields
type PublicUser = Pick<User, "id" | "name" | "email">;
// Result: { id: number; name: string; email: string; }

// Use for API responses
function getPublicProfile(userId: number): PublicUser {
    const user = findUser(userId);
    return {
        id: user.id,
        name: user.name,
        email: user.email
    };
}

// Pick for form fields
type LoginForm = Pick<User, "email" | "password">;
// Result: { email: string; password: string; }

// Pick with union
type UserIdentifiers = Pick<User, "id" | "email">;

// Pick for timestamps
type Timestamps = Pick<User, "createdAt" | "updatedAt">;

// Omit sensitive fields
type SafeUser = Omit<User, "password">;
// Result: All User fields except password

// Omit multiple fields
type UserWithoutMeta = Omit<User, "createdAt" | "updatedAt">;

// Create input type by omitting generated fields
type CreateUserInput = Omit<User, "id" | "createdAt" | "updatedAt">;
// Result: { name: string; email: string; password: string; role: string; }

function createUser(input: CreateUserInput): User {
    return {
        ...input,
        id: generateId(),
        createdAt: new Date(),
        updatedAt: new Date()
    };
}

// Omit for derived types
interface Product {
    id: string;
    name: string;
    price: number;
    discount: number;
}

type ProductInput = Omit<Product, "id">;
type ProductWithoutDiscount = Omit<Product, "discount">;

// Basic Record
type UserRoles = "admin" | "user" | "guest";
type Permissions = Record<UserRoles, string[]>;

const permissions: Permissions = {
    admin: ["read", "write", "delete"],
    user: ["read", "write"],
    guest: ["read"]
};

// Record with string keys
type StringMap = Record<string, number>;
const scores: StringMap = {
    "Alice": 95,
    "Bob": 87,
    "Charlie": 92
};

// Record with template literal keys
type HTTPMethods = "GET" | "POST" | "PUT" | "DELETE";
type RouteHandlers = Record<HTTPMethods, (req: Request) => Response>;

const handlers: RouteHandlers = {
    GET: (req) => ({ status: 200, body: "GET" }),
    POST: (req) => ({ status: 201, body: "POST" }),
    PUT: (req) => ({ status: 200, body: "PUT" }),
    DELETE: (req) => ({ status: 204, body: "" })
};

// Record for configuration
type Environment = "development" | "staging" | "production";
type EnvConfig = Record<Environment, { apiUrl: string; debug: boolean }>;

const config: EnvConfig = {
    development: { apiUrl: "http://localhost:3000", debug: true },
    staging: { apiUrl: "https://staging.api.com", debug: true },
    production: { apiUrl: "https://api.com", debug: false }
};

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

// keyof extracts property keys
type PersonKeys = keyof Person;
// Result: "name" | "age" | "email"

// Type-safe property getter
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const person: Person = { name: "Alice", age: 30, email: "alice@email.com" };

let name = getProperty(person, "name");     // string
let age = getProperty(person, "age");       // number
// let x = getProperty(person, "invalid");  // Error!

// Type-safe property setter
function setProperty<T, K extends keyof T>(
    obj: T,
    key: K,
    value: T[K]
): void {
    obj[key] = value;
}

setProperty(person, "name", "Bob");  // OK
setProperty(person, "age", 25);      // OK
// setProperty(person, "age", "25"); // Error: wrong type

// keyof with mapped types
type Getters<T> = {
    [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type PersonGetters = Getters<Person>;
// Result: { getName: () => string; getAge: () => number; getEmail: () => string; }

// Basic Exclude
type AllTypes = string | number | boolean | null | undefined;
type PrimitiveTypes = Exclude<AllTypes, null | undefined>;
// Result: string | number | boolean

// Exclude specific values
type Status = "pending" | "active" | "completed" | "cancelled";
type ActiveStatus = Exclude<Status, "cancelled">;
// Result: "pending" | "active" | "completed"

// Exclude function types
type MixedTypes = string | number | (() => void) | { id: number };
type NonFunctionTypes = Exclude<MixedTypes, Function>;
// Result: string | number | { id: number }

// Exclude keys from type
type UserKeys = keyof User;
type NonIdKeys = Exclude<UserKeys, "id">;

// Practical: exclude built-in methods
type OwnProperties<T> = Exclude<keyof T, keyof any[]>;

// Remove optional properties
type RequiredKeys<T> = Exclude<{
    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
}[keyof T], undefined>;

// Basic Extract
type AllTypes = string | number | boolean | null;
type NullableTypes = Extract<AllTypes, null | undefined>;
// Result: null

type StringOrNumber = Extract<AllTypes, string | number>;
// Result: string | number

// Extract specific literal types
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
type ReadMethods = Extract<HTTPMethod, "GET">;
// Result: "GET"

type WriteMethods = Extract<HTTPMethod, "POST" | "PUT" | "DELETE" | "PATCH">;
// Result: "POST" | "PUT" | "DELETE" | "PATCH"

// Extract function types
type Mixed = string | number | ((x: number) => number) | ((y: string) => string);
type Functions = Extract<Mixed, Function>;
// Result: ((x: number) => number) | ((y: string) => string)

// Extract by structure
type Shapes = 
    | { kind: "circle"; radius: number }
    | { kind: "square"; size: number }
    | { kind: "rectangle"; width: number; height: number };

type CircleShape = Extract<Shapes, { kind: "circle" }>;
// Result: { kind: "circle"; radius: number }

// NonNullable - remove null and undefined
type MaybeString = string | null | undefined;
type DefiniteString = NonNullable<MaybeString>;
// Result: string

// Basic ReturnType
function getUser() {
    return { id: 1, name: "Alice", email: "alice@email.com" };
}

type User = ReturnType<typeof getUser>;
// Result: { id: number; name: string; email: string; }

// ReturnType with generic function
function fetchData<T>(url: string): Promise<T> {
    return fetch(url).then(res => res.json());
}

type FetchReturn = ReturnType<typeof fetchData>;
// Result: Promise<unknown> (generic resolved to unknown)

// ReturnType from function type
type Handler = (event: Event) => void;
type HandlerReturn = ReturnType<Handler>;
// Result: void

// Complex function return
function getConfig() {
    return {
        api: { url: "https://api.com", timeout: 5000 },
        features: { darkMode: true, notifications: false }
    } as const;
}

type Config = ReturnType<typeof getConfig>;
// Infers readonly structure

// Array method return types
type MapReturn = ReturnType<typeof Array.prototype.map>;
type FilterReturn = ReturnType<typeof Array.prototype.filter>;

// Basic Parameters
function createUser(name: string, age: number, email: string) {
    return { name, age, email };
}

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

// Use extracted parameters
function logCreateUser(...args: CreateUserParams) {
    console.log("Creating user:", args);
    return createUser(...args);
}

// Parameters with function type
type HandlerFn = (event: MouseEvent, options: { passive: boolean }) => void;
type HandlerParams = Parameters<HandlerFn>;
// Result: [event: MouseEvent, options: { passive: boolean }]

// Extract specific parameter
type FirstParam<T extends (...args: any[]) => any> = Parameters<T>[0];

type Handler = (id: number, data: string) => void;
type FirstArg = FirstParam<Handler>;  // number

// Combine with ReturnType
function transform(input: string): number {
    return parseInt(input);
}

type TransformParams = Parameters<typeof transform>;  // [string]
type TransformReturn = ReturnType<typeof transform>;  // number

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

// NonNullable with union
type Value = string | number | null | undefined | boolean;
type NonNullValue = NonNullable<Value>;
// Result: string | number | boolean

// Filter array to non-null values
function filterNulls<T>(arr: (T | null | undefined)[]): NonNullable<T>[] {
    return arr.filter((item): item is NonNullable<T> => item != null);
}

const mixed = [1, null, 2, undefined, 3];
const numbers = filterNulls(mixed);  // number[]

// Safe access with NonNullable
type User = { name: string; email?: string | null };

function getEmail(user: User): NonNullable<User["email"]> | "no-email" {
    return user.email ?? "no-email";
}

// NonNullable in generic constraints
function process<T>(value: NonNullable<T>): void {
    // value is guaranteed not null/undefined
    console.log(value);
}