Intermediate

// Sales Bounded Context - Customer means "Buyer with purchase history"
namespace SalesContext {
  // Sales-specific Customer entity
  export class Customer {
    // => Sales context: Customer = buyer with payment info
    private readonly customerId: string; // => Unique identifier in Sales
    private readonly email: string; // => Contact for order confirmations
    private readonly creditLimit: number; // => Maximum order value allowed
    private orders: Order[] = []; // => Purchase history (Sales-specific)

    constructor(customerId: string, email: string, creditLimit: number) {
      this.customerId = customerId; // => Initialize customer ID
      this.email = email; // => Set email for sales communications
      this.creditLimit = creditLimit; // => Set credit limit for orders
    }

    placeOrder(order: Order): void {
      // => Domain operation: placeOrder
      // => Business rule: Sales validates against credit limit
      this.ensureCreditAvailable(order.getTotalAmount());
      // => Delegates to internal method
      this.orders.push(order); // => Add to purchase history
      // => Order placed successfully
    }

    private ensureCreditAvailable(amount: number): void {
      // => Internal logic (not part of public API)
      const totalOutstanding = this.getTotalOutstanding(); // => Calculate current debt
      if (totalOutstanding + amount > this.creditLimit) {
        // => Validate against credit limit
        throw new Error("Credit limit exceeded");
      }
      // => Credit check passed
    }

    private getTotalOutstanding(): number {
      // => Internal logic (not part of public API)
      return this.orders
        .filter((o) => !o.isPaid()) // => Filter unpaid orders
        .reduce((sum, o) => sum + o.getTotalAmount(), 0); // => Sum unpaid amounts
    }

    getCustomerId(): string {
      // => Domain operation: getCustomerId
      return this.customerId; // => Expose customer ID
    }

    getEmail(): string {
      // => Domain operation: getEmail
      return this.email; // => Expose email
    }
  }

  // Sales-specific Order entity
  export class Order {
    private readonly orderId: string; // => Order identifier
    private readonly totalAmount: number; // => Order total
    private paid: boolean = false; // => Payment status

    constructor(orderId: string, totalAmount: number) {
      this.orderId = orderId; // => Initialize order ID
      this.totalAmount = totalAmount; // => Set total amount
    }

    markAsPaid(): void {
      // => Domain operation: markAsPaid
      this.paid = true; // => Update payment status
    }

    isPaid(): boolean {
      // => Domain operation: isPaid
      return this.paid; // => Return payment status
    }

    getTotalAmount(): number {
      // => Domain operation: getTotalAmount
      return this.totalAmount; // => Expose total amount
    }
  }

  // Sales-specific repository
  export interface CustomerRepository {
    findById(customerId: string): Customer | null; // => Retrieve by ID
    // => Domain operation: findById
    save(customer: Customer): void; // => Persist customer
    // => Domain operation: save
  }
}

// Usage - Sales Context operations
const salesCustomer = new SalesContext.Customer("C123", "alice@example.com", 10000);
// => salesCustomer: creditLimit=10000, orders=[]
const order = new SalesContext.Order("O456", 5000);
// => order: totalAmount=5000, paid=false
salesCustomer.placeOrder(order);
// => Order added to purchase history, credit limit checked
console.log(salesCustomer.getEmail());
// => Outputs result
// => Output: alice@example.com

// Shipping Bounded Context - Customer means "Delivery recipient"
namespace ShippingContext {
  // Shipping-specific Customer entity
  export class Customer {
    // => Shipping context: Customer = delivery address holder
    private readonly customerId: string; // => Unique identifier in Shipping
    private readonly name: string; // => Recipient name for delivery
    private readonly addresses: DeliveryAddress[] = []; // => Delivery locations

    constructor(customerId: string, name: string) {
      this.customerId = customerId; // => Initialize customer ID
      this.name = name; // => Set recipient name
    }

    addDeliveryAddress(address: DeliveryAddress): void {
      // => Domain operation: addDeliveryAddress
      this.addresses.push(address); // => Add delivery location
      // => Address added to customer's delivery options
    }

    getDefaultAddress(): DeliveryAddress | null {
      // => Domain operation: getDefaultAddress
      const defaultAddr = this.addresses.find((a) => a.isDefault());
      // => Find default address
      return defaultAddr || null; // => Return default or null
    }

    getCustomerId(): string {
      // => Domain operation: getCustomerId
      return this.customerId; // => Expose customer ID
    }
  }

  // Shipping-specific value object
  export class DeliveryAddress {
    private readonly street: string; // => Street address
    private readonly city: string; // => City name
    private readonly zipCode: string; // => Postal code
    private readonly country: string; // => Country
    private readonly isDefaultAddress: boolean; // => Default flag

    constructor(street: string, city: string, zipCode: string, country: string, isDefaultAddress: boolean = false) {
      this.street = street; // => Initialize street
      this.city = city; // => Initialize city
      this.zipCode = zipCode; // => Initialize zip code
      this.country = country; // => Initialize country
      this.isDefaultAddress = isDefaultAddress; // => Set default flag
    }

    isDefault(): boolean {
      // => Domain operation: isDefault
      return this.isDefaultAddress; // => Return default status
    }

    getFullAddress(): string {
      // => Domain operation: getFullAddress
      return `${this.street}, ${this.city}, ${this.zipCode}, ${this.country}`;
      // => Returns `${this.street}, ${this.city}, ${this.zipCode}, ${this.country}`
      // => Format complete address string
    }
  }

  // Shipment entity - Shipping context specific
  export class Shipment {
    private readonly shipmentId: string; // => Shipment identifier
    private readonly customerId: string; // => Reference to customer
    private readonly address: DeliveryAddress; // => Delivery destination
    private status: ShipmentStatus = "PENDING"; // => Current status

