@cosmneo/onion-lasagna 0.1.0

package/dist/backend/core/onion-layers.d.cts

@@ -0,0 +1,1675 @@
+import { B as BaseDto } from '../../base-dto.class-D7W9iqoU.cjs';
+import { B as BaseInboundPort } from '../../index-DingXh7B.cjs';
+export { A as AccessDeniedError, d as AccessGuard, e as AccessGuardResult, l as ApiKeyAuthScheme, o as AuthScheme, b as BaseController, a as BaseControllerConfig, C as ControllerError, E as EnhancedHttpRequest, f as EnhancedRequest, c as GuardedController, G as GuardedControllerConfig, n as HttpBasicAuthScheme, m as HttpBearerAuthScheme, j as HttpEndpointMetadata, k as HttpEndpointMetadataFor, H as HttpEndpointMethod, h as HttpEndpointOpenApi, i as HttpEndpointOpenApiFor, g as HttpSuccessStatus, I as InvalidRequestError, R as ResourceMetadata, q as SchemeNamesOf, r as SecurityRequirementOf, S as ServiceMetadata, p as SystemMetadata, v as assertHttpResponse, t as computeRoutePath, s as defineSystemMetadata, u as isHttpResponse } from '../../index-DingXh7B.cjs';
+import { C as CodedError, A as AppErrorCode, D as DomainErrorCode, I as InfraErrorCode } from '../../validation-error.type-kD4_qNZ9.cjs';
+import { j as BaseValueObject, i as BaseUuidV7Vo } from '../../base-uuid-v7.vo-BjqKX44G.cjs';
+export { B as BaseAuditByVo, b as BaseAuditInfoVo, c as BaseAuditOnVo, d as BaseEmailVo, e as BaseLongTextVo, f as BaseMediumTextVo, g as BasePaginationVo, h as BaseShortTextVo, a as BaseUuidV4Vo, S as SKIP_VALUE_OBJECT_VALIDATION, k as SkipValueObjectValidation } from '../../base-uuid-v7.vo-BjqKX44G.cjs';
+export { C as Controller, H as HttpRequest, a as HttpResponse } from '../../http-response-BAhi8lF4.cjs';
+export { H as HttpMethod, b as RequestDtoFactory, R as RouteInput, a as RouteMetadata } from '../../routing.type-DF2BIL7x.cjs';
+
+/**
+ * Abstract base class for use case handlers (inbound adapters).
+ *
+ * Implements the {@link BaseInboundPort} interface and provides:
+ * - Automatic error wrapping for unexpected exceptions
+ * - Pass-through for known error types (UseCaseError, DomainError, InfraError)
+ *
+ * Subclasses implement the `handle` method with the actual use case logic.
+ *
+ * @typeParam TInDto - Input DTO type, must extend BaseDto
+ * @typeParam TOutDto - Output DTO type, must extend BaseDto
+ *
+ * @example
+ * ```typescript
+ * class CreateUserUseCase extends BaseInboundAdapter<CreateUserInputDto, CreateUserOutputDto> {
+ *   protected async handle(input: CreateUserInputDto): Promise<CreateUserOutputDto> {
+ *     const user = await this.userRepo.create(input.value);
+ *     return CreateUserOutputDto.create(user);
+ *   }
+ * }
+ * ```
+ */
+declare abstract class BaseInboundAdapter<TInDto extends BaseDto<unknown>, TOutDto extends BaseDto<unknown>> implements BaseInboundPort<TInDto, TOutDto> {
+    /**
+     * Implements the use case logic. Override this method in subclasses.
+     *
+     * @param input - Validated input DTO
+     * @returns Promise resolving to the output DTO
+     */
+    protected abstract handle(input: TInDto): Promise<TOutDto>;
+    /**
+     * Executes the use case with error boundary protection.
+     *
+     * Known error types are re-thrown as-is to preserve error semantics.
+     * Unknown errors are wrapped in a UseCaseError to maintain error hierarchy.
+     *
+     * @param input - Validated input DTO
+     * @returns Promise resolving to the output DTO
+     * @throws {ObjectValidationError} For validation failures (propagated to controller)
+     * @throws {UseCaseError} For use case failures or wrapped unknown errors
+     * @throws {DomainError} For domain invariant violations
+     * @throws {InfraError} For infrastructure failures
+     */
+    execute(input: TInDto): Promise<TOutDto>;
+}
+
+/**
+ * Base error class for application layer (use case) failures.
+ *
+ * Use case errors represent failures in the application's business logic
+ * orchestration, such as resource conflicts, missing entities, or
+ * unprocessable requests. They bridge domain errors to the presentation layer.
+ *
+ * **When to throw:**
+ * - Resource not found (e.g., "User with ID X not found")
+ * - Conflict states (e.g., "Email already registered")
+ * - Unprocessable business operations
+ *
+ * **Child classes:**
+ * - {@link ConflictError} - Resource state conflicts (HTTP 409)
+ * - {@link NotFoundError} - Resource not found (HTTP 404)
+ * - {@link UnprocessableError} - Valid but unprocessable request (HTTP 422)
+ *
+ * @example
+ * ```typescript
+ * const user = await this.userRepo.findById(id);
+ * if (!user) {
+ *   throw new NotFoundError({
+ *     message: `User with ID ${id} not found`,
+ *     code: 'USER_NOT_FOUND',
+ *   });
+ * }
+ * ```
+ */
+declare class UseCaseError extends CodedError {
+    /**
+     * Creates a new UseCaseError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Human-readable error description
+     * @param options.code - Machine-readable error code (default: 'USE_CASE_ERROR')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: AppErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a UseCaseError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new UseCaseError instance with the cause attached
+     */
+    static fromError(cause: unknown): UseCaseError;
+}
+
+/**
+ * Error thrown when a requested resource does not exist.
+ *
+ * Indicates that the entity or resource referenced by the request
+ * could not be found in the system.
+ *
+ * **When to throw:**
+ * - Entity lookup by ID returns null
+ * - Referenced resource doesn't exist
+ * - Parent entity for a child operation not found
+ *
+ * @example
+ * ```typescript
+ * const user = await this.userRepo.findById(userId);
+ * if (!user) {
+ *   throw new NotFoundError({
+ *     message: `User with ID ${userId} not found`,
+ *     code: 'USER_NOT_FOUND',
+ *   });
+ * }
+ * ```
+ *
+ * @extends UseCaseError
+ */
+declare class NotFoundError extends UseCaseError {
+    /**
+     * Creates a new NotFoundError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of what was not found
+     * @param options.code - Machine-readable error code (default: 'NOT_FOUND')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: AppErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a NotFoundError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new NotFoundError instance with the cause attached
+     */
+    static fromError(cause: unknown): NotFoundError;
+}
+
+/**
+ * Error thrown when an operation conflicts with existing state.
+ *
+ * Indicates that the requested operation cannot be completed because
+ * it would violate uniqueness constraints or cause state conflicts.
+ *
+ * **When to throw:**
+ * - Duplicate unique field (e.g., email already registered)
+ * - Optimistic locking conflict (stale version)
+ * - Concurrent modification detected
+ *
+ * @example
+ * ```typescript
+ * const existing = await this.userRepo.findByEmail(email);
+ * if (existing) {
+ *   throw new ConflictError({
+ *     message: 'Email already registered',
+ *     code: 'EMAIL_ALREADY_EXISTS',
+ *   });
+ * }
+ * ```
+ *
+ * @extends UseCaseError
+ */
+declare class ConflictError extends UseCaseError {
+    /**
+     * Creates a new ConflictError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of the conflict
+     * @param options.code - Machine-readable error code (default: 'CONFLICT')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: AppErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a ConflictError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new ConflictError instance with the cause attached
+     */
+    static fromError(cause: unknown): ConflictError;
+}
+
+/**
+ * Error thrown when a request is valid but cannot be processed.
+ *
+ * The request is syntactically correct and passes validation, but
+ * business logic prevents the operation from being completed.
+ *
+ * **When to throw:**
+ * - Business rule prevents operation (e.g., insufficient balance)
+ * - Invalid state transition (e.g., canceling a completed order)
+ * - Preconditions not met for the operation
+ *
+ * @example
+ * ```typescript
+ * if (account.balance < amount) {
+ *   throw new UnprocessableError({
+ *     message: 'Insufficient balance for withdrawal',
+ *     code: 'INSUFFICIENT_BALANCE',
+ *   });
+ * }
+ * ```
+ *
+ * @extends UseCaseError
+ */
+declare class UnprocessableError extends UseCaseError {
+    /**
+     * Creates a new UnprocessableError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of why the request cannot be processed
+     * @param options.code - Machine-readable error code (default: 'UNPROCESSABLE')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: AppErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates an UnprocessableError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new UnprocessableError instance with the cause attached
+     */
+    static fromError(cause: unknown): UnprocessableError;
+}
+
+/**
+ * Base class for Domain-Driven Design Entities.
+ *
+ * Entities are domain objects that have a distinct identity that runs through
+ * time and different states. Unlike Value Objects (compared by value),
+ * Entities are compared by their identity (ID).
+ *
+ * **Note:** Entities should be composed of Value Objects, which are self-validating.
+ * Therefore, entity-level validation is not needed - VOs validate themselves
+ * at construction time. Cross-property invariants should be checked in factory methods.
+ *
+ * Key characteristics:
+ * - **Identity**: Each entity has a unique identifier (must be a Value Object)
+ * - **Equality by identity**: Two entities with the same ID are considered equal
+ * - **Mutable state**: Entity properties can change while identity remains
+ * - **Composed of VOs**: Properties should be Value Objects (self-validating)
+ * - **Versioning**: Optional version field for optimistic locking
+ *
+ * @typeParam TId - The identity type (must extend BaseValueObject)
+ * @typeParam TProps - The properties type containing entity state (must be an object)
+ *
+ * @example
+ * ```typescript
+ * interface UserProps {
+ *   name: PersonName;
+ *   email: Email;
+ *   createdAt: DateVo;
+ * }
+ *
+ * class User extends BaseEntity<UserId, UserProps> {
+ *   private constructor(id: UserId, props: UserProps, version?: number) {
+ *     super(id, props, version);
+ *   }
+ *
+ *   static create(name: PersonName, email: Email): User {
+ *     const id = UserId.create();
+ *     return new User(id, {
+ *       name,
+ *       email,
+ *       createdAt: DateVo.now(),
+ *     });
+ *   }
+ *
+ *   static fromPersistence(id: UserId, props: UserProps, version: number): User {
+ *     return new User(id, props, version);
+ *   }
+ *
+ *   get name(): PersonName {
+ *     return this.props.name;
+ *   }
+ *
+ *   get email(): Email {
+ *     return this.props.email;
+ *   }
+ *
+ *   changeName(newName: PersonName): void {
+ *     this._props.name = newName;
+ *   }
+ * }
+ *
+ * const user1 = User.create(PersonName.create('John'), Email.create('john@example.com'));
+ * const user2 = User.fromPersistence(user1.id, { ...user1.props }, user1.version);
+ * user1.equals(user2); // true - same ID
+ * ```
+ */
+declare abstract class BaseEntity<TId extends BaseValueObject<unknown>, TProps extends object> {
+    private readonly _id;
+    protected _props: TProps;
+    private readonly _version;
+    /**
+     * Creates a new Entity instance.
+     *
+     * @param id - The unique identifier for this entity
+     * @param props - The entity's properties/state (should be composed of Value Objects)
+     * @param version - Optional version number for optimistic locking (defaults to 0)
+     */
+    protected constructor(id: TId, props: TProps, version?: number);
+    /**
+     * The unique identifier for this entity.
+     *
+     * @returns The entity's ID of type TId
+     */
+    get id(): TId;
+    /**
+     * The entity's properties/state.
+     *
+     * Protected to encourage encapsulation via specific getters.
+     * Subclasses should expose individual properties as needed.
+     *
+     * @returns The entity's properties of type TProps
+     */
+    protected get props(): TProps;
+    /**
+     * The version number for optimistic locking.
+     *
+     * Use this to detect concurrent modifications:
+     * - Load entity with version N
+     * - Attempt to save with "WHERE version = N"
+     * - If rows affected = 0, another process modified the entity
+     *
+     * @returns The current version number
+     */
+    get version(): number;
+    /**
+     * Compares this Entity with another for equality.
+     *
+     * Entities are equal if they have the same identity (ID).
+     * This differs from Value Objects which compare by value.
+     *
+     * @param other - The Entity to compare with
+     * @returns `true` if the IDs are equal, `false` otherwise
+     *
+     * @example
+     * ```typescript
+     * const user1 = User.create(PersonName.create('John'), Email.create('john@example.com'));
+     * const user2 = User.fromPersistence(user1.id, { name: PersonName.create('John Updated'), ... }, 1);
+     * user1.equals(user2); // true - same ID, different state
+     * ```
+     */
+    equals(other: BaseEntity<TId, TProps>): boolean;
+    /**
+     * Compares two IDs for equality.
+     *
+     * Since TId must extend BaseValueObject, we use the value object's
+     * `equals` method for comparison.
+     *
+     * @param a - First ID to compare
+     * @param b - Second ID to compare
+     * @returns `true` if IDs are equal, `false` otherwise
+     */
+    protected idEquals(a: TId, b: TId): boolean;
+    /**
+     * Returns the next version number.
+     *
+     * Call this when persisting changes to implement optimistic locking.
+     * The repository should save with version + 1.
+     *
+     * @returns The next version number (current + 1)
+     *
+     * @example
+     * ```typescript
+     * // In repository
+     * async save(entity: User): Promise<void> {
+     *   await this.db.update({
+     *     ...entity.toPersistence(),
+     *     version: entity.nextVersion(),
+     *   }).where({ id: entity.id, version: entity.version });
+     * }
+     * ```
+     */
+    protected nextVersion(): number;
+}
+
+/**
+ * Base class for Domain Events in Domain-Driven Design.
+ *
+ * Domain Events represent something meaningful that happened in the domain.
+ * They are immutable records of past occurrences that other parts of the
+ * system can react to.
+ *
+ * Key characteristics:
+ * - **Immutable**: Events are facts about the past, they cannot change
+ * - **Named in past tense**: e.g., OrderPlaced, UserRegistered, PaymentReceived
+ * - **Contain relevant data**: Include all information needed by handlers
+ * - **Raised by Aggregate Roots**: Events are collected and published after persistence
+ *
+ * @typeParam TPayload - The event-specific data payload type
+ *
+ * @example
+ * ```typescript
+ * interface OrderPlacedPayload {
+ *   orderId: string;
+ *   customerId: string;
+ *   items: Array<{ productId: string; quantity: number }>;
+ *   totalAmount: number;
+ * }
+ *
+ * class OrderPlacedEvent extends BaseDomainEvent<OrderPlacedPayload> {
+ *   constructor(payload: OrderPlacedPayload) {
+ *     super('OrderPlaced', payload.orderId, payload);
+ *   }
+ * }
+ *
+ * // In aggregate root
+ * class Order extends BaseAggregateRoot<OrderId, OrderProps> {
+ *   static create(customerId: string, items: OrderItem[]): Order {
+ *     const order = new Order(...);
+ *     order.addDomainEvent(new OrderPlacedEvent({
+ *       orderId: order.id.value,
+ *       customerId,
+ *       items: items.map(i => ({ productId: i.productId, quantity: i.quantity })),
+ *       totalAmount: order.totalAmount,
+ *     }));
+ *     return order;
+ *   }
+ * }
+ * ```
+ */
+declare abstract class BaseDomainEvent<TPayload = unknown> {
+    private readonly _eventId;
+    private readonly _eventName;
+    private readonly _aggregateId;
+    private readonly _occurredOn;
+    private readonly _payload;
+    /**
+     * Deep clones an object, handling Date objects specially.
+     *
+     * @param obj - The object to clone
+     * @returns A deep copy of the object
+     */
+    private static deepClone;
+    /**
+     * Recursively freezes an object and all nested objects.
+     *
+     * @param obj - The object to deep freeze
+     * @returns The frozen object
+     */
+    private static deepFreeze;
+    /**
+     * Creates an immutable copy of the payload.
+     *
+     * Clones the payload first to avoid mutating the original object,
+     * then deep-freezes the clone to ensure immutability.
+     *
+     * @param payload - The payload to clone and freeze
+     * @returns An immutable copy of the payload
+     */
+    private static cloneAndFreeze;
+    /**
+     * Creates a new Domain Event.
+     *
+     * The payload is cloned and deep-frozen to ensure immutability. The original
+     * object passed in remains unmodified. Any attempt to modify the event's
+     * payload after creation will throw a TypeError in strict mode.
+     *
+     * @param eventName - The name of the event (e.g., 'OrderPlaced', 'UserRegistered')
+     * @param aggregateId - The ID of the aggregate that raised this event
+     * @param payload - The event-specific data (will be cloned and deep-frozen)
+     * @param eventId - Optional custom event ID (defaults to crypto.randomUUID())
+     * @param occurredOn - Optional timestamp (defaults to now)
+     */
+    protected constructor(eventName: string, aggregateId: string, payload: TPayload, eventId?: string, occurredOn?: Date);
+    /**
+     * Unique identifier for this event instance.
+     *
+     * Useful for idempotency checks and event deduplication.
+     */
+    get eventId(): string;
+    /**
+     * The name/type of this event.
+     *
+     * Used for routing events to appropriate handlers.
+     * Should be in PastTense format (e.g., 'OrderPlaced', 'UserRegistered').
+     */
+    get eventName(): string;
+    /**
+     * The ID of the aggregate that raised this event.
+     *
+     * Useful for event sourcing and aggregate-specific event streams.
+     */
+    get aggregateId(): string;
+    /**
+     * Timestamp when this event occurred.
+     *
+     * Represents the moment the domain action happened.
+     */
+    get occurredOn(): Date;
+    /**
+     * The event-specific data payload.
+     *
+     * Contains all information needed by event handlers.
+     */
+    get payload(): TPayload;
+    /**
+     * Serializes the event to a plain object for persistence or messaging.
+     *
+     * @returns A plain object representation of the event
+     *
+     * @example
+     * ```typescript
+     * const event = new OrderPlacedEvent({ orderId: '123', ... });
+     * const serialized = event.toJSON();
+     * // {
+     * //   eventId: 'uuid',
+     * //   eventName: 'OrderPlaced',
+     * //   aggregateId: '123',
+     * //   occurredOn: '2024-01-15T10:30:00.000Z',
+     * //   payload: { orderId: '123', ... }
+     * // }
+     * ```
+     */
+    toJSON(): {
+        eventId: string;
+        eventName: string;
+        aggregateId: string;
+        occurredOn: string;
+        payload: TPayload;
+    };
+}
+
+/**
+ * Base class for Aggregate Roots in Domain-Driven Design.
+ *
+ * An Aggregate Root is a special Entity that serves as the entry point to an
+ * aggregate - a cluster of domain objects that are treated as a single unit
+ * for data changes. The Aggregate Root enforces invariants across the entire
+ * aggregate and manages domain events.
+ *
+ * **Note:** Like entities, aggregate roots should be composed of Value Objects,
+ * which are self-validating. Cross-property invariants should be checked in
+ * factory methods or domain methods.
+ *
+ * Key characteristics:
+ * - **Entry point**: External objects can only reference the Aggregate Root
+ * - **Consistency boundary**: All changes within the aggregate are atomic
+ * - **Invariant enforcement**: The root ensures all business rules are satisfied
+ * - **Event management**: Collects domain events raised during operations
+ *
+ * @typeParam TId - The identity type (must extend BaseValueObject)
+ * @typeParam TProps - The properties type containing aggregate state (must be an object)
+ *
+ * @example
+ * ```typescript
+ * interface OrderProps {
+ *   customerId: CustomerId;
+ *   items: OrderItem[];
+ *   status: OrderStatus;
+ *   placedAt: DateVo;
+ * }
+ *
+ * class Order extends BaseAggregateRoot<OrderId, OrderProps> {
+ *   private constructor(id: OrderId, props: OrderProps, version?: number) {
+ *     super(id, props, version);
+ *   }
+ *
+ *   static create(customerId: CustomerId, items: OrderItem[]): Order {
+ *     const id = OrderId.create();
+ *     const order = new Order(id, {
+ *       customerId,
+ *       items,
+ *       status: OrderStatus.pending(),
+ *       placedAt: DateVo.now(),
+ *     });
+ *
+ *     // Raise domain event
+ *     order.addDomainEvent(new OrderPlacedEvent({
+ *       orderId: id.value,
+ *       customerId: customerId.value,
+ *       itemCount: items.length,
+ *     }));
+ *
+ *     return order;
+ *   }
+ *
+ *   static fromPersistence(id: OrderId, props: OrderProps, version: number): Order {
+ *     return new Order(id, props, version);
+ *   }
+ *
+ *   addItem(item: OrderItem): void {
+ *     if (!this.props.status.isPending()) {
+ *       throw new InvariantViolationError({
+ *         message: 'Cannot add items to a non-pending order',
+ *       });
+ *     }
+ *     this._props.items.push(item);
+ *     this.addDomainEvent(new OrderItemAddedEvent({
+ *       orderId: this.id.value,
+ *       productId: item.productId.value,
+ *     }));
+ *   }
+ *
+ *   confirm(): void {
+ *     this._props.status = OrderStatus.confirmed();
+ *     this.addDomainEvent(new OrderConfirmedEvent({ orderId: this.id.value }));
+ *   }
+ * }
+ *
+ * // In repository after save:
+ * async save(order: Order): Promise<void> {
+ *   await this.db.save(order.toPersistence());
+ *   const events = order.pullDomainEvents();
+ *   await this.eventPublisher.publishAll(events);
+ * }
+ * ```
+ */
+declare abstract class BaseAggregateRoot<TId extends BaseValueObject<unknown>, TProps extends object> extends BaseEntity<TId, TProps> {
+    private _domainEvents;
+    /**
+     * Creates a new Aggregate Root instance.
+     *
+     * @param id - The unique identifier for this aggregate
+     * @param props - The aggregate's properties/state (should be composed of Value Objects)
+     * @param version - Optional version number for optimistic locking (defaults to 0)
+     */
+    protected constructor(id: TId, props: TProps, version?: number);
+    /**
+     * Adds a domain event to be published after persistence.
+     *
+     * Call this method when a significant domain action occurs.
+     * Events are collected and should be published by the repository
+     * after successfully persisting the aggregate.
+     *
+     * @param event - The domain event to add
+     *
+     * @example
+     * ```typescript
+     * confirm(): void {
+     *   this._props.status = OrderStatus.confirmed();
+     *   this.addDomainEvent(new OrderConfirmedEvent({
+     *     orderId: this.id.value,
+     *     confirmedAt: new Date(),
+     *   }));
+     * }
+     * ```
+     */
+    protected addDomainEvent(event: BaseDomainEvent): void;
+    /**
+     * Returns and clears all pending domain events.
+     *
+     * This method should be called by the repository after successfully
+     * persisting the aggregate. The events are cleared to prevent
+     * duplicate publishing.
+     *
+     * @returns Array of domain events that were pending
+     *
+     * @example
+     * ```typescript
+     * // In repository
+     * async save(order: Order): Promise<void> {
+     *   await this.db.transaction(async (tx) => {
+     *     await tx.orders.upsert(order.toPersistence());
+     *   });
+     *
+     *   // Only publish after successful persistence
+     *   const events = order.pullDomainEvents();
+     *   for (const event of events) {
+     *     await this.eventBus.publish(event);
+     *   }
+     * }
+     * ```
+     */
+    pullDomainEvents(): BaseDomainEvent[];
+    /**
+     * Returns pending domain events without clearing them.
+     *
+     * Useful for inspection or testing without affecting the event queue.
+     *
+     * @returns Array of pending domain events
+     */
+    peekDomainEvents(): readonly BaseDomainEvent[];
+    /**
+     * Checks if there are any pending domain events.
+     *
+     * @returns `true` if there are events waiting to be published
+     *
+     * @example
+     * ```typescript
+     * if (order.hasDomainEvents) {
+     *   const events = order.pullDomainEvents();
+     *   await eventBus.publishAll(events);
+     * }
+     * ```
+     */
+    get hasDomainEvents(): boolean;
+    /**
+     * Clears all pending domain events without returning them.
+     *
+     * Use with caution - this discards events that haven't been published.
+     * Useful in testing or when intentionally discarding events.
+     */
+    protected clearDomainEvents(): void;
+}
+
+/**
+ * Base error class for domain layer failures.
+ *
+ * Domain errors represent violations of business rules, invariants,
+ * or aggregate consistency. They originate from the core domain logic
+ * and should be caught and handled by the application layer.
+ *
+ * **When to throw:**
+ * - Business rule violations (e.g., "Cannot withdraw more than balance")
+ * - Invariant violations (e.g., "Email format invalid")
+ * - Aggregate consistency failures
+ *
+ * **Child classes:**
+ * - {@link InvariantViolationError} - Value object or entity invariant failures
+ * - {@link PartialLoadError} - Incomplete aggregate reconstitution
+ *
+ * @example
+ * ```typescript
+ * if (account.balance < amount) {
+ *   throw new DomainError({
+ *     message: 'Insufficient funds for withdrawal',
+ *     code: 'INSUFFICIENT_FUNDS',
+ *   });
+ * }
+ * ```
+ */
+declare class DomainError extends CodedError {
+    /**
+     * Creates a new DomainError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Human-readable error description
+     * @param options.code - Machine-readable error code (default: 'DOMAIN_ERROR')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: DomainErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a DomainError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new DomainError instance with the cause attached
+     */
+    static fromError(cause: unknown): DomainError;
+}
+
+/**
+ * Error thrown when a domain invariant is violated.
+ *
+ * Invariants are business rules that must always be true. This error
+ * indicates a programming error or corrupted state—if inputs are
+ * properly validated, this should never occur in production.
+ *
+ * **When to throw:**
+ * - Business rule violations (e.g., `updatedAt < createdAt`)
+ * - Assert-style guards in domain logic
+ * - Invalid state transitions
+ *
+ * @example
+ * ```typescript
+ * if (order.status === 'shipped' && order.items.length === 0) {
+ *   throw new InvariantViolationError({
+ *     message: 'Shipped order must have at least one item',
+ *     code: 'EMPTY_SHIPPED_ORDER',
+ *   });
+ * }
+ * ```
+ *
+ * @extends DomainError
+ */
+declare class InvariantViolationError extends DomainError {
+    /**
+     * Creates a new InvariantViolationError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of the violated invariant
+     * @param options.code - Machine-readable error code (default: 'INVARIANT_VIOLATION')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: DomainErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates an InvariantViolationError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new InvariantViolationError instance with the cause attached
+     */
+    static fromError(cause: unknown): InvariantViolationError;
+}
+
+/**
+ * Error thrown when an entity or aggregate is partially loaded.
+ *
+ * Indicates that required data is missing, typically due to incomplete
+ * database queries or lazy loading issues. This error should not escape
+ * the application boundary—it represents an internal system failure.
+ *
+ * **When to throw:**
+ * - Required relation not loaded
+ * - Aggregate missing expected child entities
+ * - Incomplete projection from data layer
+ *
+ * @example
+ * ```typescript
+ * if (!order.customer) {
+ *   throw new PartialLoadError({
+ *     message: 'Order customer relation not loaded',
+ *     code: 'ORDER_CUSTOMER_NOT_LOADED',
+ *   });
+ * }
+ * ```
+ *
+ * @extends DomainError
+ */
+declare class PartialLoadError extends DomainError {
+    /**
+     * Creates a new PartialLoadError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of what was not loaded
+     * @param options.code - Machine-readable error code (default: 'PARTIAL_LOAD')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: DomainErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a PartialLoadError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new PartialLoadError instance with the cause attached
+     */
+    static fromError(cause: unknown): PartialLoadError;
+}
+
+/**
+ * The underlying value structure for Money.
+ */
+interface MoneyValue {
+    amount: number;
+    currency: string;
+}
+/**
+ * Value Object representing a monetary amount with currency.
+ *
+ * Provides arithmetic operations and comparison methods.
+ * Prevents operations between different currencies.
+ *
+ * @example
+ * ```typescript
+ * const price = Money.usd(29.99);
+ * const tax = Money.usd(2.40);
+ * const total = price.add(tax);
+ *
+ * console.log(total.amount);   // 32.39
+ * console.log(total.currency); // 'USD'
+ *
+ * if (total.isGreaterThan(Money.usd(30))) {
+ *   // Apply discount
+ * }
+ * ```
+ */
+declare class Money extends BaseValueObject<MoneyValue> {
+    /**
+     * Creates a Money instance with USD currency.
+     *
+     * @param amount - The monetary amount
+     */
+    static usd(amount: number): Money;
+    /**
+     * Creates a Money instance with EUR currency.
+     *
+     * @param amount - The monetary amount
+     */
+    static eur(amount: number): Money;
+    /**
+     * Creates a zero amount in the specified currency.
+     *
+     * @param currency - The currency code (default: 'USD')
+     */
+    static zero(currency?: string): Money;
+    /**
+     * Reconstitutes a Money from a persisted value.
+     *
+     * @param value - The money value from persistence
+     */
+    static fromPersistence(value: MoneyValue): Money;
+    /**
+     * The monetary amount.
+     */
+    get amount(): number;
+    /**
+     * The currency code.
+     */
+    get currency(): string;
+    /**
+     * Adds another Money value to this one.
+     *
+     * @param other - The Money to add
+     * @throws {InvariantViolationError} If currencies don't match
+     */
+    add(other: Money): Money;
+    /**
+     * Subtracts another Money value from this one.
+     *
+     * @param other - The Money to subtract
+     * @throws {InvariantViolationError} If currencies don't match
+     */
+    subtract(other: Money): Money;
+    /**
+     * Multiplies this Money by a factor.
+     *
+     * @param factor - The multiplication factor
+     */
+    multiply(factor: number): Money;
+    /**
+     * Checks if this Money is greater than another.
+     *
+     * @param other - The Money to compare with
+     * @throws {InvariantViolationError} If currencies don't match
+     */
+    isGreaterThan(other: Money): boolean;
+    /**
+     * Checks if this Money is less than another.
+     *
+     * @param other - The Money to compare with
+     * @throws {InvariantViolationError} If currencies don't match
+     */
+    isLessThan(other: Money): boolean;
+    /**
+     * Checks if this Money represents zero.
+     */
+    isZero(): boolean;
+    /**
+     * Asserts that two Money values have the same currency.
+     * @internal
+     */
+    private assertSameCurrency;
+}
+
+/**
+ * Value Object representing an Order's unique identifier.
+ *
+ * Extends BaseUuidV7Vo to use time-ordered UUIDs for better
+ * database indexing and natural ordering.
+ *
+ * @example
+ * ```typescript
+ * const orderId = OrderId.create();
+ * console.log(orderId.value); // '01902e8a-7c3b-7def-8a1b-...'
+ *
+ * orderId.equals(anotherOrderId); // true if same value
+ * ```
+ */
+declare class OrderId extends BaseUuidV7Vo {
+}
+
+/**
+ * Possible values for an order's status.
+ */
+type OrderStatusValue = 'pending' | 'confirmed' | 'shipped' | 'cancelled';
+/**
+ * Value Object representing an Order's status.
+ *
+ * Provides type-safe status values with behavior methods for checking state.
+ * Uses static factory methods to ensure only valid statuses can be created.
+ *
+ * @example
+ * ```typescript
+ * const status = OrderStatus.pending();
+ *
+ * if (status.isPending()) {
+ *   // Can modify order
+ * }
+ *
+ * if (status.isShipped()) {
+ *   // Cannot cancel
+ * }
+ * ```
+ */
+declare class OrderStatus extends BaseValueObject<OrderStatusValue> {
+    /**
+     * Creates a new OrderStatus with 'pending' value.
+     * Use when creating new orders.
+     */
+    static pending(): OrderStatus;
+    /**
+     * Creates a new OrderStatus with 'confirmed' value.
+     * Use when payment is received.
+     */
+    static confirmed(): OrderStatus;
+    /**
+     * Creates a new OrderStatus with 'shipped' value.
+     * Use when order is dispatched.
+     */
+    static shipped(): OrderStatus;
+    /**
+     * Creates a new OrderStatus with 'cancelled' value.
+     * Use when order is cancelled by customer or system.
+     */
+    static cancelled(): OrderStatus;
+    /**
+     * Reconstitutes an OrderStatus from a persisted value.
+     *
+     * @param value - The status value from persistence
+     */
+    static fromPersistence(value: OrderStatusValue): OrderStatus;
+    /**
+     * Checks if the order is in pending status.
+     */
+    isPending(): boolean;
+    /**
+     * Checks if the order is confirmed.
+     */
+    isConfirmed(): boolean;
+    /**
+     * Checks if the order has been shipped.
+     */
+    isShipped(): boolean;
+    /**
+     * Checks if the order has been cancelled.
+     */
+    isCancelled(): boolean;
+    /**
+     * Checks if the order can still be modified (pending or confirmed).
+     */
+    isModifiable(): boolean;
+}
+
+/**
+ * Value Object representing an OrderItem's unique identifier.
+ */
+declare class OrderItemId extends BaseUuidV7Vo {
+}
+
+/**
+ * Properties for an OrderItem entity.
+ */
+interface OrderItemProps {
+    productId: string;
+    productName: string;
+    quantity: number;
+    unitPrice: Money;
+}
+/**
+ * Entity representing a line item within an Order aggregate.
+ *
+ * OrderItem is not an aggregate root - it's accessed through the Order aggregate.
+ * It has its own identity but cannot exist independently of an Order.
+ *
+ * @example
+ * ```typescript
+ * const item = OrderItem.create({
+ *   productId: 'prod-123',
+ *   productName: 'Widget',
+ *   quantity: 2,
+ *   unitPrice: Money.usd(29.99),
+ * });
+ *
+ * console.log(item.totalPrice.amount); // 59.98
+ * ```
+ */
+declare class OrderItem extends BaseEntity<OrderItemId, OrderItemProps> {
+    private constructor();
+    /**
+     * Creates a new OrderItem.
+     */
+    static create(props: OrderItemProps): OrderItem;
+    /**
+     * Reconstitutes an OrderItem from persistence.
+     */
+    static fromPersistence(id: OrderItemId, props: OrderItemProps): OrderItem;
+    get productId(): string;
+    get productName(): string;
+    get quantity(): number;
+    get unitPrice(): Money;
+    /**
+     * Calculates the total price for this line item.
+     */
+    get totalPrice(): Money;
+    /**
+     * Updates the quantity of this item.
+     */
+    updateQuantity(newQuantity: number): void;
+    /**
+     * Converts to a plain object for events or persistence.
+     */
+    toPlain(): {
+        id: string;
+        productId: string;
+        productName: string;
+        quantity: number;
+        unitPrice: {
+            amount: number;
+            currency: string;
+        };
+    };
+}
+
+/**
+ * Properties for the Order aggregate.
+ */
+interface OrderProps {
+    customerId: string;
+    items: OrderItem[];
+    status: OrderStatus;
+    totalAmount: Money;
+    placedAt: Date;
+}
+/**
+ * Order Aggregate Root.
+ *
+ * Represents a customer's order with line items. The Order is the aggregate root
+ * and controls access to its OrderItems. All modifications go through the Order
+ * to ensure business invariants are maintained.
+ *
+ * **Policies used:**
+ * - Value: `defaultOrderStatus` - New orders start as 'pending'
+ * - Business: `canAddOrderItem` - Items can only be added to pending orders
+ * - Business: `canCancelOrder` - Orders can only be cancelled if not shipped
+ *
+ * **Events raised:**
+ * - `OrderPlacedEvent` - When order is created
+ * - `OrderCancelledEvent` - When order is cancelled
+ *
+ * @example
+ * ```typescript
+ * // Create a new order
+ * const order = Order.create('customer-123', [
+ *   OrderItem.create({
+ *     productId: 'prod-1',
+ *     productName: 'Widget',
+ *     quantity: 2,
+ *     unitPrice: Money.usd(29.99),
+ *   }),
+ * ]);
+ *
+ * // Add another item
+ * order.addItem(OrderItem.create({
+ *   productId: 'prod-2',
+ *   productName: 'Gadget',
+ *   quantity: 1,
+ *   unitPrice: Money.usd(49.99),
+ * }));
+ *
+ * // Cancel the order
+ * order.cancel('Customer changed their mind');
+ *
+ * // Get events for publishing
+ * const events = order.pullDomainEvents();
+ * ```
+ */
+declare class Order extends BaseAggregateRoot<OrderId, OrderProps> {
+    private constructor();
+    /**
+     * Creates a new Order.
+     *
+     * @param customerId - The customer placing the order
+     * @param items - Initial order items
+     * @returns A new Order instance with OrderPlacedEvent raised
+     */
+    static create(customerId: string, items: OrderItem[]): Order;
+    /**
+     * Reconstitutes an Order from persistence.
+     *
+     * @param id - The order ID
+     * @param props - The order properties
+     * @param version - The version for optimistic locking
+     */
+    static fromPersistence(id: OrderId, props: OrderProps, version: number): Order;
+    get customerId(): string;
+    get items(): readonly OrderItem[];
+    get status(): OrderStatus;
+    get totalAmount(): Money;
+    get placedAt(): Date;
+    /**
+     * Adds an item to the order.
+     *
+     * Uses the `canAddOrderItem` business policy to check if the operation is allowed.
+     *
+     * @param item - The item to add
+     * @throws {InvariantViolationError} If the order is not in pending status
+     */
+    addItem(item: OrderItem): void;
+    /**
+     * Confirms the order (e.g., after payment received).
+     *
+     * @throws {InvariantViolationError} If the order is not in pending status
+     */
+    confirm(): void;
+    /**
+     * Marks the order as shipped.
+     *
+     * @throws {InvariantViolationError} If the order is not confirmed
+     */
+    ship(): void;
+    /**
+     * Cancels the order.
+     *
+     * Uses the `canCancelOrder` business policy to check if the operation is allowed.
+     *
+     * @param reason - The reason for cancellation
+     * @throws {InvariantViolationError} If the order cannot be cancelled
+     */
+    cancel(reason: string): void;
+}
+
+/**
+ * Business Policy: Determines if items can be added to an order.
+ *
+ * Items can only be added to orders that are still in 'pending' status.
+ * Once an order is confirmed, shipped, or cancelled, items cannot be added.
+ *
+ * @param order - The order to check
+ * @returns `true` if items can be added to the order
+ *
+ * @example
+ * ```typescript
+ * if (!canAddOrderItem(order)) {
+ *   throw new InvariantViolationError({
+ *     message: 'Cannot add items to non-pending order',
+ *     code: 'ORDER_NOT_PENDING',
+ *   });
+ * }
+ * ```
+ */
+declare const canAddOrderItem: (order: Order) => boolean;
+
+/**
+ * Business Policy: Determines if an order can be cancelled.
+ *
+ * Orders can only be cancelled if they have not yet been shipped.
+ * Once an order is shipped or delivered, it cannot be cancelled.
+ *
+ * @param order - The order to check
+ * @returns `true` if the order can be cancelled
+ *
+ * @example
+ * ```typescript
+ * if (!canCancelOrder(order)) {
+ *   throw new InvariantViolationError({
+ *     message: 'Order cannot be cancelled',
+ *     code: 'ORDER_CANNOT_CANCEL',
+ *   });
+ * }
+ * ```
+ */
+declare const canCancelOrder: (order: Order) => boolean;
+
+/**
+ * Value Policy: Default order status for new orders.
+ *
+ * New orders start in 'pending' status, awaiting payment confirmation.
+ *
+ * @returns The default OrderStatus (pending)
+ *
+ * @example
+ * ```typescript
+ * const order = new Order(id, {
+ *   status: defaultOrderStatus(),
+ *   // ...
+ * });
+ * ```
+ */
+declare const defaultOrderStatus: () => OrderStatus;
+
+/**
+ * Payload for the OrderCancelled domain event.
+ */
+interface OrderCancelledPayload {
+    orderId: string;
+    reason: string;
+    cancelledAt: string;
+}
+/**
+ * Domain event raised when an order is cancelled.
+ *
+ * @example
+ * ```typescript
+ * order.addDomainEvent(new OrderCancelledEvent({
+ *   orderId: order.id.value,
+ *   reason: 'Customer requested cancellation',
+ *   cancelledAt: new Date().toISOString(),
+ * }));
+ * ```
+ */
+declare class OrderCancelledEvent extends BaseDomainEvent<OrderCancelledPayload> {
+    constructor(payload: OrderCancelledPayload);
+}
+
+/**
+ * Payload for the OrderPlaced domain event.
+ */
+interface OrderPlacedPayload {
+    orderId: string;
+    customerId: string;
+    itemCount: number;
+    totalAmount: number;
+    currency: string;
+    placedAt: string;
+}
+/**
+ * Domain event raised when a new order is placed.
+ *
+ * @example
+ * ```typescript
+ * order.addDomainEvent(new OrderPlacedEvent({
+ *   orderId: order.id.value,
+ *   customerId: order.customerId,
+ *   itemCount: order.items.length,
+ *   totalAmount: order.totalAmount.amount,
+ *   currency: order.totalAmount.currency,
+ *   placedAt: new Date().toISOString(),
+ * }));
+ * ```
+ */
+declare class OrderPlacedEvent extends BaseDomainEvent<OrderPlacedPayload> {
+    constructor(payload: OrderPlacedPayload);
+}
+
+/**
+ * Error thrown when attempting to modify an order that has already been shipped.
+ *
+ * @example
+ * ```typescript
+ * if (order.status.isShipped()) {
+ *   throw new OrderAlreadyShippedError(order.id.value);
+ * }
+ * ```
+ */
+declare class OrderAlreadyShippedError extends InvariantViolationError {
+    constructor(orderId: string);
+}
+
+/**
+ * Base error class for infrastructure layer failures.
+ *
+ * Infrastructure errors represent failures in external dependencies
+ * such as databases, network services, file systems, or third-party APIs.
+ * They are automatically created by {@link BaseOutboundAdapter} when
+ * repository or gateway methods fail.
+ *
+ * **When to throw:**
+ * - Database connection or query failures
+ * - Network timeouts or connection errors
+ * - External API failures
+ * - File system errors
+ *
+ * **Child classes:**
+ * - {@link DbError} - Database operation failures
+ * - {@link NetworkError} - Network connectivity issues
+ * - {@link TimeoutError} - Operation timeout
+ * - {@link ExternalServiceError} - Third-party service failures
+ *
+ * @example
+ * ```typescript
+ * // In a repository extending BaseOutboundAdapter
+ * protected override createInfraError(error: unknown, methodName: string): InfraError {
+ *   return new DbError({
+ *     message: `Database error in ${methodName}`,
+ *     cause: error,
+ *   });
+ * }
+ * ```
+ */
+declare class InfraError extends CodedError {
+    /**
+     * Creates a new InfraError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Human-readable error description
+     * @param options.code - Machine-readable error code (default: 'INFRA_ERROR')
+     * @param options.cause - Optional underlying error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: InfraErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates an InfraError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new InfraError instance with the cause attached
+     */
+    static fromError(cause: unknown): InfraError;
+}
+
+/**
+ * Abstract base class for outbound adapters (secondary/driven ports).
+ *
+ * Provides automatic error handling for all subclass methods by:
+ * - Wrapping synchronous methods with try/catch
+ * - Attaching `.catch()` handlers to Promise-returning methods
+ * - Converting all errors to {@link InfraError} with the original as `cause`
+ *
+ * This ensures infrastructure errors are properly typed and don't leak
+ * implementation details to the application layer.
+ *
+ * @example
+ * ```typescript
+ * class UserRepository extends BaseOutboundAdapter {
+ *   constructor(private db: Database) {
+ *     super();
+ *   }
+ *
+ *   async findById(id: string): Promise<User | null> {
+ *     return this.db.users.findUnique({ where: { id } });
+ *   }
+ *
+ *   protected override createInfraError(error: unknown, methodName: string): InfraError {
+ *     return new DbError({
+ *       message: `Database error in ${methodName}`,
+ *       cause: error,
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare abstract class BaseOutboundAdapter {
+    /**
+     * Initializes the adapter and wraps all subclass methods with error handling.
+     * Must be called via `super()` in subclass constructors.
+     */
+    protected constructor();
+    /**
+     * Factory method for creating infrastructure errors.
+     *
+     * Override this in subclasses to return specific error types
+     * (e.g., `DbError`, `NetworkError`, `ExternalServiceError`).
+     *
+     * @param error - The original error that was caught
+     * @param methodName - Name of the method where the error occurred (for debugging)
+     * @returns An InfraError instance wrapping the original error
+     */
+    protected createInfraError(error: unknown, methodName: string): InfraError;
+    /**
+     * Walks the prototype chain and wraps all methods with error handling.
+     * Uses prototype-level Symbol markers to prevent re-wrapping across instances.
+     * @internal
+     */
+    private wrapAllSubclassMethods;
+}
+
+/**
+ * Error thrown when a database operation fails.
+ *
+ * Wraps database-specific errors (connection failures, query errors,
+ * constraint violations) into a transport-agnostic infrastructure error.
+ *
+ * **When to throw:**
+ * - Database connection lost
+ * - Query execution failed
+ * - Transaction rollback
+ * - Constraint violation (unique, foreign key)
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await this.db.query('SELECT * FROM users');
+ * } catch (error) {
+ *   throw new DbError({
+ *     message: 'Failed to fetch users',
+ *     code: 'USER_QUERY_FAILED',
+ *     cause: error,
+ *   });
+ * }
+ * ```
+ *
+ * @extends InfraError
+ */
+declare class DbError extends InfraError {
+    /**
+     * Creates a new DbError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of the database failure
+     * @param options.code - Machine-readable error code (default: 'DB_ERROR')
+     * @param options.cause - Optional underlying database error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: InfraErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a DbError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new DbError instance with the cause attached
+     */
+    static fromError(cause: unknown): DbError;
+}
+
+/**
+ * Error thrown when a network operation fails.
+ *
+ * Indicates connectivity issues such as DNS resolution failures,
+ * connection refused, or network unreachable errors.
+ *
+ * **When to throw:**
+ * - Connection refused
+ * - DNS resolution failed
+ * - Network unreachable
+ * - Socket errors
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fetch('https://api.example.com/data');
+ * } catch (error) {
+ *   throw new NetworkError({
+ *     message: 'Failed to connect to API',
+ *     code: 'API_CONNECTION_FAILED',
+ *     cause: error,
+ *   });
+ * }
+ * ```
+ *
+ * @extends InfraError
+ */
+declare class NetworkError extends InfraError {
+    /**
+     * Creates a new NetworkError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of the network failure
+     * @param options.code - Machine-readable error code (default: 'NETWORK_ERROR')
+     * @param options.cause - Optional underlying network error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: InfraErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a NetworkError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new NetworkError instance with the cause attached
+     */
+    static fromError(cause: unknown): NetworkError;
+}
+
+/**
+ * Error thrown when an operation exceeds its time limit.
+ *
+ * Indicates that a request or operation took longer than the
+ * configured timeout threshold.
+ *
+ * **When to throw:**
+ * - Request timeout exceeded
+ * - Database query timeout
+ * - External API response timeout
+ * - Lock acquisition timeout
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ * setTimeout(() => controller.abort(), 5000);
+ *
+ * try {
+ *   await fetch(url, { signal: controller.signal });
+ * } catch (error) {
+ *   throw new TimeoutError({
+ *     message: 'Request timed out after 5 seconds',
+ *     code: 'REQUEST_TIMEOUT',
+ *     cause: error,
+ *   });
+ * }
+ * ```
+ *
+ * @extends InfraError
+ */
+declare class TimeoutError extends InfraError {
+    /**
+     * Creates a new TimeoutError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of what timed out
+     * @param options.code - Machine-readable error code (default: 'TIMEOUT_ERROR')
+     * @param options.cause - Optional underlying timeout error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: InfraErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates a TimeoutError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new TimeoutError instance with the cause attached
+     */
+    static fromError(cause: unknown): TimeoutError;
+}
+
+/**
+ * Error thrown when a third-party service call fails.
+ *
+ * Wraps errors from external APIs, payment gateways, email services,
+ * or any other third-party dependency.
+ *
+ * **When to throw:**
+ * - Third-party API returns an error
+ * - External service is unavailable
+ * - Unexpected response from external service
+ * - Rate limiting by external service
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await this.paymentGateway.charge(amount);
+ * } catch (error) {
+ *   throw new ExternalServiceError({
+ *     message: 'Payment gateway charge failed',
+ *     code: 'PAYMENT_GATEWAY_ERROR',
+ *     cause: error,
+ *   });
+ * }
+ * ```
+ *
+ * @extends InfraError
+ */
+declare class ExternalServiceError extends InfraError {
+    /**
+     * Creates a new ExternalServiceError instance.
+     *
+     * @param options - Error configuration
+     * @param options.message - Description of the external service failure
+     * @param options.code - Machine-readable error code (default: 'EXTERNAL_SERVICE_ERROR')
+     * @param options.cause - Optional underlying service error
+     */
+    constructor({ message, code, cause, }: {
+        message: string;
+        code?: InfraErrorCode | string;
+        cause?: unknown;
+    });
+    /**
+     * Creates an ExternalServiceError from a caught error.
+     *
+     * @param cause - The original caught error
+     * @returns A new ExternalServiceError instance with the cause attached
+     */
+    static fromError(cause: unknown): ExternalServiceError;
+}
+
+export { BaseAggregateRoot, BaseDomainEvent, BaseEntity, BaseInboundAdapter, BaseInboundPort, BaseOutboundAdapter, BaseUuidV7Vo, BaseValueObject, ConflictError, DbError, DomainError, ExternalServiceError, InfraError, InvariantViolationError, Money, type MoneyValue, NetworkError, NotFoundError, Order, OrderAlreadyShippedError, OrderCancelledEvent, type OrderCancelledPayload, OrderId, OrderItem, OrderItemId, type OrderItemProps, OrderPlacedEvent, type OrderPlacedPayload, type OrderProps, OrderStatus, type OrderStatusValue, PartialLoadError, TimeoutError, UnprocessableError, UseCaseError, canAddOrderItem, canCancelOrder, defaultOrderStatus };