// Enterprise Strict Immutability with as const & Readonly
interface DatabaseConnectionConfig {
  readonly host: string;
  readonly port: number;
  readonly database: string;
  readonly ssl: boolean;
}

// Deep readonly tuple inference with 'as const'
const DEFAULT_PORTS = [5432, 3306, 6379, 27017] as const;
type DatabasePort = typeof DEFAULT_PORTS[number]; // 5432 | 3306 | 6379 | 27017

// Type-Safe Entity Repository using Generic Constraints
interface IdentifiableEntity {
  id: string;
  createdAt: Date;
  updatedAt: Date;
}

class InMemoryRepository<T extends IdentifiableEntity> {
  private items = new Map<string, T>();

  public save(entity: T): void {
    this.items.set(entity.id, entity);
  }

  public findById(id: string): T | undefined {
    return this.items.get(id);
  }

  // Type-safe property extraction using keyof constraint
  public getProperty<K extends keyof T>(id: string, key: K): T[K] | undefined {
    const entity = this.findById(id);
    return entity ? entity[key] : undefined;
  }
}

// Custom Type Extraction Utilities using infer
type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
type ExtractPromisePayload<T> = T extends Promise<infer U> ? U : T;
type ExtractArrayElement<T> = T extends (infer E)[] ? E : T;

// Real-World Example
async function fetchUserPayload() {
  return { userId: "usr_991", role: "ADMIN", active: true };
}

// Automatically extracts: { userId: string, role: string, active: boolean }
type UserResponse = ExtractPromisePayload<ExtractReturnType<typeof fetchUserPayload>>;

// Generating Type-Safe Getters using Key Remapping
type CreateGetters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

interface UserState {
  name: string;
  age: number;
}

// Produces: { getName: () => string; getAge: () => number; }
type UserStateGetters = CreateGetters<UserState>;

// Exhaustive Discriminated Union Pattern
type NetworkState =
  | { status: 'idle' }
  | { status: 'loading' }
  | { status: 'success'; data: string[] }
  | { status: 'error'; error: Error };

function handleState(state: NetworkState): string {
  switch (state.status) {
    case 'idle':
      return 'Ready';
    case 'loading':
      return 'Fetching data...';
    case 'success':
      return `Loaded ${state.data.length} records`;
    case 'error':
      return `Error: ${state.error.message}`;
    default: {
      // Exhaustiveness check: Throws compile-time error if new state variant added!
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck;
    }
  }
}

// Generic Nominal Type Brand Generator
declare const __brand: unique symbol;
type Brand<B> = { readonly [__brand]: B };
type Nominal<T, B> = T & Brand<B>;

type UserId = Nominal<string, 'UserId'>;
type OrderId = Nominal<string, 'OrderId'>;

function getOrder(userId: UserId, orderId: OrderId) {
  // Safe from accidental parameter swapping!
}

const user = "usr_1" as UserId;
const order = "ord_99" as OrderId;

getOrder(user, order); // ✓ Clean compilation
// getOrder(order, user); // ✗ Compile error: Type OrderId is not assignable to UserId!

// Schema-First Type Synthesis
import { z } from 'zod';

export const UserSchema = z.object({
  id: z.string().uuid(),
  email: z.string().email(),
  role: z.enum(['ADMIN', 'ENGINEER', 'GUEST']),
  points: z.number().int().nonnegative()
});

// Synthesize static TypeScript type directly from runtime schema!
export type User = z.infer<typeof UserSchema>;

// Validate incoming API response payload safely
export function parseIncomingUser(rawJson: unknown): User {
  return UserSchema.parse(rawJson); // Throws ZodError on schema mismatch!
}