    constructor(shipmentId: string, customerId: string, address: DeliveryAddress) {
      this.shipmentId = shipmentId; // => Initialize shipment ID
      this.customerId = customerId; // => Link to customer
      this.address = address; // => Set delivery address
    }

    ship(): void {
      // => Domain operation: ship
      if (this.status !== "PENDING") {
        // => Validate current status
        throw new Error("Shipment already processed");
      }
      this.status = "SHIPPED"; // => Update to shipped
      // => Shipment marked as shipped
    }

    getStatus(): ShipmentStatus {
      // => Domain operation: getStatus
      return this.status; // => Return current status
    }
  }

  type ShipmentStatus = "PENDING" | "SHIPPED" | "DELIVERED";
  // => Type definition for shipment states
}

// Usage - Shipping Context operations
const shippingCustomer = new ShippingContext.Customer("C123", "Alice Smith");
// => shippingCustomer: name="Alice Smith", addresses=[]
const address = new ShippingContext.DeliveryAddress("123 Main St", "Seattle", "98101", "USA", true);
// => address: street="123 Main St", city="Seattle", isDefault=true
shippingCustomer.addDeliveryAddress(address);
// => Address added to customer's delivery options
const shipment = new ShippingContext.Shipment("S789", "C123", address);
// => shipment: status="PENDING", address=address
shipment.ship();
// => shipment.status becomes "SHIPPED"
console.log(shipment.getStatus());
// => Outputs result
// => Output: SHIPPED

// Shared Kernel - Common model shared between contexts
namespace SharedKernel {
  // Shared value object - used by multiple contexts
  export class Money {
    private readonly amount: number; // => Monetary amount
    private readonly currency: string; // => Currency code (USD, EUR, etc.)

    constructor(amount: number, currency: string) {
      // => Initialize object with parameters
      if (amount < 0) {
        // => Validate non-negative amount
        throw new Error("Amount cannot be negative");
        // => Raise domain exception
      }
      this.amount = amount; // => Initialize amount
      this.currency = currency; // => Initialize currency
    }

    add(other: Money): Money {
      // => Domain operation: add
      this.ensureSameCurrency(other); // => Validate currency match
      return new Money(this.amount + other.amount, this.currency);
      // => Return new Money with combined amount
    }

    private ensureSameCurrency(other: Money): void {
      // => Internal logic (not part of public API)
      if (this.currency !== other.currency) {
        // => Validate currencies match
        throw new Error("Cannot operate on different currencies");
        // => Raise domain exception
      }
      // => Currency validation passed
    }

    getAmount(): number {
      // => Domain operation: getAmount
      return this.amount; // => Expose amount
    }

    getCurrency(): string {
      // => Domain operation: getCurrency
      return this.currency; // => Expose currency
    }
  }

  // Shared enum - product category taxonomy
  export enum ProductCategory {
    ELECTRONICS = "ELECTRONICS", // => Electronic goods
    CLOTHING = "CLOTHING", // => Apparel items
    BOOKS = "BOOKS", // => Published works
    FOOD = "FOOD", // => Consumable products
  }
}

// Billing Context - uses shared kernel
namespace BillingContext {
  import Money = SharedKernel.Money; // => Import shared Money type

  export class Invoice {
    private readonly invoiceId: string; // => Invoice identifier
    private readonly items: InvoiceItem[] = []; // => Line items

    constructor(invoiceId: string) {
      this.invoiceId = invoiceId; // => Initialize invoice ID
    }

    addItem(item: InvoiceItem): void {
      // => Domain operation: addItem
      this.items.push(item); // => Add line item
      // => Item added to invoice
    }

    getTotal(): Money {
      // => Domain operation: getTotal
      if (this.items.length === 0) {
        // => Check for empty invoice
        return new Money(0, "USD"); // => Return zero amount
      }
      return (
        // => Return result to caller
        this.items
          .map((item) => item.getPrice()) // => Extract prices
          .reduce((sum, price) => sum.add(price))
      ); // => Sum all prices
    }
  }

  export class InvoiceItem {
    private readonly description: string; // => Item description
    private readonly price: Money; // => Item price (shared type)

    constructor(description: string, price: Money) {
      this.description = description; // => Initialize description
      this.price = price; // => Initialize price
    }

    getPrice(): Money {
      // => Domain operation: getPrice
      return this.price; // => Expose price
    }
  }
}

// Accounting Context - also uses shared kernel
namespace AccountingContext {
  import Money = SharedKernel.Money; // => Import shared Money type

  export class Transaction {
    private readonly transactionId: string; // => Transaction identifier
    private readonly amount: Money; // => Transaction amount (shared type)
    private readonly type: "DEBIT" | "CREDIT"; // => Transaction type

    constructor(transactionId: string, amount: Money, type: "DEBIT" | "CREDIT") {
      this.transactionId = transactionId; // => Initialize transaction ID
      this.amount = amount; // => Initialize amount
      this.type = type; // => Set transaction type
    }

    getAmount(): Money {
      // => Domain operation: getAmount
      return this.amount; // => Expose amount
    }

    getType(): string {
      // => Domain operation: getType
      return this.type; // => Expose transaction type
    }
  }
}

// Usage - Both contexts use shared Money type
const invoiceItem = new BillingContext.InvoiceItem("Laptop", new SharedKernel.Money(1200, "USD"));
// => invoiceItem: description="Laptop", price=Money{1200, USD}
const invoice = new BillingContext.Invoice("INV-001");
// => invoice: invoiceId="INV-001", items=[]
invoice.addItem(invoiceItem);
// => Item added to invoice
const total = invoice.getTotal();
// => total: Money{1200, USD}
console.log(`Total: ${total.getAmount()} ${total.getCurrency()}`);
// => Outputs result
// => Output: Total: 1200 USD

const transaction = new AccountingContext.Transaction("TXN-001", new SharedKernel.Money(1200, "USD"), "DEBIT");
// => transaction: amount=Money{1200, USD}, type="DEBIT"
console.log(`Transaction: ${transaction.getAmount().getAmount()}`);
// => Outputs result
// => Output: Transaction: 1200

// Supplier Context - Provides product catalog service
namespace ProductCatalogContext {
  // => Executes domain logic
  // Supplier's public API
  export interface ProductCatalogService {
    // => Preserves domain model
    getProduct(productId: string): ProductDTO | null; // => Public interface
    // => Domain operation: getProduct
    searchProducts(query: string): ProductDTO[]; // => Search functionality
    // => Domain operation: searchProducts
  }
  // => Updates aggregate state

  // Data Transfer Object - Supplier's contract
  export interface ProductDTO {
    // => Communicates domain intent
    productId: string; // => Product identifier
    // => Executes domain logic
    name: string; // => Product name
    // => Updates aggregate state
    description: string; // => Product description
    // => Validates business rule
    price: number; // => Price in cents
    // => Enforces invariant
    currency: string; // => Currency code
    // => Encapsulates domain knowledge
  }
  // => Validates business rule

  // Internal implementation (private to Supplier)
  class Product {
    // => Product: domain model element
    constructor(
      // => Initialize object with parameters
      private readonly productId: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly name: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly description: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly price: number,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly currency: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
    ) {}
    // => Enforces invariant

    toDTO(): ProductDTO {
      // => Domain operation: toDTO
      // => Convert internal model to public DTO
      return {
        // => Returns {
        productId: this.productId,
        // => Encapsulates domain knowledge
        name: this.name,
        // => Delegates to domain service
        description: this.description,
        // => Maintains consistency boundary
        price: this.price,
        // => Applies domain event
        currency: this.currency,
        // => Coordinates with bounded context
      };
      // => Implements tactical pattern
    }
    // => Protects aggregate integrity
  }
  // => Ensures transactional consistency

  // Supplier's service implementation
  export class ProductCatalogServiceImpl implements ProductCatalogService {
    // => ProductCatalogServiceImpl: domain model element
    private products: Map<string, Product> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => Internal product storage

    constructor() {
      // => Initialize object with parameters
      // Seed with sample data
      const laptop = new Product("P1", "Laptop", "15-inch laptop", 120000, "USD");
      // => laptop: price=120000 cents = $1200
      this.products.set("P1", laptop);
      // => Delegates to internal method
      // => Product stored in catalog
    }
    // => Manages entity lifecycle

    getProduct(productId: string): ProductDTO | null {
      // => Domain operation: getProduct
      const product = this.products.get(productId);
      // => Retrieve product by ID
      return product ? product.toDTO() : null;
      // => Return DTO or null if not found
    }
    // => Preserves domain model

    searchProducts(query: string): ProductDTO[] {
      // => Domain operation: searchProducts
      const results: ProductDTO[] = [];
      // => Create data structure
      this.products.forEach((product) => {
        // => Iterate all products
        if (product["name"].toLowerCase().includes(query.toLowerCase())) {
          // => Check if name matches query
          results.push(product.toDTO());
          // => Add matching product to results
        }
        // => Communicates domain intent
      });
      // => Delegates to domain service
      return results; // => Return matching products
      // => Returns results; // => Return matching products
    }
    // => Executes domain logic
  }
  // => Updates aggregate state
}
// => Validates business rule

// Customer Context - Depends on Supplier's service
namespace OrderManagementContext {
  // => Enforces invariant
  import ProductDTO = ProductCatalogContext.ProductDTO;
  // => Encapsulates domain knowledge
  import ProductCatalogService = ProductCatalogContext.ProductCatalogService;
  // => Import Supplier's public contracts

  // Customer's domain model
  export class OrderItem {
    // => Maintains consistency boundary
    private readonly productId: string; // => Reference to catalog product
    // => Applies domain event
    private readonly productName: string; // => Cached name
    // => Coordinates with bounded context
    private readonly price: number; // => Price at order time
    // => Implements tactical pattern
    private readonly quantity: number; // => Quantity ordered

    constructor(productId: string, productName: string, price: number, quantity: number) {
      // => Protects aggregate integrity
      this.productId = productId; // => Initialize product ID
      // => Ensures transactional consistency
      this.productName = productName; // => Initialize cached name
      // => Manages entity lifecycle
      this.price = price; // => Initialize price snapshot
      this.quantity = quantity; // => Initialize quantity
    }
    // => Delegates to domain service

    getTotalPrice(): number {
      // => Domain operation: getTotalPrice
      return this.price * this.quantity; // => Calculate line total
    }
    // => Maintains consistency boundary

    getProductName(): string {
      // => Domain operation: getProductName
      return this.productName; // => Expose product name
    }
    // => Applies domain event
  }
  // => Coordinates with bounded context

  // Customer's service using Supplier
  export class OrderService {
    // => OrderService: domain model element
    constructor(private catalogService: ProductCatalogService) {}
    // => Inject Supplier's service

    createOrderItem(productId: string, quantity: number): OrderItem {
      // => Domain operation: createOrderItem
      const productDTO = this.catalogService.getProduct(productId);
      // => Call Supplier's API to get product
      if (!productDTO) {
        // => Validate product exists
        throw new Error("Product not found");
        // => Raise domain exception
      }
      // => Implements tactical pattern
      return new OrderItem(productDTO.productId, productDTO.name, productDTO.price, quantity);
      // => Create order item with product data from Supplier
    }
    // => Protects aggregate integrity
  }
  // => Ensures transactional consistency
}
// => Manages entity lifecycle

// Usage - Customer depends on Supplier
const catalogService = new ProductCatalogContext.ProductCatalogServiceImpl();
// => Supplier service instantiated
const orderService = new OrderManagementContext.OrderService(catalogService);
// => Customer service depends on Supplier

const orderItem = orderService.createOrderItem("P1", 2);
// => Calls Supplier API: getProduct("P1")
// => Creates OrderItem with product data
console.log(`Ordered: ${orderItem.getProductName()}, Total: ${orderItem.getTotalPrice()}`);
// => Outputs result
// => Output: Ordered: Laptop, Total: 240000

// External Payment Gateway - Third-party system with its own model
namespace ExternalPaymentGateway {
  // External system's data structure (we don't control this)
  export interface PaymentResponse {
    transaction_id: string; // => Snake case naming
    status_code: number; // => Numeric status codes
    amount_cents: number; // => Amount in cents
    currency_iso: string; // => ISO currency code
    timestamp_ms: number; // => Unix timestamp
    customer_ref: string; // => External customer reference
  }

  // Simulated external API
  export class PaymentGatewayAPI {
    // => PaymentGatewayAPI: domain model element
    processPayment(amount: number, currency: string, customerRef: string): PaymentResponse {
      // => Domain operation: processPayment
      // => External system processes payment
      return {
        // => Returns {
        transaction_id: `TXN-${Date.now()}`, // => Generate transaction ID
        status_code: 200, // => 200 = success in their system
        amount_cents: amount,
        currency_iso: currency,
        timestamp_ms: Date.now(),
        // => Execute method
        customer_ref: customerRef,
      };
    }
  }
}

// Our Bounded Context - with its own domain model
namespace PaymentContext {
  // Our domain model - uses our ubiquitous language
  export class Payment {
    private readonly paymentId: string; // => Our naming: paymentId
    private readonly amount: Money; // => Our Money value object
    private readonly status: PaymentStatus; // => Our status enum
    private readonly processedAt: Date; // => Our Date type

    constructor(paymentId: string, amount: Money, status: PaymentStatus, processedAt: Date) {
      this.paymentId = paymentId; // => Initialize payment ID
      this.amount = amount; // => Initialize amount
      this.status = status; // => Initialize status
      this.processedAt = processedAt; // => Initialize timestamp
    }

    isSuccessful(): boolean {
      // => Domain operation: isSuccessful
      return this.status === PaymentStatus.COMPLETED;
      // => Check if payment succeeded
    }

    getPaymentId(): string {
      // => Domain operation: getPaymentId
      return this.paymentId; // => Expose payment ID
    }

    getAmount(): Money {
      // => Domain operation: getAmount
      return this.amount; // => Expose amount
    }
  }

  export class Money {
    // => Money: domain model element
    constructor(
      // => Initialize object with parameters
      private readonly amount: number,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly currency: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
    ) {}

    getAmount(): number {
      // => Domain operation: getAmount
      return this.amount; // => Expose amount
    }

    getCurrency(): string {
      // => Domain operation: getCurrency
      return this.currency; // => Expose currency
    }
  }

  export enum PaymentStatus {
    PENDING = "PENDING", // => Payment initiated
    COMPLETED = "COMPLETED", // => Payment succeeded
    FAILED = "FAILED", // => Payment failed
  }

  // Anti-Corruption Layer - Translates external model to our model
  export class PaymentGatewayAdapter {
    // => PaymentGatewayAdapter: domain model element
    constructor(private readonly gateway: ExternalPaymentGateway.PaymentGatewayAPI) {}
    // => Adapter wraps external system

    processPayment(amount: Money, customerRef: string): Payment {
      // => Domain operation: processPayment
      // => Public method uses our domain model
      const response = this.gateway.processPayment(amount.getAmount(), amount.getCurrency(), customerRef);
      // => Call external API (uses their model)

      return this.translateToPayment(response);
      // => Translate external response to our domain model
    }

    private translateToPayment(response: ExternalPaymentGateway.PaymentResponse): Payment {
      // => Internal logic (not part of public API)
      // => ACL translation logic
      const money = new Money(response.amount_cents, response.currency_iso);
      // => Convert external amount to our Money type

      const status = this.translateStatus(response.status_code);
      // => Convert external status code to our enum

      const processedAt = new Date(response.timestamp_ms);
      // => Convert Unix timestamp to Date

      return new Payment(response.transaction_id, money, status, processedAt);
      // => Create our domain model from external data
    }

    private translateStatus(statusCode: number): PaymentStatus {
      // => Internal logic (not part of public API)
      // => Map external status codes to our enum
      switch (statusCode) {
        // => Operation: switch()
        case 200:
          return PaymentStatus.COMPLETED; // => 200 → COMPLETED
        // => Returns PaymentStatus.COMPLETED; // => 200 → COMPLETED
        case 400:
        case 500:
          return PaymentStatus.FAILED; // => Error codes → FAILED
        // => Returns PaymentStatus.FAILED; // => Error codes → FAILED
        default:
          return PaymentStatus.PENDING; // => Unknown → PENDING
        // => Returns PaymentStatus.PENDING; // => Unknown → PENDING
      }
    }
  }
}

// Usage - ACL protects our domain from external model
const externalGateway = new ExternalPaymentGateway.PaymentGatewayAPI();
// => External system instantiated
const adapter = new PaymentContext.PaymentGatewayAdapter(externalGateway);
// => ACL adapter wraps external system

const money = new PaymentContext.Money(5000, "USD");
// => Our Money value object
const payment = adapter.processPayment(money, "CUST-123");
// => Process payment through ACL
// => ACL calls external API, translates response to our model

console.log(`Payment ${payment.getPaymentId()} successful: ${payment.isSuccessful()}`);
// => Outputs result
// => Output: Payment TXN-[timestamp] successful: true

// Published Language - Shared contract for Order events
namespace OrderEventPublishedLanguage {
  // => Executes domain logic
  // Version 1.0 - Stable, documented contract
  export interface OrderCreatedEvent {
    // => Coordinates with bounded context
    eventType: "OrderCreated"; // => Event discriminator
    // => Implements tactical pattern
    version: "1.0"; // => Schema version for compatibility
    // => Protects aggregate integrity
    timestamp: string; // => ISO 8601 timestamp
    // => Ensures transactional consistency
    payload: {
      // => Manages entity lifecycle
      orderId: string; // => Order identifier
      // => Preserves domain model
      customerId: string; // => Customer reference
      // => Communicates domain intent
      items: Array<{
        // => Order line items
        productId: string; // => Product reference
        // => Executes domain logic
        quantity: number; // => Quantity ordered
        // => Updates aggregate state
        priceAtOrder: number; // => Price snapshot in cents
        // => Validates business rule
      }>;
      // => Enforces invariant
      totalAmount: number; // => Total in cents
      // => Encapsulates domain knowledge
      currency: string; // => Currency code (ISO 4217)
      // => Delegates to domain service
    };
    // => Updates aggregate state
  }
  // => Validates business rule

  // Validator for Published Language contract
  export class OrderCreatedEventValidator {
    // => OrderCreatedEventValidator: domain model element
    static validate(event: any): event is OrderCreatedEvent {
      // => Type guard for validation
      return (
        // => Returns (
        event.eventType === "OrderCreated" && // => Check event type
        // => Maintains consistency boundary
        event.version === "1.0" && // => Check schema version
        // => Applies domain event
        typeof event.timestamp === "string" && // => Validate timestamp
        // => Coordinates with bounded context
        typeof event.payload.orderId === "string" && // => Validate orderId
        // => Implements tactical pattern
        Array.isArray(event.payload.items) && // => Validate items array
        // => Protects aggregate integrity
        typeof event.payload.totalAmount === "number" // => Validate total
        // => Ensures transactional consistency
      );
      // => Enforces invariant
    }
    // => Encapsulates domain knowledge
  }
  // => Delegates to domain service
}
// => Maintains consistency boundary

// Context 1 (Publisher) - Order Management publishes events
namespace OrderManagementContext {
  // => Applies domain event
  import OrderCreatedEvent = OrderEventPublishedLanguage.OrderCreatedEvent;
  // => Import Published Language contract

  export class Order {
    // => Order: domain model element
    constructor(
      // => Initialize object with parameters
      private readonly orderId: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly customerId: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly items: OrderItem[],
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly totalAmount: number,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
    ) {}
    // => Coordinates with bounded context

    // Translate internal model to Published Language
    toOrderCreatedEvent(): OrderCreatedEvent {
      // => Domain operation: toOrderCreatedEvent
      // => Convert domain model to Published Language
      return {
        // => Returns {
        eventType: "OrderCreated",
        // => Implements tactical pattern
        version: "1.0",
        // => Manages entity lifecycle
        timestamp: new Date().toISOString(), // => ISO 8601 format
        // => Preserves domain model
        payload: {
          // => Protects aggregate integrity
          orderId: this.orderId,
          // => Ensures transactional consistency
          customerId: this.customerId,
          // => Manages entity lifecycle
          items: this.items.map((item) => ({
            // => Map domain items to Published Language
            productId: item.productId,
            // => Preserves domain model
            quantity: item.quantity,
            // => Communicates domain intent
            priceAtOrder: item.price,
            // => Executes domain logic
          })),
          // => Updates aggregate state
          totalAmount: this.totalAmount,
          // => Validates business rule
          currency: "USD",
          // => Enforces invariant
        },
        // => Encapsulates domain knowledge
      };
      // => Delegates to domain service
    }
    // => Maintains consistency boundary
  }
  // => Applies domain event

  export class OrderItem {
    // => OrderItem: domain model element
    constructor(
      // => Initialize object with parameters
      public readonly productId: string,
      // => Field: readonly (public)
      public readonly quantity: number,
      // => Field: readonly (public)
      public readonly price: number,
      // => Field: readonly (public)
    ) {}
    // => Coordinates with bounded context
  }
  // => Implements tactical pattern
}
// => Protects aggregate integrity

// Context 2 (Subscriber) - Billing consumes events
namespace BillingContext {
  // => Ensures transactional consistency
  import OrderCreatedEvent = OrderEventPublishedLanguage.OrderCreatedEvent;
  // => Manages entity lifecycle
  import Validator = OrderEventPublishedLanguage.OrderCreatedEventValidator;
  // => Import Published Language contract and validator

  export class BillingService {
    // => BillingService: domain model element
    handleOrderCreated(event: OrderCreatedEvent): void {
      // => Domain operation: handleOrderCreated
      // => Receive event in Published Language format
      if (!Validator.validate(event)) {
        // => Validate against Published Language schema
        throw new Error("Invalid OrderCreatedEvent");
        // => Raise domain exception
      }
      // => Preserves domain model

      const invoice = this.createInvoice(event);
      // => Translate Published Language to our domain model
      console.log(`Invoice created: ${invoice.invoiceId}`);
      // => Outputs result
      // => Process in our context's ubiquitous language
    }
    // => Communicates domain intent

    private createInvoice(event: OrderCreatedEvent): Invoice {
      // => Internal logic (not part of public API)
      // => Convert Published Language to our domain model
      return new Invoice(
        // => Communicates domain intent
        `INV-${event.payload.orderId}`, // => Generate invoice ID
        // => Executes domain logic
        event.payload.customerId,
        // => Executes domain logic
        event.payload.totalAmount,
        // => Updates aggregate state
      );
      // => Validates business rule
    }
    // => Enforces invariant
  }
  // => Encapsulates domain knowledge

  class Invoice {
    // => Invoice: domain model element
    constructor(
      // => Initialize object with parameters
      public readonly invoiceId: string,
      // => Field: readonly (public)
      public readonly customerId: string,
      // => Field: readonly (public)
      public readonly amount: number,
      // => Field: readonly (public)
    ) {}
    // => Delegates to domain service
  }
  // => Maintains consistency boundary
}
// => Applies domain event

// Usage - Published Language enables clean integration
const orderItem = new OrderManagementContext.OrderItem("P123", 2, 5000);
// => orderItem: productId="P123", quantity=2, price=5000
const order = new OrderManagementContext.Order("O456", "C789", [orderItem], 10000);
// => order: orderId="O456", totalAmount=10000

const event = order.toOrderCreatedEvent();
// => Convert to Published Language format
console.log(`Event version: ${event.version}, Type: ${event.eventType}`);
// => Outputs result
// => Output: Event version: 1.0, Type: OrderCreated

const billingService = new BillingContext.BillingService();
// => Billing context service
billingService.handleOrderCreated(event);
// => Consume Published Language event
// => Output: Invoice created: INV-O456

// External System - Legacy ERP we must integrate with
namespace LegacyERPSystem {
  // ERP's model (we don't control this)
  export class ERPCustomer {
    cust_id: string; // => Legacy naming convention
    full_name_text: string; // => Verbose field names
    email_addr: string; // => Abbreviated naming
    credit_limit_cents: number; // => Amount in cents
    status_flag: number; // => 1=active, 0=inactive

    constructor(
      // => Initialize object with parameters
      cust_id: string,
      full_name_text: string,
      email_addr: string,
      credit_limit_cents: number,
      status_flag: number,
    ) {
      this.cust_id = cust_id; // => Initialize customer ID
      this.full_name_text = full_name_text; // => Initialize name
      this.email_addr = email_addr; // => Initialize email
      this.credit_limit_cents = credit_limit_cents; // => Initialize credit limit
      this.status_flag = status_flag; // => Initialize status
    }
  }

  export class ERPService {
    // => ERPService: domain model element
    private customers: Map<string, ERPCustomer> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => ERP customer storage

    getCustomer(cust_id: string): ERPCustomer | null {
      // => Domain operation: getCustomer
      return this.customers.get(cust_id) || null;
      // => Retrieve customer by legacy ID format
    }

    saveCustomer(customer: ERPCustomer): void {
      // => Domain operation: saveCustomer
      this.customers.set(customer.cust_id, customer);
      // => Delegates to internal method
      // => Store customer in ERP
    }
  }
}

// Our Context - Conformist approach (no translation layer)
namespace SalesContext {
  import ERPCustomer = LegacyERPSystem.ERPCustomer;
  import ERPService = LegacyERPSystem.ERPService;
  // => Direct import of ERP types (conformist)

  // We conform to ERP's model instead of maintaining our own
  export class SalesService {
    // => SalesService: domain model element
    constructor(private erpService: ERPService) {}
    // => Inject ERP service

    createCustomer(name: string, email: string, creditLimit: number): ERPCustomer {
      // => Domain operation: createCustomer
      // => Use ERP model directly in our domain
      const customer = new ERPCustomer(
        `CUST-${Date.now()}`, // => Generate ERP-format ID
        name,
        email,
        creditLimit * 100, // => Convert to cents for ERP
        1, // => 1 = active in ERP's convention
      );
      // => Create ERP customer directly

      this.erpService.saveCustomer(customer);
      // => Delegates to internal method
      // => Save using ERP service
      return customer; // => Return ERP model
      // => Returns customer; // => Return ERP model
    }

    isCustomerActive(customer: ERPCustomer): boolean {
      // => Domain operation: isCustomerActive
      // => Our business logic uses ERP conventions
      return customer.status_flag === 1;
      // => Returns customer.status_flag === 1
      // => Check status using ERP's numeric flag
    }

    getCreditLimitDollars(customer: ERPCustomer): number {
      // => Domain operation: getCreditLimitDollars
      // => Our helper methods work with ERP model
      return customer.credit_limit_cents / 100;
      // => Returns customer.credit_limit_cents / 100
      // => Convert cents to dollars
    }
  }
}

// Usage - Conformist pattern (accept external model)
const erpService = new LegacyERPSystem.ERPService();
// => ERP service instantiated
const salesService = new SalesContext.SalesService(erpService);
// => Our service conforms to ERP

const customer = salesService.createCustomer("Alice", "alice@example.com", 5000);
// => Creates ERPCustomer directly
console.log(`Customer: ${customer.full_name_text}, Active: ${salesService.isCustomerActive(customer)}`);
// => Outputs result
// => Output: Customer: Alice, Active: true
console.log(`Credit limit: $${salesService.getCreditLimitDollars(customer)}`);
// => Outputs result
// => Output: Credit limit: $5000

// Our Bounded Context - Inventory Management (Host)
namespace InventoryContext {
  // => Executes domain logic
  // Internal domain model (private)
  class Product {
    // => Product: domain model element
    constructor(
      // => Initialize object with parameters
      private readonly productId: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private readonly name: string,
      // => Field: readonly (private)
      // => Encapsulated state, not directly accessible
      private stockLevel: number,
      // => Encapsulated field (not publicly accessible)
    ) {}
    // => Updates aggregate state

    reserveStock(quantity: number): void {
      // => Domain operation: reserveStock
      if (this.stockLevel < quantity) {
        // => Validate sufficient stock
        throw new Error("Insufficient stock");
        // => Raise domain exception
      }
      // => Manages entity lifecycle
      this.stockLevel -= quantity; // => Reduce available stock
      // => Modifies stockLevel
      // => State change operation
      // => Stock reserved successfully
    }
    // => Validates business rule

    getStockLevel(): number {
      // => Domain operation: getStockLevel
      return this.stockLevel; // => Expose current stock
      // => Preserves domain model
    }
    // => Enforces invariant

    getProductId(): string {
      // => Domain operation: getProductId
      return this.productId; // => Expose product ID
      // => Communicates domain intent
    }
    // => Encapsulates domain knowledge

    getName(): string {
      // => Domain operation: getName
      return this.name; // => Expose product name
      // => Executes domain logic
    }
    // => Delegates to domain service
  }
  // => Maintains consistency boundary

  // Public API - Open Host Service
  export interface InventoryService {
    // => Public interface for external contexts
    checkAvailability(productId: string): StockAvailabilityDTO;
    // => Domain operation: checkAvailability
    // => Check stock availability
    reserveStock(request: StockReservationRequest): StockReservationResult;
    // => Domain operation: reserveStock
    // => Reserve stock for order
  }
  // => Applies domain event

  // Public DTOs - Well-documented contracts
  export interface StockAvailabilityDTO {
    // => Updates aggregate state
    productId: string; // => Product identifier
    // => Validates business rule
    productName: string; // => Product name
    // => Enforces invariant
    availableQuantity: number; // => Current stock level
    // => Encapsulates domain knowledge
    isAvailable: boolean; // => Availability flag
    // => Delegates to domain service
  }
  // => Coordinates with bounded context

  export interface StockReservationRequest {
    // => Maintains consistency boundary
    productId: string; // => Product to reserve
    // => Applies domain event
    quantity: number; // => Quantity to reserve
    // => Coordinates with bounded context
    reservationId: string; // => Idempotency key
    // => Implements tactical pattern
  }
  // => Implements tactical pattern

  export interface StockReservationResult {
    // => Protects aggregate integrity
    success: boolean; // => Reservation outcome
    // => Ensures transactional consistency
    reservationId: string; // => Idempotency key
    // => Manages entity lifecycle
    remainingStock: number; // => Stock after reservation
    // => Preserves domain model
  }
  // => Protects aggregate integrity

  // Open Host Service implementation
  export class InventoryServiceImpl implements InventoryService {
    // => InventoryServiceImpl: domain model element
    private products: Map<string, Product> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => Internal product storage

    constructor() {
      // => Initialize object with parameters
      // Seed initial inventory
      this.products.set("P1", new Product("P1", "Laptop", 50));
      // => Delegates to internal method
      // => Product P1: stockLevel=50
      this.products.set("P2", new Product("P2", "Mouse", 200));
      // => Delegates to internal method
      // => Product P2: stockLevel=200
    }
    // => Ensures transactional consistency

    checkAvailability(productId: string): StockAvailabilityDTO {
      // => Domain operation: checkAvailability
      // => Public method: check stock
      const product = this.products.get(productId);
      // => Retrieve product from internal model

      if (!product) {
        // => Product not found
        return {
          // => Returns {
          productId,
          // => Manages entity lifecycle
          productName: "Unknown",
          // => Preserves domain model
          availableQuantity: 0,
          // => Communicates domain intent
          isAvailable: false,
          // => Executes domain logic
        };
        // => Return unavailable DTO
      }
      // => Updates aggregate state

      return {
        // => Returns {
        // => Convert internal model to public DTO
        productId: product.getProductId(),
        // => Execute method
        productName: product.getName(),
        // => Execute method
        availableQuantity: product.getStockLevel(),
        // => Execute method
        isAvailable: product.getStockLevel() > 0,
        // => Execute method
      };
      // => Return availability DTO
    }
    // => Validates business rule

    reserveStock(request: StockReservationRequest): StockReservationResult {
      // => Domain operation: reserveStock
      // => Public method: reserve stock
      const product = this.products.get(request.productId);
      // => Retrieve product

      if (!product) {
        // => Product not found
        return {
          // => Returns {
          success: false,
          // => Enforces invariant
          reservationId: request.reservationId,
          // => Encapsulates domain knowledge
          remainingStock: 0,
          // => Delegates to domain service
        };
        // => Maintains consistency boundary
      }
      // => Applies domain event

      try {
        // => Coordinates with bounded context
        product.reserveStock(request.quantity);
        // => Attempt reservation on domain model
        return {
          // => Returns {
          success: true,
          // => Implements tactical pattern
          reservationId: request.reservationId,
          // => Protects aggregate integrity
          remainingStock: product.getStockLevel(),
          // => Execute method
        };
        // => Return success result
      } catch (error) {
        // => Reservation failed (insufficient stock)
        return {
          // => Returns {
          success: false,
          // => Ensures transactional consistency
          reservationId: request.reservationId,
          // => Manages entity lifecycle
          remainingStock: product.getStockLevel(),
          // => Execute method
        };
        // => Return failure result
      }
      // => Preserves domain model
    }
    // => Communicates domain intent
  }
  // => Executes domain logic
}
// => Updates aggregate state

// Consumer Context - Order Management uses Open Host Service
namespace OrderContext {
  // => Validates business rule
  import InventoryService = InventoryContext.InventoryService;
  // => Enforces invariant
  import StockReservationRequest = InventoryContext.StockReservationRequest;
  // => Import public contracts from Open Host

  export class OrderService {
    // => OrderService: domain model element
    constructor(private inventoryService: InventoryService) {}
    // => Depend on Open Host Service interface

    placeOrder(productId: string, quantity: number): void {
      // => Domain operation: placeOrder
      // => Place order using inventory service
      const availability = this.inventoryService.checkAvailability(productId);
      // => Check availability via Open Host Service

      if (!availability.isAvailable || availability.availableQuantity < quantity) {
        // => Validate stock sufficient
        throw new Error("Product not available");
        // => Raise domain exception
      }
      // => Encapsulates domain knowledge

      const result = this.inventoryService.reserveStock({
        // => Reserve stock via Open Host Service
        productId,
        // => Delegates to domain service
        quantity,
        // => Maintains consistency boundary
        reservationId: `RES-${Date.now()}`,
        // => Execute method
      });
      // => Applies domain event

      if (!result.success) {
        // => Validate reservation succeeded
        throw new Error("Reservation failed");
        // => Raise domain exception
      }
      // => Coordinates with bounded context

      console.log(`Order placed. Remaining stock: ${result.remainingStock}`);
      // => Outputs result
      // => Output success message
    }
    // => Implements tactical pattern
  }
  // => Protects aggregate integrity
}
// => Ensures transactional consistency

// Usage - Multiple consumers can easily integrate
const inventoryService = new InventoryContext.InventoryServiceImpl();
// => Open Host Service instantiated

const availability = inventoryService.checkAvailability("P1");
// => Check stock via public API
console.log(`${availability.productName}: ${availability.availableQuantity} available`);
// => Outputs result
// => Output: Laptop: 50 available

const orderService = new OrderContext.OrderService(inventoryService);
// => Consumer uses Open Host Service
orderService.placeOrder("P1", 5);
// => Order placed. Remaining stock: 45

// Context 1 - Employee HR Management
namespace HRContext {
  export class Employee {
    // => HR's Employee model
    private readonly employeeId: string; // => HR identifier
    private readonly fullName: string; // => Legal name
    private readonly department: string; // => Org structure
    private readonly salary: number; // => Compensation info
    private readonly hireDate: Date; // => Employment start date

    constructor(employeeId: string, fullName: string, department: string, salary: number, hireDate: Date) {
      this.employeeId = employeeId; // => Initialize employee ID
      this.fullName = fullName; // => Initialize name
      this.department = department; // => Initialize department
      this.salary = salary; // => Initialize salary
      this.hireDate = hireDate; // => Initialize hire date
    }

    promoteEmployee(newDepartment: string, newSalary: number): void {
      // => Domain operation: promoteEmployee
      // => HR operation: promotion
      // Note: No integration with CustomerSupport context
      console.log(`Promoted ${this.fullName} to ${newDepartment}`);
      // => Delegates to internal method
      // => Outputs result
      // => HR-specific business logic
    }

    getEmployeeId(): string {
      // => Domain operation: getEmployeeId
      return this.employeeId; // => Expose employee ID
    }
  }

  export class HRService {
    private employees: Map<string, Employee> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => HR employee records

    hireEmployee(employee: Employee): void {
      // => Domain operation: hireEmployee
      this.employees.set(employee.getEmployeeId(), employee);
      // => Delegates to internal method
      // => Add employee to HR system
      console.log("Employee hired in HR system");
      // => Outputs result
      // => HR-specific process (no external context notified)
    }
  }
}

// Context 2 - Customer Support Ticketing (completely independent)
namespace CustomerSupportContext {
  export class SupportAgent {
    // => Support's Agent model (different from HR Employee!)
    private readonly agentId: string; // => Support identifier
    private readonly displayName: string; // => Customer-facing name
    private readonly skillSet: string[]; // => Support categories
    private readonly activeTickets: number = 0; // => Current workload

    constructor(agentId: string, displayName: string, skillSet: string[]) {
      this.agentId = agentId; // => Initialize agent ID
      this.displayName = displayName; // => Initialize display name
      this.skillSet = skillSet; // => Initialize skills
    }

    assignTicket(ticket: SupportTicket): void {
      // => Domain operation: assignTicket
      // => Support operation: ticket assignment
      // Note: No integration with HR context
      console.log(`Ticket assigned to ${this.displayName}`);
      // => Delegates to internal method
      // => Outputs result
      // => Support-specific business logic
    }

    getAgentId(): string {
      // => Domain operation: getAgentId
      return this.agentId; // => Expose agent ID
    }
  }

  export class SupportTicket {
    constructor(
      private readonly ticketId: string,
      private readonly description: string,
    ) {}

    getTicketId(): string {
      // => Domain operation: getTicketId
      return this.ticketId; // => Expose ticket ID
    }
  }

  export class SupportService {
    private agents: Map<string, SupportAgent> = new Map();
    // => Encapsulated field (not publicly accessible)
    // => Support agent records

    registerAgent(agent: SupportAgent): void {
      // => Domain operation: registerAgent
      this.agents.set(agent.getAgentId(), agent);
      // => Delegates to internal method
      // => Add agent to Support system
      console.log("Agent registered in Support system");
      // => Outputs result
      // => Support-specific process (no HR context notified)
    }
  }
}

// Usage - Separate Ways: No integration between contexts
const hrService = new HRContext.HRService();
// => HR context service
const employee = new HRContext.Employee("E123", "Alice Johnson", "Engineering", 120000, new Date("2024-01-15"));
// => HR Employee entity
hrService.hireEmployee(employee);
// => Output: Employee hired in HR system
// => Note: No notification to Support context

const supportService = new CustomerSupportContext.SupportService();
// => Support context service (independent)
const agent = new CustomerSupportContext.SupportAgent("A456", "Alice J.", ["Technical", "Billing"]);
// => Support Agent entity (unrelated to HR Employee)
supportService.registerAgent(agent);
// => Output: Agent registered in Support system
// => Note: No notification to HR context

// These contexts operate independently - no shared data, no integration
console.log("Contexts operate separately with no integration");
// => Outputs result