stratal 0.0.13 → 0.0.15

package/dist/index-D69rxo8H.d.mts

@@ -0,0 +1,2616 @@
+import { t as index_d_exports } from "./index-CSuHOJc3.mjs";
+import { t as Constructor } from "./types-Cu4jkeiH.mjs";
+import { _ as II18nService, a as index_d_exports$1, o as z, t as OpenAPIHono, v as MessageKeys, y as MessageParams } from "./index-CpAN9ENH.mjs";
+import { i as LoggerService } from "./index-Cfkie8JM.mjs";
+import { DependencyContainer, DependencyContainer as DependencyContainer$1, container as container$1, delay, inject as inject$1, injectable as injectable$1, instancePerContainerCachingFactory as instancePerContainerCachingFactory$1, singleton } from "tsyringe";
+import { SSEMessage, SSEStreamingApi, SSEStreamingApi as SSEStreamingApi$1 } from "hono/streaming";
+import { CoreContext } from "@intlify/core-base";
+import { Context } from "hono";
+import { ContentfulStatusCode, RedirectStatusCode } from "hono/utils/http-status";
+import { StreamingApi, StreamingApi as StreamingApi$1 } from "hono/utils/stream";
+import InjectionToken$1, { default as InjectionToken$2 } from "tsyringe/dist/typings/providers/injection-token";
+
+//#region src/errors/error-response.d.ts
+type Environment = 'development' | 'staging' | 'production';
+interface ErrorResponse {
+  /**
+   * Numeric error code for identification and escalation
+   * See error-codes.ts for the complete registry
+   */
+  code: number;
+  /**
+   * Human-readable error message
+   * Fixed per error type, not customizable
+   */
+  message: string;
+  /**
+   * ISO timestamp when the error occurred
+   */
+  timestamp: string;
+  /**
+   * Additional structured data about the error
+   * Only included in development environment
+   */
+  metadata?: Record<string, unknown>;
+  /**
+   * Stack trace for debugging
+   * Only included in development environment
+   */
+  stack?: string;
+}
+/**
+ * Type guard to check if an object is an ErrorResponse
+ */
+declare function isErrorResponse(obj: unknown): obj is ErrorResponse;
+//#endregion
+//#region src/i18n/messages/index.d.ts
+/**
+ * All locale messages
+ * Explicitly import and export (no filesystem scanning - Cloudflare Workers compatible)
+ */
+declare const messages: {
+  readonly en: typeof index_d_exports;
+};
+/**
+ * Type for all messages
+ */
+type Messages = typeof messages;
+/**
+ * Get messages for all locales
+ */
+declare function getMessages(): Record<string, Record<string, unknown>>;
+/**
+ * Get available locales
+ */
+declare function getLocales(): string[];
+//#endregion
+//#region src/di/types.d.ts
+/**
+ * Service scope for DI registration
+ *
+ * Maps directly to tsyringe's Lifecycle enum.
+ * Scope is specified at registration time via provider configuration,
+ * not at class decoration time.
+ *
+ * @example
+ * ```typescript
+ * // In module providers:
+ * { provide: MY_TOKEN, useClass: MyService, scope: Scope.Singleton }
+ *
+ * // In Application.ts:
+ * container.register(MY_TOKEN, MyService, Scope.Request)
+ * ```
+ */
+declare enum Scope {
+  /** New instance per resolution (default) */
+  Transient = 0,
+  /** Single instance shared globally */
+  Singleton = 1,
+  /** New instance per child container (per request) */
+  Request = 3
+}
+/**
+ * Options for conditional binding with `when()` method
+ */
+interface WhenOptions {
+  /**
+   * Cache predicate result after first evaluation.
+   * When true, the predicate is evaluated once and the result is reused.
+   * When false (default), predicate is evaluated on each resolution.
+   */
+  cache?: boolean;
+}
+/**
+ * Decorator function type for extend() method
+ *
+ * @template T The service type being decorated
+ */
+type ExtensionDecorator<T> = (service: T, container: ContainerLike) => T;
+/**
+ * Minimal container interface for decorator functions
+ * Avoids circular dependency with Container class
+ */
+interface ContainerLike {
+  resolve<T>(token: InjectionToken$1<T>): T;
+}
+//#endregion
+//#region src/di/conditional-binding-builder.d.ts
+/**
+ * Container interface for predicate functions
+ * Using a minimal interface to avoid circular imports
+ */
+interface PredicateContainer {
+  resolve<T>(token: InjectionToken$1<T>): T;
+  isRegistered<T>(token: InjectionToken$1<T>): boolean;
+}
+/**
+ * Initial builder returned by container.when()
+ */
+interface ConditionalBindingBuilder {
+  /**
+   * Specify the token to conditionally bind
+   *
+   * @param token - DI token for the service
+   * @returns Builder for specifying implementations
+   */
+  use<T extends object>(token: InjectionToken$1<T>): ConditionalBindingUse<T>;
+}
+/**
+ * Builder after specifying token with use()
+ */
+interface ConditionalBindingUse<T extends object> {
+  /**
+   * Specify the implementation when predicate returns true.
+   * Registration is completed immediately.
+   *
+   * If predicate is false at resolution time:
+   * - Uses `otherwise()` implementation if provided
+   * - Falls back to existing registration if available
+   * - Throws error if no fallback exists
+   *
+   * @param implementation - Service class to use when predicate is true
+   * @returns Builder for optional fallback specification
+   */
+  give(implementation: Constructor<T>): ConditionalBindingGive<T>;
+}
+/**
+ * Builder after specifying true implementation with give()
+ * Registration is already complete at this point.
+ */
+interface ConditionalBindingGive<T extends object> {
+  /**
+   * Optionally specify a fallback implementation when predicate returns false.
+   * This re-registers with the explicit fallback instead of existing registration.
+   *
+   * @param implementation - Service class to use when predicate is false
+   */
+  otherwise(implementation: Constructor<T>): void;
+}
+/**
+ * Implementation of ConditionalBindingBuilder
+ *
+ * @internal
+ */
+declare class ConditionalBindingBuilderImpl implements ConditionalBindingBuilder {
+  private readonly tsyringeContainer;
+  private readonly predicateContainer;
+  private readonly predicate;
+  private readonly options;
+  constructor(tsyringeContainer: DependencyContainer, predicateContainer: PredicateContainer, predicate: (container: PredicateContainer) => boolean, options: WhenOptions);
+  use<T extends object>(token: InjectionToken$1<T>): ConditionalBindingUse<T>;
+}
+//#endregion
+//#region src/di/container.d.ts
+/**
+ * Options for creating a Container instance
+ */
+interface ContainerOptions {
+  /** Pre-created DependencyContainer */
+  container: DependencyContainer;
+  /** Whether this is a request-scoped container */
+  isRequestScoped?: boolean;
+}
+/**
+ * Unified Container for DI management
+ *
+ * Manages the two-tier container hierarchy:
+ * - Global scope: Singletons, base instances of request-scoped services
+ * - Request scope: Context-enriched instances per HTTP request
+ *
+ * @example Basic registration
+ * ```typescript
+ * import { container as tsyringeRootContainer } from 'tsyringe'
+ *
+ * const container = new Container({
+ *   container: tsyringeRootContainer.createChildContainer()
+ * })
+ *
+ * container.register(I18nService)
+ * container.register(MY_TOKEN, MyService)
+ * container.registerSingleton(ConfigService)
+ * container.registerValue(MY_TOKEN, myInstance)
+ * ```
+ *
+ * @example Request scope (automatic lifecycle)
+ * ```typescript
+ * await container.runInRequestScope(routerContext, async (requestContainer) => {
+ *   const i18n = requestContainer.resolve(I18N_TOKEN)
+ * })
+ * ```
+ */
+declare class Container {
+  private readonly container;
+  private readonly isRequestScoped;
+  constructor(options: ContainerOptions);
+  /**
+   * Register a service with optional explicit token and scope
+   */
+  register<T extends object>(serviceClass: Constructor<T>, scope?: Scope): void;
+  register<T extends object>(token: InjectionToken$1<T>, serviceClass: Constructor<T>, scope?: Scope): void;
+  /**
+   * Register a service as singleton
+   */
+  registerSingleton<T extends object>(serviceClass: Constructor<T>): void;
+  registerSingleton<T extends object>(token: InjectionToken$1<T>, serviceClass: Constructor<T>): void;
+  /**
+   * Register a value (instance) directly
+   */
+  registerValue<T>(token: InjectionToken$1<T>, value: T): void;
+  /**
+   * Register with factory function
+   */
+  registerFactory<T>(token: InjectionToken$1<T>, factory: (container: Container) => T): void;
+  /**
+   * Register an alias to an existing token
+   */
+  registerExisting<T>(alias: InjectionToken$1<T>, target: InjectionToken$1<T>): void;
+  /**
+   * Resolve a service from the container
+   */
+  resolve<T>(token: InjectionToken$1<T>): T;
+  /**
+   * Check if a token is registered
+   */
+  isRegistered<T>(token: InjectionToken$1<T>): boolean;
+  /**
+   * Start a conditional binding with predicate evaluation
+   */
+  when(predicate: (container: PredicateContainer) => boolean, options?: WhenOptions): ConditionalBindingBuilder;
+  /**
+   * Replace a service registration with a decorated version
+   */
+  extend<T>(token: InjectionToken$1<T>, decorator: ExtensionDecorator<T>): void;
+  /**
+   * Run callback within request scope
+   *
+   * Creates a child container with fresh instances for services registered with `scope: Scope.Request`.
+   * Callback receives the request-scoped container as argument.
+   *
+   * Can only be called on global container (not request-scoped).
+   */
+  runInRequestScope<T>(routerContext: RouterContext, callback: (requestContainer: Container) => T | Promise<T>): Promise<T>;
+  /**
+   * Create request scope container
+   *
+   * Can only be called on global container (not request-scoped).
+   */
+  createRequestScope(routerContext: RouterContext): Container;
+  /**
+   * Get underlying tsyringe container
+   */
+  getTsyringeContainer(): DependencyContainer;
+  dispose(): void | Promise<void>;
+}
+//#endregion
+//#region src/di/tokens.d.ts
+/**
+ * Token for the Container instance
+ * Used for injecting the Container into services that need dynamic resolution
+ */
+declare const CONTAINER_TOKEN: unique symbol;
+declare const DI_TOKENS: {
+  readonly CloudflareEnv: symbol;
+  readonly ExecutionContext: symbol;
+  readonly Container: typeof CONTAINER_TOKEN;
+  readonly Application: symbol;
+  readonly ModuleRegistry: symbol;
+  readonly ErrorHandler: symbol;
+  readonly Database: symbol;
+  readonly Queue: symbol;
+  readonly ConsumerRegistry: symbol;
+  readonly Cron: symbol;
+  readonly EventRegistry: symbol;
+  readonly Quarry: symbol;
+  /**
+   * AuthContext: Use for services that need user authentication (userId).
+   */
+  readonly AuthContext: symbol;
+  readonly DurableObjectState: symbol;
+  readonly DurableObjectId: symbol;
+};
+type DIToken = typeof DI_TOKENS[keyof typeof DI_TOKENS];
+//#endregion
+//#region src/di/decorators/inject-param.decorator.d.ts
+/**
+ * Metadata key for storing parameter injection information
+ */
+declare const INJECT_PARAM_METADATA_KEY: unique symbol;
+/**
+ * Describes a parameter injection
+ */
+interface ParamInjection {
+  /** Parameter index in the method signature (0-based) */
+  index: number;
+  /** DI token to resolve */
+  token: InjectionToken$1;
+}
+/**
+ * Mark a method parameter for DI injection
+ *
+ * The parameter will be resolved from the request-scoped container
+ * when the controller method is invoked.
+ *
+ * @param token - DI token to resolve (class or symbol)
+ *
+ * @example With class token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(UserService) userService: UserService
+ * ) { }
+ * ```
+ *
+ * @example With symbol token
+ * ```typescript
+ * async show(
+ *   ctx: RouterContext,
+ *   @InjectParam(DI_TOKENS.Cache) cache: ICacheService
+ * ) { }
+ * ```
+ */
+declare function InjectParam<T>(token: InjectionToken$1<T>): ParameterDecorator;
+/**
+ * Get method parameter injections
+ *
+ * @param target - Controller prototype
+ * @param propertyKey - Method name
+ * @returns Array of parameter injections sorted by index
+ */
+declare function getMethodInjections(target: object, propertyKey: string | symbol): ParamInjection[];
+//#endregion
+//#region src/di/decorators.d.ts
+/**
+ * Mark a class as injectable
+ *
+ * This decorator wraps tsyringe's `@injectable` decorator and optionally
+ * associates a token with the class. The actual lifecycle (Singleton, Request,
+ * Transient) is determined at registration time, not decoration time.
+ *
+ * **Lifecycle Control:**
+ * - Use `scope: Scope.Singleton` in module providers for singleton
+ * - Use `scope: Scope.Request` in module providers for request-scoped
+ * - Default is Transient (new instance per resolution)
+ *
+ * @param token - Optional DI token for service resolution
+ *
+ * @example Basic usage (no token)
+ * ```typescript
+ * @Transient()
+ * export class UserService {
+ *   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}
+ * }
+ *
+ * // In module:
+ * @Module({
+ *   providers: [UserService]  // Transient by default
+ * })
+ * ```
+ *
+ * @example With token
+ * ```typescript
+ * @Transient(DI_TOKENS.ConnectionManager)
+ * export class ConnectionManager implements Disposable {
+ *   // ...
+ * }
+ *
+ * // In Application.ts:
+ * container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)
+ * ```
+ *
+ * @example Singleton via provider scope
+ * ```typescript
+ * @Transient()
+ * export class ConsumerRegistry {
+ *   // ...
+ * }
+ *
+ * // In module:
+ * @Module({
+ *   providers: [
+ *     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
+ *   ]
+ * })
+ * ```
+ */
+declare function Transient<T>(token?: InjectionToken$1<T>): <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
+//#endregion
+//#region src/di/errors/conditional-binding-fallback.error.d.ts
+/**
+ * ConditionalBindingFallbackError
+ *
+ * Thrown when a conditional binding predicate returns false but no fallback
+ * implementation was provided and no existing registration exists for the token.
+ *
+ * This typically indicates a misconfiguration in the DI setup where:
+ * - A `when().use().give()` chain was used without `otherwise()`
+ * - AND the token wasn't previously registered
+ * - AND the predicate evaluated to false at resolution time
+ */
+declare class ConditionalBindingFallbackError extends ApplicationError {
+  constructor(token: string);
+}
+//#endregion
+//#region src/di/errors/request-scope-operation-not-allowed.error.d.ts
+/**
+ * RequestScopeOperationNotAllowedError
+ *
+ * Thrown when attempting to call a method that is not allowed on the current container scope.
+ * - `createRequestScope()` and `runInRequestScope()` can only be called on global containers
+ */
+declare class RequestScopeOperationNotAllowedError extends ApplicationError {
+  constructor(methodName: string);
+}
+//#endregion
+//#region src/env.d.ts
+/**
+ * Cloudflare Worker Environment Bindings
+ *
+ * This interface defines the base environment bindings required by Stratal.
+ * Use TypeScript module augmentation to add your own application-specific bindings.
+ *
+ * @example
+ * ```typescript
+ * declare module 'stratal' {
+ *   interface StratalEnv {
+ *     DATABASE: D1Database
+ *     NOTIFICATIONS_QUEUE: Queue
+ *   }
+ * }
+ * ```
+ */
+interface StratalEnv {
+  ENVIRONMENT: string;
+  CACHE: KVNamespace;
+}
+//#endregion
+//#region src/router/constants.d.ts
+/**
+ * Type-safe context keys for Hono router variables
+ * Using symbols to avoid string collisions
+ */
+declare const ROUTER_CONTEXT_KEYS: {
+  readonly REQUEST_CONTAINER: "requestContainer";
+  readonly LOCALE: "locale";
+};
+/**
+ * Metadata keys for storing route and controller configuration
+ * Using symbols to avoid collisions with other decorators
+ */
+declare const ROUTE_METADATA_KEYS: {
+  readonly CONTROLLER_ROUTE: symbol;
+  readonly CONTROLLER_OPTIONS: symbol;
+  readonly CONTROLLER_MIDDLEWARES: symbol;
+  readonly ROUTE_CONFIG: symbol;
+  readonly DECORATED_METHODS: symbol;
+  readonly HTTP_ROUTE_CONFIG: symbol;
+  readonly HTTP_DECORATED_METHODS: symbol;
+  readonly AUTH_GUARD: symbol;
+  readonly GATEWAY_MARKER: symbol;
+  readonly WS_ON_MESSAGE: symbol;
+  readonly WS_ON_CLOSE: symbol;
+  readonly WS_ON_ERROR: symbol;
+};
+/**
+ * Security scheme identifiers for OpenAPI
+ * These reference the security scheme definitions in security.schemas.ts
+ */
+declare const SECURITY_SCHEMES: {
+  readonly BEARER_AUTH: "bearerAuth";
+  readonly API_KEY: "apiKey";
+  readonly SESSION_COOKIE: "sessionCookie";
+};
+/**
+ * HTTP method mapping for RESTful controller methods
+ * Maps controller method names to HTTP verbs and path patterns
+ */
+declare const HTTP_METHODS: {
+  readonly index: {
+    readonly method: "get";
+    readonly path: "";
+  };
+  readonly show: {
+    readonly method: "get";
+    readonly path: "/:id";
+  };
+  readonly create: {
+    readonly method: "post";
+    readonly path: "";
+  };
+  readonly update: {
+    readonly method: "put";
+    readonly path: "/:id";
+  };
+  readonly patch: {
+    readonly method: "patch";
+    readonly path: "/:id";
+  };
+  readonly destroy: {
+    readonly method: "delete";
+    readonly path: "/:id";
+  };
+};
+/**
+ * Sentinel symbol to opt a controller out of versioning.
+ * When used as the version, no prefix is applied even when defaultVersion is set.
+ */
+declare const VERSION_NEUTRAL: unique symbol;
+//#endregion
+//#region src/router/types.d.ts
+/**
+ * Route parameter type for OpenAPI
+ * ZodObject or ZodPipe (piped validation)
+ */
+type ZodObjectWithEffect = index_d_exports$1.ZodObject<any> | index_d_exports$1.ZodPipe<any, any>;
+type RouteParameter = ZodObjectWithEffect | undefined;
+/**
+ * Hono context variables with type-safe keys
+ */
+interface RouterVariables {
+  [ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER]: Container;
+  [ROUTER_CONTEXT_KEYS.LOCALE]?: string;
+}
+/**
+ * Hono environment type for router
+ */
+interface RouterEnv {
+  Bindings: StratalEnv;
+  Variables: RouterVariables;
+}
+/**
+ * Security scheme identifier type
+ * Matches the keys in SECURITY_SCHEMES constant
+ */
+type SecurityScheme = typeof SECURITY_SCHEMES[keyof typeof SECURITY_SCHEMES];
+/**
+ * HTTP method type from OpenAPI spec
+ */
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options' | 'trace' | 'all';
+/**
+ * Object form for request body with optional content type
+ */
+interface RouteBodyObject {
+  schema: index_d_exports$1.ZodType;
+  contentType?: string;
+}
+/**
+ * Request body definition for @Route() decorator
+ * Bare ZodType defaults to application/json
+ */
+type RouteBody = index_d_exports$1.ZodType | RouteBodyObject;
+/**
+ * Object form for response with optional description and content type
+ */
+interface RouteResponseObject {
+  schema: index_d_exports$1.ZodType;
+  description?: string;
+  contentType?: string;
+}
+/**
+ * Single response definition for @Route() decorator
+ * Status code is auto-derived from method name (create->201, others->200)
+ */
+type RouteResponse = index_d_exports$1.ZodType | RouteResponseObject;
+/**
+ * Route configuration for @Route() decorator
+ * Defines OpenAPI metadata for a controller method
+ */
+interface RouteConfig {
+  /**
+   * Request body schema (for POST, PUT, PATCH)
+   * @example z.object({}) or { schema: z.object({}), contentType: 'multipart/form-data' }
+   */
+  body?: RouteBody;
+  /**
+   * URL parameters schema (e.g., { id: z.string().uuid() })
+   * Must be ZodObject or ZodPipe for OpenAPI compatibility
+   */
+  params?: RouteParameter;
+  /**
+   * Query parameters schema (e.g., pagination, filters)
+   * Must be ZodObject or ZodPipe for OpenAPI compatibility
+   */
+  query?: RouteParameter;
+  /**
+   * Response schema for success case
+   * Status code auto-derived: create()->201, others->200
+   * @example userSchema or { schema: userSchema, description: 'User details' }
+   */
+  response: RouteResponse;
+  /**
+   * OpenAPI tags for grouping endpoints
+   * Merged with controller-level tags
+   */
+  tags?: string[];
+  /**
+   * Security schemes required for this route
+   * Merged with controller-level security
+   * Empty array = public route (no auth)
+   */
+  security?: SecurityScheme[];
+  /**
+   * Human-readable description for OpenAPI docs
+   */
+  description?: string;
+  /**
+   * Detailed summary for OpenAPI docs
+   */
+  summary?: string;
+  /**
+   * Hide this route from OpenAPI documentation
+   * Route remains functional but won't appear in /api/docs or /api/openapi.json
+   * Useful for internal-only endpoints, debug routes, or work-in-progress features
+   */
+  hideFromDocs?: boolean;
+  /**
+   * HTTP success status code for the response
+   * Used by HTTP method decorators (@Get, @Post, etc.) to set the success status
+   * For @Route() decorator, status code is auto-derived from method name
+   */
+  statusCode?: number;
+}
+/**
+ * Metadata stored by HTTP method decorators (@Get, @Post, etc.)
+ * Contains the explicit HTTP method, path, and route configuration
+ */
+interface HttpRouteMetadata {
+  method: HttpMethod;
+  path: string;
+  config: RouteConfig;
+}
+/**
+ * Controller options for @Controller() decorator
+ * Provides default configuration for all routes in the controller
+ */
+interface ControllerOptions {
+  /**
+   * Default tags applied to all routes in this controller
+   * Routes can append additional tags
+   */
+  tags?: string[];
+  /**
+   * Default security schemes applied to all routes
+   * Routes can add more schemes or override with empty array
+   */
+  security?: SecurityScheme[];
+  /**
+   * Hide all routes in this controller from OpenAPI documentation
+   * Routes remain functional but won't appear in /api/docs or /api/openapi.json
+   * Can be overridden at route level with hideFromDocs: false
+   * Useful for internal-only controllers, debug endpoints, or utilities
+   */
+  hideFromDocs?: boolean;
+  /**
+   * API version(s) for this controller.
+   * When versioning is enabled, routes are prefixed with the version (e.g., /v1/users).
+   * Use VERSION_NEUTRAL to opt out of versioning (no prefix applied).
+   * Can be a single version string, array of versions, or VERSION_NEUTRAL symbol.
+   */
+  version?: string | string[] | typeof VERSION_NEUTRAL;
+}
+/**
+ * Versioning configuration for the application.
+ * Enables URI-based API versioning when provided to Stratal config.
+ */
+interface VersioningOptions {
+  /**
+   * Prefix for version segments in the URL.
+   * @default 'v'
+   * @example 'v' produces /v1, /v2; 'api/v' produces /api/v1, /api/v2
+   */
+  prefix?: string;
+  /**
+   * Default version applied to controllers without explicit version.
+   * Controllers with VERSION_NEUTRAL are not affected.
+   */
+  defaultVersion?: string | string[];
+}
+//#endregion
+//#region src/router/router-context.d.ts
+type ContextQueryResult<R extends Record<string, unknown> | undefined, K extends string | undefined> = K extends string ? string : R extends undefined ? Record<string, unknown> : R;
+/**
+ * Router context wrapper with helper methods
+ *
+ * Provides convenient access to Hono's context and common request/response operations.
+ * The native Hono context is available via the `c` property for advanced use cases.
+ *
+ * @example
+ * ```typescript
+ * async index(ctx: RouterContext): Promise<Response> {
+ *   // Use helper methods
+ *   const users = await this.service.findAll()
+ *   return ctx.json(users)
+ * }
+ *
+ * async show(ctx: RouterContext): Promise<Response> {
+ *   // Access route params
+ *   const id = ctx.param('id')
+ *   const user = await this.service.findById(id)
+ *   return ctx.json(user)
+ * }
+ *
+ * async create(ctx: RouterContext): Promise<Response> {
+ *   // Parse request body
+ *   const body = await ctx.body<CreateUserInput>()
+ *   const user = await this.service.create(body)
+ *   return ctx.json(user, 201)
+ * }
+ * ```
+ */
+declare class RouterContext<T extends RouterEnv = RouterEnv> {
+  readonly c: Context<T>;
+  /**
+   * Native Hono context
+   * Access for advanced use cases not covered by helper methods
+   */
+  constructor(c: Context<T>);
+  /**
+   * Get request-scoped DI container
+   * Contains request-specific services and context (AuthContext)
+   *
+   * @throws Error if container not initialized
+   */
+  getContainer(): Container;
+  /**
+   * Set locale for the current request
+   * Locale is determined by X-Locale header or defaults to config
+   *
+   * @param locale - Locale code (e.g., 'en', 'fr')
+   */
+  setLocale(locale: string): void;
+  /**
+   * Get locale for the current request
+   *
+   * @returns Current locale code
+   */
+  getLocale(): string;
+  /**
+   * Return JSON response
+   *
+   * @param data - Data to serialize as JSON
+   * @param status - HTTP status code (default: 200)
+   */
+  json(data: object, status?: ContentfulStatusCode): Response;
+  /**
+   * Get route parameter value
+   *
+   * @param key - Parameter name (e.g., 'id' for /users/:id)
+   */
+  param(key: string): string;
+  /**
+   * Get query parameter value
+   *
+   * @param key - Query parameter name
+   */
+  query<R extends Record<string, unknown> | undefined = undefined, K extends string | undefined = undefined>(key?: K): ContextQueryResult<R, K>;
+  /**
+   * Get request header value
+   *
+   * @param name - Header name (case-insensitive)
+   */
+  header(name: string): string | undefined;
+  /**
+   * Get validated request body from OpenAPI route
+   * Returns pre-validated data that has passed schema validation
+   *
+   * @returns Validated JSON body
+   */
+  body<T>(): Promise<T>;
+  /**
+   * Return text response
+   *
+   * @param text - Text content
+   * @param status - HTTP status code (default: 200)
+   */
+  text(text: string, status?: ContentfulStatusCode): Response;
+  /**
+   * Return HTML response
+   *
+   * @param html - HTML content
+   * @param status - HTTP status code (default: 200)
+   */
+  html(html: string, status?: ContentfulStatusCode): Response;
+  /**
+   * Redirect to another URL
+   *
+   * @param url - Target URL
+   * @param status - HTTP status code (default: 302)
+   */
+  redirect(url: string, status?: RedirectStatusCode): Response;
+  /**
+   * Return a streaming response (binary/generic)
+   *
+   * @param callback - Async function that writes to the stream
+   * @param onError - Optional error handler called if an error occurs during streaming
+   */
+  stream(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response;
+  /**
+   * Return a streaming text response
+   *
+   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+   *
+   * @param callback - Async function that writes text to the stream
+   * @param onError - Optional error handler called if an error occurs during streaming
+   */
+  streamText(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response;
+  /**
+   * Return a Server-Sent Events (SSE) streaming response
+   *
+   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+   *
+   * @param callback - Async function that writes SSE events to the stream
+   * @param onError - Optional error handler called if an error occurs during streaming
+   */
+  streamSSE(callback: (stream: SSEStreamingApi) => Promise<void>, onError?: (err: Error, stream: SSEStreamingApi) => Promise<void>): Response;
+}
+//#endregion
+//#region src/router/controller.d.ts
+/**
+ * Controller interface for handling HTTP requests
+ *
+ * Controllers can implement RESTful methods or a custom handle() method.
+ * The route for the controller is set via the `@Controller` decorator.
+ *
+ * RESTful methods auto-map to HTTP verbs:
+ * - index() → GET /route
+ * - show() → GET /route/:id
+ * - create() → POST /route
+ * - update() → PUT /route/:id
+ * - patch() → PATCH /route/:id
+ * - destroy() → DELETE /route/:id
+ *
+ * For non-RESTful routes (wildcards, custom patterns), implement handle()
+ */
+interface IController {
+  /**
+   * GET /route
+   * List all resources
+   */
+  index?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * GET /route/:id
+   * Show a specific resource
+   */
+  show?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * POST /route
+   * Create a new resource
+   */
+  create?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * PUT /route/:id
+   * Update a resource (full replacement)
+   */
+  update?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * PATCH /route/:id
+   * Patch a resource (partial update)
+   */
+  patch?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * DELETE /route/:id
+   * Delete a resource
+   */
+  destroy?(ctx: RouterContext): Promise<Response> | Response;
+  /**
+   * Custom handler for non-RESTful routes
+   * Use this for wildcards (e.g., /api/v1/auth/*) or custom patterns
+   * Takes precedence over RESTful methods if defined
+   */
+  handle?(ctx: RouterContext): Promise<Response> | Response;
+}
+//#endregion
+//#region src/router/middleware.interface.d.ts
+/**
+ * Middleware interface for request processing
+ *
+ * Middlewares use the `@Transient()` decorator and are registered via
+ * the `configure(consumer)` method in modules implementing `MiddlewareConfigurable`.
+ *
+ * @example
+ * ```typescript
+ * @Transient()
+ * export class LoggingMiddleware implements Middleware {
+ *   async handle(ctx: RouterContext, next: () => Promise<void>): Promise<void> {
+ *     const start = Date.now()
+ *     await next()
+ *     console.log(`Request took ${Date.now() - start}ms`)
+ *   }
+ * }
+ *
+ * // Register in module:
+ * @Module({ providers: [...] })
+ * export class AppModule implements MiddlewareConfigurable {
+ *   configure(consumer: MiddlewareConsumer): void {
+ *     consumer.apply(LoggingMiddleware).forRoutes('*')
+ *   }
+ * }
+ * ```
+ */
+interface Middleware {
+  /**
+   * Handle middleware logic
+   * Call next() to continue the middleware chain
+   *
+   * @param ctx - Router context with request/response helpers
+   * @param next - Function to call the next middleware or route handler
+   */
+  handle(ctx: RouterContext, next: () => Promise<void>): Promise<void>;
+}
+//#endregion
+//#region src/middleware/types.d.ts
+/**
+ * Route information for middleware targeting
+ */
+interface RouteInfo {
+  /** Route path pattern (e.g., '/api/v1/users', '/health') */
+  path: string;
+  /** HTTP method(s) to match. If omitted, matches all methods */
+  method?: HttpMethod | HttpMethod[];
+  /** API version(s) to target. When versioning is enabled, resolves to versioned path. */
+  version?: string | string[];
+}
+/**
+ * Internal configuration entry for middleware registration
+ */
+interface MiddlewareConfigEntry {
+  /** Middleware classes to apply */
+  middlewares: Constructor<Middleware>[];
+  /** Routes to exclude from middleware */
+  excludes: RouteInfo[];
+  /** Target routes for middleware */
+  routes: MiddlewareRouteTarget[];
+}
+/**
+ * Valid targets for middleware routes
+ * - Controller class: Apply to all routes in that controller
+ * - RouteInfo: Apply to specific path/method combination
+ * - '*': Apply to all routes (global middleware)
+ */
+type MiddlewareRouteTarget = Constructor<IController> | RouteInfo | '*';
+/**
+ * Interface for modules that configure middleware
+ *
+ * Implement this interface in your module class to configure
+ * middleware using the consumer pattern.
+ *
+ * @example
+ * ```typescript
+ * @Module({ providers: [...] })
+ * export class AppModule implements MiddlewareConfigurable {
+ *   configure(consumer: MiddlewareConsumer): void {
+ *     consumer
+ *       .apply(LoggingMiddleware, CorsMiddleware)
+ *       .exclude({ path: '/health', method: 'get' })
+ *       .forRoutes('*')
+ *
+ *     consumer
+ *       .apply(CorsMiddleware)
+ *       .forRoutes(ApiController, WebhooksController)
+ *   }
+ * }
+ * ```
+ */
+interface MiddlewareConfigurable {
+  /**
+   * Configure middleware for this module
+   * @param consumer - Middleware consumer for fluent configuration
+   */
+  configure(consumer: MiddlewareConsumer): void;
+}
+/**
+ * Forward declaration for MiddlewareConsumer
+ * Implementation in middleware-consumer.ts
+ */
+interface MiddlewareConsumer {
+  /**
+   * Specify middleware(s) to apply
+   * @param middlewares - Middleware classes to apply
+   * @returns Builder for configuring routes
+   */
+  apply(...middlewares: Constructor<Middleware>[]): MiddlewareBuilder;
+  /**
+   * Get all configured middleware entries
+   */
+  getEntries(): MiddlewareConfigEntry[];
+}
+/**
+ * Forward declaration for MiddlewareBuilder
+ * Implementation in middleware-consumer.ts
+ */
+interface MiddlewareBuilder {
+  /**
+   * Exclude routes from middleware
+   * @param routes - Routes to exclude (path strings or RouteInfo objects)
+   */
+  exclude(...routes: (string | RouteInfo)[]): this;
+  /**
+   * Apply middleware to specified routes
+   * @param targets - Controller classes, route patterns, or '*' for global
+   */
+  forRoutes(...targets: MiddlewareRouteTarget[]): void;
+}
+//#endregion
+//#region src/module/types.d.ts
+/**
+ * Provider that uses a class constructor
+ *
+ * @example Transient (default)
+ * ```typescript
+ * { provide: UserService, useClass: UserService }
+ * ```
+ *
+ * @example Singleton
+ * ```typescript
+ * { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
+ * ```
+ *
+ * @example Request-scoped
+ * ```typescript
+ * { provide: DI_TOKENS.ConnectionManager, useClass: ConnectionManager, scope: Scope.Request }
+ * ```
+ */
+interface ClassProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useClass: Constructor<T>;
+  /** Lifecycle scope - defaults to Transient if not specified */
+  scope?: Scope;
+}
+/**
+ * Provider that uses a pre-created value
+ *
+ * Note: Values are inherently singleton-like (same instance always returned).
+ * No scope option needed.
+ */
+interface ValueProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useValue: T;
+}
+/**
+ * Provider that uses a factory function with auto-injection support
+ *
+ * Note: Factory providers do not support scope/lifecycle in tsyringe.
+ * Factories are always called fresh on each resolution (transient-like behavior).
+ *
+ * @example Factory with dependencies
+ * ```typescript
+ * {
+ *   provide: LOGGER_TOKENS.Transports,
+ *   useFactory: (console) => [console],
+ *   inject: [LOGGER_TOKENS.ConsoleTransport]
+ * }
+ * ```
+ */
+interface FactoryProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useFactory: (...deps: any[]) => T | Promise<T>;
+  inject?: InjectionToken$2<unknown>[];
+}
+/**
+ * Provider that creates an alias to an existing token
+ *
+ * When the `provide` token is resolved, the container resolves `useExisting` instead.
+ * Both tokens return the same instance (for singleton/request-scoped services).
+ *
+ * Use cases:
+ * - Creating interface tokens that alias concrete implementations
+ * - Multiple tokens resolving to the same service
+ *
+ * @example Basic alias
+ * ```typescript
+ * {
+ *   provide: 'IUserService',
+ *   useExisting: UserService
+ * }
+ * // Resolving 'IUserService' returns the UserService instance
+ * ```
+ *
+ * @example Interface abstraction
+ * ```typescript
+ * providers: [
+ *   UserService,
+ *   { provide: I_USER_SERVICE, useExisting: UserService }
+ * ]
+ * // Both UserService and I_USER_SERVICE resolve to the same instance
+ * ```
+ */
+interface ExistingProvider<T extends object = object> {
+  provide: InjectionToken$2<T>;
+  useExisting: InjectionToken$2<T>;
+}
+/**
+ * Union type for all provider types
+ */
+type Provider<T extends object = object> = Constructor<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+/**
+ * Module class type (decorated with @Module)
+ *
+ * Static methods for dynamic module configuration:
+ * - forRoot: Synchronous configuration (like NestJS forRoot)
+ * - forRootAsync: Async configuration with factory (like NestJS forRootAsync)
+ */
+interface ModuleClass<T extends object = object> extends Constructor<T> {
+  /**
+   * Synchronous module configuration
+   *
+   * Use for global singleton modules with static configuration
+   *
+   * @example
+   * ```typescript
+   * @Module({ providers: [] })
+   * export class ConfigModule {
+   *   static forRoot(options: ConfigOptions): DynamicModule {
+   *     return {
+   *       providers: [
+   *         { provide: CONFIG_TOKEN, useValue: options }
+   *       ]
+   *     }
+   *   }
+   * }
+   *
+   * // Usage in AppModule
+   * @Module({ imports: [ConfigModule.forRoot({ apiKey: '...' })] })
+   * ```
+   */
+  forRoot?: (...args: unknown[]) => DynamicModule;
+  /**
+   * Async module configuration with dependency injection
+   *
+   * Use when configuration depends on other services
+   *
+   * @example
+   * ```typescript
+   * @Module({ providers: [] })
+   * export class DatabaseModule {
+   *   static forRootAsync<T>(options: AsyncModuleOptions<T>): DynamicModule {
+   *     return {
+   *       providers: [
+   *         {
+   *           provide: DB_TOKEN,
+   *           useFactory: options.useFactory,
+   *           inject: options.inject
+   *         }
+   *       ]
+   *     }
+   *   }
+   * }
+   *
+   * // Usage in AppModule
+   * @Module({
+   *   imports: [
+   *     DatabaseModule.forRootAsync({
+   *       inject: [CONFIG_TOKEN],
+   *       useFactory: (config) => ({ url: config.databaseUrl })
+   *     })
+   *   ]
+   * })
+   * ```
+   */
+  forRootAsync?: <TOptions>(options: AsyncModuleOptions<TOptions>) => DynamicModule;
+}
+/**
+ * Module options for `@Module` decorator
+ *
+ * Note: Middlewares are configured via the MiddlewareConfigurable interface's
+ * configure() method, not via this options object. See middleware/types.ts.
+ */
+interface ModuleOptions {
+  imports?: (ModuleClass | DynamicModule)[];
+  providers?: Provider[];
+  controllers?: Constructor[];
+  consumers?: Constructor[];
+  jobs?: Constructor[];
+}
+/**
+ * Dynamic module returned by forRoot/forRootAsync
+ *
+ * Contains additional providers, controllers, consumers, and jobs
+ * that are added to the module when configured dynamically.
+ */
+interface DynamicModule extends Omit<ModuleOptions, 'imports'> {
+  /**
+   * Reference to the module class that created this dynamic module
+   *
+   * Required for dynamic modules to support lifecycle methods (configure, onInitialize, onShutdown).
+   * ModuleRegistry uses this to instantiate the actual module class instead of an anonymous wrapper.
+   *
+   * Note: This is NOT for provider scoping (tsyringe is always global).
+   * It's purely for preserving the class reference for lifecycle method calls.
+   */
+  module: Constructor;
+}
+/**
+ * Async configuration options for forRootAsync
+ */
+interface AsyncModuleOptions<TOptions> {
+  inject?: InjectionToken$2<unknown>[];
+  useFactory: (...deps: any[]) => TOptions | Promise<TOptions>;
+}
+/**
+ * Context passed to lifecycle hooks
+ */
+interface ModuleContext {
+  container: Container;
+  logger: LoggerService;
+}
+/**
+ * Lifecycle hook: called after all providers are registered
+ */
+interface OnInitialize {
+  onInitialize(context: ModuleContext): void | Promise<void>;
+}
+/**
+ * Lifecycle hook: called during application shutdown
+ */
+interface OnShutdown {
+  onShutdown(context: ModuleContext): void | Promise<void>;
+}
+/**
+ * Tsyringe registry entry type (for internal use)
+ *
+ * Note: useFactory receives DependencyContainer from tsyringe,
+ * but we resolve our Container via CONTAINER_TOKEN for consistency.
+ */
+interface RegistryEntry<T extends object = object> {
+  token: InjectionToken$2<T>;
+  useClass?: Constructor<T>;
+  useValue?: T;
+  useFactory?: (dependencyContainer: DependencyContainer) => T;
+  useToken?: InjectionToken$2<T>;
+}
+//#endregion
+//#region src/i18n/i18n.options.d.ts
+/**
+ * I18n Module Options
+ *
+ * Configuration options for the I18n dynamic module.
+ * Use with I18nModule.forRoot() to configure i18n for your application.
+ */
+/**
+ * Options for configuring the I18n module
+ *
+ * @example
+ * ```typescript
+ * I18nModule.forRoot({
+ *   defaultLocale: 'en',
+ *   fallbackLocale: 'en',
+ *   locales: ['en', 'fr'],
+ *   messages: {
+ *     en: { common: { hello: 'Hello' } },
+ *     fr: { common: { hello: 'Bonjour' } }
+ *   }
+ * })
+ * ```
+ */
+interface I18nModuleOptions {
+  /**
+   * Default locale for the application
+   * Used when no locale is specified in request headers
+   * @default 'en'
+   */
+  defaultLocale?: string;
+  /**
+   * Fallback locale when translation is missing
+   * @default 'en'
+   */
+  fallbackLocale?: string;
+  /**
+   * List of supported locales
+   * Request locales not in this list will fall back to defaultLocale
+   */
+  locales?: string[];
+  /**
+   * Application-specific messages to merge with system messages
+   * Keys are locale codes, values are message objects
+   */
+  messages?: Record<string, Record<string, unknown>>;
+}
+/**
+ * Resolved options with all defaults applied
+ * Used internally by I18n services
+ */
+interface ResolvedI18nOptions {
+  defaultLocale: string;
+  fallbackLocale: string;
+  locales: string[];
+  messages: Record<string, Record<string, unknown>>;
+}
+/**
+ * Resolve I18n options with defaults
+ */
+declare function resolveI18nOptions(options?: I18nModuleOptions): ResolvedI18nOptions;
+//#endregion
+//#region src/i18n/i18n.module.d.ts
+declare class I18nModule implements MiddlewareConfigurable {
+  /**
+   * Configure I18n with app-specific options
+   *
+   * Use this method in AppModule to provide custom locale configuration
+   * and app-specific messages that merge with system messages.
+   *
+   * @param options - I18n configuration options
+   * @returns Dynamic module with options provider
+   *
+   * @example
+   * ```typescript
+   * // apps/backend/src/i18n/index.ts
+   * export const i18nConfig: I18nModuleOptions = {
+   *   defaultLocale: 'en',
+   *   fallbackLocale: 'en',
+   *   locales: ['en', 'fr'],
+   *   messages: appMessages
+   * }
+   *
+   * // apps/backend/src/app.module.ts
+   * @Module({
+   *   imports: [I18nModule.forRoot(i18nConfig)],
+   * })
+   * export class AppModule {}
+   * ```
+   */
+  static forRoot(options?: I18nModuleOptions): DynamicModule;
+  /**
+   * Configure middleware for locale extraction and i18n context
+   */
+  configure(consumer: MiddlewareConsumer): void;
+}
+//#endregion
+//#region src/i18n/i18n.tokens.d.ts
+/**
+ * I18n Module DI Tokens
+ * Symbol-based tokens to avoid string collisions
+ */
+declare const I18N_TOKENS: {
+  /** MessageLoaderService - loads and caches locale messages */readonly MessageLoader: symbol; /** I18nService - request-scoped translation service */
+  readonly I18nService: symbol; /** I18nModuleOptions - configuration options from forRoot() */
+  readonly Options: symbol;
+};
+//#endregion
+//#region src/i18n/setup.d.ts
+/**
+ * I18n Setup - Message Compiler Registration
+ *
+ * Registers a JIT (Just-In-Time) message compiler for @intlify/core-base
+ * that works in Cloudflare Workers edge runtime.
+ *
+ * This must be called ONCE at application startup, before any I18nService instances are created.
+ */
+/**
+ * Setup JIT message compiler for i18n
+ *
+ * Registers a message compiler that uses JIT compilation mode.
+ * In @intlify/core-base v10+, JIT mode is enabled by default, which generates
+ * AST (Abstract Syntax Tree) instead of JavaScript code, making it compatible
+ * with CSP-restricted environments like Cloudflare Workers.
+ *
+ * **IMPORTANT:** Call this function once at application startup before creating
+ * any I18nService instances. Safe to call multiple times (only registers once).
+ *
+ * @example
+ * ```typescript
+ * // In application entry point (before app.initialize())
+ * setupI18nCompiler()
+ * ```
+ */
+declare function setupI18nCompiler(): void;
+//#endregion
+//#region src/i18n/errors/locale-not-supported.error.d.ts
+declare class LocaleNotSupportedError extends ApplicationError {
+  constructor(locale: string, supportedLocales: string[]);
+}
+//#endregion
+//#region src/i18n/errors/translation-missing.error.d.ts
+declare class TranslationMissingError extends ApplicationError {
+  constructor(key: string, locale: string);
+}
+//#endregion
+//#region src/i18n/services/message-loader.service.d.ts
+declare class MessageLoaderService {
+  private readonly options?;
+  private readonly cache;
+  private readonly contextCache;
+  private readonly locales;
+  private readonly defaultLocale;
+  constructor(options?: I18nModuleOptions | undefined);
+  /**
+   * Get CoreContext for a locale (lazily built and cached on first access)
+   * Falls back to default locale if locale not found
+   *
+   * @param locale - Locale code
+   * @returns Cached CoreContext ready for translation
+   */
+  getCoreContext(locale: string): CoreContext;
+  /**
+   * Get messages for a specific locale
+   * Falls back to default locale if locale not found
+   *
+   * @param locale - Locale code
+   * @returns Message object for the locale
+   */
+  getMessages(locale: string): Record<string, unknown>;
+  /**
+   * Get list of available locale codes
+   *
+   * @returns Array of locale codes
+   */
+  getAvailableLocales(): string[];
+  /**
+   * Check if a locale is supported
+   *
+   * @param locale - Locale code to check
+   * @returns true if locale is supported
+   */
+  isLocaleSupported(locale: string): boolean;
+  /**
+   * Get default locale
+   *
+   * @returns Default locale code
+   */
+  getDefaultLocale(): string;
+  /**
+   * Flatten nested messages to dot-notation
+   *
+   * Converts { auth: { login: { title: 'Sign In' } } }
+   * to { 'auth.login.title': 'Sign In' }
+   */
+  private flattenMessages;
+  /**
+   * Deep merge two objects
+   * App messages override core messages at leaf level
+   */
+  private deepMerge;
+}
+//#endregion
+//#region src/i18n/middleware/locale-extraction.middleware.d.ts
+declare class LocaleExtractionMiddleware implements Middleware {
+  private readonly loader;
+  constructor(loader: MessageLoaderService);
+  handle(ctx: RouterContext, next: () => Promise<void>): Promise<void>;
+  /**
+   * Extract and validate locale from X-Locale header
+   */
+  private extractLocale;
+}
+//#endregion
+//#region src/middleware/middleware-consumer.d.ts
+/**
+ * Consumer for configuring middleware in modules
+ *
+ * Provides fluent API for registering middleware with route targeting.
+ * Used by modules implementing MiddlewareConfigurable interface.
+ *
+ * @example
+ * ```typescript
+ * @Module({ providers: [...] })
+ * export class AppModule implements MiddlewareConfigurable {
+ *   configure(consumer: MiddlewareConsumer): void {
+ *     // Global logging middleware (excludes health check)
+ *     consumer
+ *       .apply(LoggingMiddleware)
+ *       .exclude('/health')
+ *       .forRoutes('*')
+ *
+ *     // CORS middleware for specific controllers
+ *     consumer
+ *       .apply(CorsMiddleware)
+ *       .forRoutes(ApiController, WebhooksController)
+ *
+ *     // Rate limiting for auth endpoints
+ *     consumer
+ *       .apply(RateLimitMiddleware)
+ *       .forRoutes({ path: '/api/v1/auth/*', method: 'post' })
+ *   }
+ * }
+ * ```
+ */
+declare class MiddlewareConsumerImpl implements MiddlewareConsumer {
+  private entries;
+  /**
+   * Start configuring middleware
+   *
+   * @param middlewares - Middleware classes to apply
+   * @returns Builder for configuring routes and exclusions
+   */
+  apply(...middlewares: Constructor<Middleware>[]): MiddlewareBuilder;
+  /**
+   * Add a configuration entry (called by builder)
+   * @internal
+   */
+  addEntry(entry: MiddlewareConfigEntry): void;
+  /**
+   * Get all configured middleware entries
+   */
+  getEntries(): MiddlewareConfigEntry[];
+}
+/**
+ * Create a new middleware consumer instance
+ */
+declare function createMiddlewareConsumer(): MiddlewareConsumer;
+//#endregion
+//#region src/middleware/middleware-configuration.service.d.ts
+/**
+ * Service for applying middleware configurations to Hono app
+ *
+ * Processes MiddlewareConfigEntry[] from modules and registers
+ * appropriate middleware handlers with route matching.
+ */
+declare class MiddlewareConfigurationService {
+  private readonly logger;
+  private readonly versioningOptions;
+  constructor(logger: LoggerService, versioningOptions?: VersioningOptions | null);
+  /**
+   * Apply middleware configurations to the Hono app
+   *
+   * @param app - Hono application instance
+   * @param configs - Middleware configuration entries from modules
+   * @param controllers - All registered controller classes (for route resolution)
+   * @param container - DI container for resolving middleware instances
+   */
+  applyMiddlewares(app: OpenAPIHono<RouterEnv>, configs: MiddlewareConfigEntry[], controllers: Constructor<IController>[], container: Container): void;
+  /**
+   * Apply a single middleware configuration entry
+   */
+  private applyMiddlewareConfig;
+  /**
+   * Resolve route targets into concrete route patterns
+   */
+  private resolveRoutePatterns;
+  /**
+   * Resolve a RouteInfo with version into versioned path(s).
+   * If versioning is disabled or no version is specified, returns the RouteInfo as-is.
+   */
+  private resolveVersionedRouteInfo;
+  /**
+   * Register middleware handlers for a specific route pattern
+   */
+  private registerMiddlewareForPattern;
+  /**
+   * Register handler for a specific HTTP method
+   */
+  private registerForMethod;
+  /**
+   * Create a middleware handler function that executes the middleware chain
+   */
+  private createMiddlewareHandler;
+  /**
+   * Check if a request matches any exclusion pattern
+   */
+  private isExcluded;
+  /**
+   * Check if request matches a route pattern
+   */
+  private matchesRoute;
+  /**
+   * Match request path against pattern
+   * Supports wildcards: /api/* matches /api/users, /api/v1/users
+   */
+  private matchesPath;
+  /**
+   * Execute middleware chain in order
+   */
+  private executeMiddlewareChain;
+}
+//#endregion
+//#region src/router/hono-app.d.ts
+/**
+ * HonoApp — extends OpenAPIHono with Stratal-specific setup
+ *
+ * Absorbs all Hono-related setup from the former RouterService and RequestScopeService:
+ * - Request scope middleware (child container per request)
+ * - Global middleware (CORS, logging, error handling)
+ * - defaultHook for validation errors
+ * - `use()` overload for Stratal middleware classes
+ * - `configure()` for module middleware, OpenAPI, routes, and 404
+ */
+declare class HonoApp extends OpenAPIHono<RouterEnv> {
+  private configured;
+  private readonly _container;
+  private readonly _logger;
+  /**
+   * Reference to the original Hono `use` implementation.
+   * Captured in constructor after super() sets it as an instance property.
+   * Used by private methods to register middleware without going through the override.
+   */
+  private nativeUse;
+  constructor(container: Container, logger: LoggerService);
+  /**
+   * Configure module middleware, OpenAPI endpoints, controller routes, and 404 handler.
+   * Called once by Application.initialize().
+   */
+  configure(middlewareConfigs: MiddlewareConfigEntry[], controllers: Constructor<IController>[], versioningOptions?: VersioningOptions | null): Promise<void>;
+  private setupRequestScope;
+  private setupGlobalMiddleware;
+  private applyMiddlewareClasses;
+}
+//#endregion
+//#region src/router/services/route-registration.service.d.ts
+/**
+ * Route registration service
+ * Manages controller and route registration with OpenAPI support
+ *
+ * Responsibilities:
+ * - Register RESTful controllers with OpenAPI metadata
+ * - Auto-derive HTTP methods/paths from controller method names
+ * - Build OpenAPI route configurations with guard execution
+ * - Validate all controllers have access decorators (strict mode)
+ * - Create controller handlers with DI resolution
+ */
+declare class RouteRegistrationService {
+  private logger;
+  private versioningOptions;
+  private controllerClasses;
+  constructor(logger: LoggerService, versioningOptions?: VersioningOptions | null);
+  /**
+   * Configure router with controllers
+   *
+   * @param app - OpenAPIHono application instance
+   * @param controllers - Array of controller classes from modules
+   */
+  configure(app: OpenAPIHono<RouterEnv>, controllers: Constructor<IController>[]): Promise<void>;
+  /**
+   * Register a WebSocket gateway
+   * Applies versioning and guards, then registers an upgradeWebSocket handler
+   */
+  private registerGateway;
+  /**
+   * Register a single WebSocket gateway route
+   */
+  private registerGatewayRoute;
+  /**
+   * Register a single controller with all its routes
+   * Validates that controller has access decorator (strict mode)
+   */
+  private registerController;
+  /**
+   * Dispatch route registration based on decorator type
+   */
+  private dispatchRoutes;
+  /**
+   * Resolve versioned paths for a controller based on versioning configuration.
+   *
+   * @param basePath - The base path from @Controller decorator
+   * @param controllerOpts - Controller options (may contain version)
+   * @returns Array of resolved paths (with version prefix if applicable)
+   */
+  private resolveVersionedPaths;
+  /**
+   * Create a guard execution middleware
+   *
+   * This middleware executes all guards for a route before the handler.
+   * Guards are executed in order; all must pass for the request to proceed.
+   *
+   * @param guards - Array of guards to execute
+   * @returns Hono middleware function
+   */
+  private createGuardMiddleware;
+  /**
+   * Register wildcard route for non-RESTful controllers
+   */
+  private registerWildcardRoute;
+  /**
+   * Register OpenAPI routes with metadata
+   */
+  private registerOpenAPIRoutes;
+  /**
+   * Register routes using HTTP method decorators (@Get, @Post, etc.)
+   * These use explicit method + path instead of convention-based derivation
+   */
+  private registerHttpRoutes;
+  /**
+   * Join a base path and a route path, normalizing slashes
+   */
+  private joinPaths;
+  /**
+   * Register route without OpenAPI metadata (for hidden routes)
+   * Route is functional but won't appear in documentation
+   */
+  private registerRouteWithoutOpenAPI;
+  /**
+   * Register traditional RESTful routes without OpenAPI
+   */
+  private registerRESTfulRoutes;
+  /**
+   * Auto-derive HTTP method and path from controller method name
+   * Uses HTTP_METHODS constant for RESTful convention mapping
+   */
+  private deriveHttpMethodAndPath;
+  /**
+   * Merge controller-level and route-level metadata
+   * Tags are merged (appended), security is merged (union)
+   * Guards automatically add sessionCookie security if present
+   */
+  private mergeMetadata;
+  /**
+   * Build OpenAPI route configuration from metadata
+   * Creates a route definition compatible with @hono/zod-openapi
+   * Includes guard execution for proper access control
+   *
+   * Execution order: Global middlewares → Guards → Handler
+   */
+  private buildOpenAPIRoute;
+  /**
+   * Check if a body definition is a RouteBodyObject (has schema key) vs bare ZodType
+   */
+  private isRouteBodyObject;
+  /**
+   * Resolve method parameter injections from the container
+   *
+   * @param prototype - Controller prototype
+   * @param methodName - Method name to get injections for
+   * @param container - Request-scoped container
+   * @returns Array of resolved dependencies in parameter order
+   */
+  private resolveMethodInjections;
+  /**
+   * Create controller handler that resolves controller from request-scoped container
+   * This ensures each request gets a fresh controller with request-scoped context
+   */
+  private createControllerHandler;
+}
+//#endregion
+//#region src/router/router.tokens.d.ts
+/**
+ * Dependency injection tokens for the router system
+ */
+declare const ROUTER_TOKENS: {
+  /**
+   * Token for RouterContext (request-scoped)
+   * Contains Hono context wrapper with helper methods
+   */
+  readonly RouterContext: symbol;
+};
+//#endregion
+//#region src/router/decorators/controller.decorator.d.ts
+/**
+ * Base controller decorator for route registration
+ *
+ * This is the core controller decorator that handles:
+ * - Transient scope registration (request-scoped)
+ * - Route metadata storage
+ * - Controller options (tags, security schemes, hideFromDocs)
+ *
+ * @param route - Base route for this controller (e.g., '/api/v1/users')
+ * @param options - Optional configuration (tags, security schemes, hideFromDocs)
+ *
+ * @example
+ * ```typescript
+ * import { Controller } from 'stratal/router'
+ *
+ * @Controller('/api/v1/users', { tags: ['Users'] })
+ * export class UsersController implements IController {
+ *   // All routes accessible
+ * }
+ * ```
+ */
+declare function Controller(route: string, options?: ControllerOptions): <T extends Constructor>(target: T) => T;
+/**
+ * Get the route from controller class metadata
+ *
+ * @param target - Controller class or instance
+ * @returns Route string or undefined if not set
+ */
+declare function getControllerRoute(target: object): string | undefined;
+/**
+ * Get the options from controller class metadata
+ *
+ * @param target - Controller class or instance
+ * @returns Controller options or undefined if not set
+ */
+declare function getControllerOptions(target: object): ControllerOptions | undefined;
+/**
+ * Get the version from controller class metadata
+ *
+ * @param target - Controller class or instance
+ * @returns Version string, array, VERSION_NEUTRAL symbol, or undefined if not set
+ */
+declare function getControllerVersion(target: object): ControllerOptions['version'];
+//#endregion
+//#region src/router/decorators/http-method.decorator.d.ts
+/**
+ * Registers a GET route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration (response schema, body, params, etc.)
+ *
+ * @example
+ * ```typescript
+ * @Controller('/api/v1/users')
+ * class UsersController {
+ *   @Get('/', { response: z.array(userSchema), summary: 'List users' })
+ *   async list(ctx: RouterContext) { ... }
+ *
+ *   @Get('/:id', { params: z.object({ id: z.string().uuid() }), response: userSchema })
+ *   async getUser(ctx: RouterContext) { ... }
+ * }
+ * ```
+ */
+declare const Get: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a POST route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration (response schema, body, params, etc.)
+ *
+ * @example
+ * ```typescript
+ * @Controller('/api/v1/users')
+ * class UsersController {
+ *   @Post('/', { body: createUserSchema, response: userSchema, statusCode: 201 })
+ *   async createUser(ctx: RouterContext) { ... }
+ * }
+ * ```
+ */
+declare const Post: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a PUT route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const Put: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a PATCH route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const Patch: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers a DELETE route on the controller method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const Delete: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Registers an ALL (any HTTP method) route on the controller method.
+ * Routes using @All are automatically hidden from OpenAPI documentation
+ * since OpenAPI does not support a catch-all HTTP method.
+ *
+ * @param path - Route path relative to the controller base path
+ * @param config - Optional route configuration
+ */
+declare const All: (path: string, config?: RouteConfig) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Get the HTTP route metadata from a controller method decorated with
+ * @Get, @Post, @Put, @Patch, @Delete, or @All.
+ *
+ * @param target - Controller prototype
+ * @param methodName - Name of the method
+ * @returns HTTP route metadata or undefined if not decorated
+ */
+declare function getHttpRouteMetadata(target: object, methodName: string): HttpRouteMetadata | undefined;
+/**
+ * Get all methods decorated with HTTP method decorators from a controller class.
+ *
+ * @param ControllerClass - Controller class
+ * @returns Array of method names that have HTTP route metadata
+ */
+declare function getHttpDecoratedMethods(ControllerClass: new (...args: unknown[]) => object): string[];
+//#endregion
+//#region src/router/decorators/route.decorator.d.ts
+/**
+ * Decorator to add OpenAPI metadata to a controller method using convention-based routing.
+ *
+ * **Cannot be mixed with HTTP method decorators** (`@Get`, `@Post`, `@Put`, `@Patch`,
+ * `@Delete`, `@All`) in the same controller. Use one pattern or the other.
+ *
+ * Stores route configuration (schemas, response, tags, security) in metadata.
+ * HTTP method, path, and success status code are auto-derived from the method name:
+ * - index() → GET /base-path → 200
+ * - show() → GET /base-path/:id → 200
+ * - create() → POST /base-path → 201
+ * - update() → PUT /base-path/:id → 200
+ * - patch() → PATCH /base-path/:id → 200
+ * - destroy() → DELETE /base-path/:id → 200
+ *
+ * @param config - Route configuration (schemas, response, tags, security)
+ *
+ * @example
+ * ```typescript
+ * @Controller('/api/v1/notes', {
+ *   tags: ['Notes'],
+ *   security: ['bearerAuth']
+ * })
+ * export class NotesController implements Controller {
+ *   @Route({
+ *     body: createNoteSchema,
+ *     response: noteSchema, // 201 auto-derived from 'create' method
+ *     tags: ['Mutations'],
+ *     description: 'Create a new note'
+ *   })
+ *   async create(ctx: RouterContext): Promise<Response> {
+ *     // POST /api/v1/notes (auto-derived from method name)
+ *     // Body schema: createNoteSchema (auto-validated)
+ *     // Response: 201 → noteSchema (status auto-derived)
+ *     // Tags: ['Notes', 'Mutations'] (merged with controller)
+ *     // Security: ['bearerAuth'] (inherited from controller)
+ *     const body = ctx.body()
+ *     const note = await this.notesService.create(body)
+ *     return ctx.json(note, 201)
+ *   }
+ *
+ *   @Route({
+ *     query: paginationSchema,
+ *     response: z.array(noteSchema) // 200 auto-derived from 'index' method
+ *   })
+ *   async index(ctx: RouterContext): Promise<Response> {
+ *     // GET /api/v1/notes (auto-derived)
+ *     // Query params auto-validated
+ *     const notes = await this.notesService.list()
+ *     return ctx.json(notes)
+ *   }
+ *
+ *   @Route({
+ *     params: z.object({ id: z.string().uuid() }),
+ *     response: {
+ *       schema: noteSchema,
+ *       description: 'Note details'
+ *     },
+ *     security: [] // Override to make public
+ *   })
+ *   async show(ctx: RouterContext): Promise<Response> {
+ *     // GET /api/v1/notes/:id (auto-derived)
+ *     // URL params auto-validated
+ *     // Response: 200 → noteSchema (status auto-derived)
+ *     // Security: [] (public route, override controller security)
+ *     const id = ctx.param('id')
+ *     const note = await this.notesService.findById(id)
+ *     return ctx.json(note)
+ *   }
+ * }
+ * ```
+ */
+declare function Route(config: Omit<RouteConfig, 'statusCode'>): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Get the route configuration from a controller method
+ *
+ * @param target - Controller instance or prototype
+ * @param methodName - Name of the method
+ * @returns Route configuration or undefined if not decorated
+ */
+declare function getRouteConfig(target: object, methodName: string): RouteConfig | undefined;
+/**
+ * Get all methods with @Route() decorator from a controller
+ *
+ * @param ControllerClass - Controller class
+ * @returns Array of method names that have route config
+ */
+declare function getDecoratedMethods(ControllerClass: new (...args: unknown[]) => object): string[];
+//#endregion
+//#region src/router/schemas/common.schemas.d.ts
+/**
+ * Common OpenAPI Schemas
+ *
+ * Reusable schema definitions for common API patterns:
+ * - Error responses
+ * - Pagination
+ * - Common parameters
+ */
+/**
+ * Generic error response schema
+ * Used for all error responses (4xx, 5xx)
+ * Matches ApplicationError.toErrorResponse() structure
+ */
+declare const errorResponseSchema: z.ZodObject<{
+  code: z.ZodNumber;
+  message: z.ZodString;
+  timestamp: z.ZodString;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Validation error response schema
+ * Used for 400 Bad Request with validation failures
+ * Matches ApplicationError.toErrorResponse() structure with validation-specific metadata
+ */
+declare const validationErrorResponseSchema: z.ZodObject<{
+  code: z.ZodNumber;
+  message: z.ZodString;
+  timestamp: z.ZodString;
+  metadata: z.ZodObject<{
+    issues: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      message: z.ZodString;
+      code: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Pagination query parameters schema
+ * Used for list endpoints
+ */
+declare const paginationQuerySchema: z.ZodObject<{
+  page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/**
+ * Paginated response wrapper schema
+ * Generic wrapper for paginated list responses
+ */
+declare const paginatedResponseSchema: <T extends z.ZodType>(itemSchema: T) => z.ZodObject<{
+  data: z.ZodArray<T>;
+  pagination: z.ZodObject<{
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+    total: z.ZodNumber;
+    totalPages: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * UUID parameter schema
+ * Used for :id parameters in RESTful routes
+ */
+declare const uuidParamSchema: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Success message response schema
+ * Used for operations that don't return data (e.g., DELETE)
+ */
+declare const successMessageSchema: z.ZodObject<{
+  message: z.ZodString;
+  data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Common HTTP status error schemas
+ * Pre-configured for standard error responses
+ */
+declare const commonErrorSchemas: {
+  readonly 400: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodObject<{
+        issues: z.ZodArray<z.ZodObject<{
+          path: z.ZodString;
+          message: z.ZodString;
+          code: z.ZodString;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Validation error";
+  };
+  readonly 401: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Unauthorized";
+  };
+  readonly 403: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Forbidden";
+  };
+  readonly 404: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Not found";
+  };
+  readonly 409: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Conflict";
+  };
+  readonly 500: {
+    readonly schema: z.ZodObject<{
+      code: z.ZodNumber;
+      message: z.ZodString;
+      timestamp: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly description: "Internal server error";
+  };
+};
+//#endregion
+//#region src/router/errors/hono-app-already-configured.error.d.ts
+/**
+ * Error thrown when HonoApp.configure() is called more than once.
+ *
+ * HonoApp can only be configured a single time during application bootstrap.
+ */
+declare class HonoAppAlreadyConfiguredError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/router/errors/controller-registration.error.d.ts
+/**
+ * Error thrown when a controller fails to register
+ *
+ * This typically happens when:
+ * - Controller is missing the `@Controller` decorator
+ * - Controller route metadata is not set
+ * - Controller class name is invalid
+ *
+ * Error Code: 9005
+ */
+declare class ControllerRegistrationError extends ApplicationError {
+  constructor(controllerName: string, reason?: string);
+}
+//#endregion
+//#region src/router/errors/openapi-route-registration.error.d.ts
+/**
+ * OpenAPIRouteRegistrationError
+ *
+ * Thrown when an OpenAPI route fails to register properly
+ * This indicates a configuration issue with route decorators or metadata
+ * Uses i18n key for localized error messages
+ *
+ * @example
+ * ```typescript
+ * throw new OpenAPIRouteRegistrationError('/api/v1/users', 'Missing response schema')
+ * ```
+ */
+declare class OpenAPIRouteRegistrationError extends ApplicationError {
+  constructor(path: string, reason: string);
+}
+//#endregion
+//#region src/router/errors/openapi-validation.error.d.ts
+/**
+ * OpenAPIValidationError
+ *
+ * Thrown when OpenAPI request/response validation fails
+ * Uses i18n key for localized error messages
+ *
+ * HTTP Status: 400 Bad Request
+ * Error Code: 1004
+ *
+ * @example
+ * ```typescript
+ * throw new OpenAPIValidationError('Request body missing required field: email')
+ * ```
+ */
+declare class OpenAPIValidationError extends ApplicationError {
+  constructor(details: string);
+}
+//#endregion
+//#region src/router/errors/route-not-found.error.d.ts
+/**
+ * Error thrown when a requested route is not found
+ *
+ * HTTP Status: 404 Not Found
+ * Error Code: 4004
+ */
+declare class RouteNotFoundError extends ApplicationError {
+  constructor(path: string, method: string);
+}
+//#endregion
+//#region src/i18n/services/i18n.service.d.ts
+/**
+ * I18n Service
+ *
+ * Provides internationalization (i18n) support for the application.
+ * Injects RouterContext to access request-specific locale.
+ *
+ * @example Usage in services
+ * ```typescript
+ * @Transient(MY_TOKENS.UserService)
+ * export class UserService {
+ *   constructor(
+ *     @inject(I18N_TOKENS.I18nService) private readonly i18n: II18nService
+ *   ) {}
+ *
+ *   getWelcomeMessage(): string {
+ *     return this.i18n.t('common.welcome')
+ *   }
+ * }
+ * ```
+ */
+declare class I18nService implements II18nService {
+  private readonly loader;
+  private readonly routerContext?;
+  constructor(loader: MessageLoaderService, routerContext?: RouterContext | undefined);
+  /**
+   * Translate a message key
+   *
+   * @param key - Message key (e.g., 'common.actions.save')
+   * @param params - Optional parameters for interpolation
+   * @returns Translated string
+   */
+  t(key: MessageKeys, params?: MessageParams): string;
+  /**
+   * Get current locale
+   *
+   * @returns Current locale code from RouterContext or default locale
+   */
+  getLocale(): string;
+}
+//#endregion
+//#region src/i18n/middleware/i18n-context.middleware.d.ts
+declare class I18nContextMiddleware implements Middleware {
+  private readonly i18n;
+  constructor(i18n: I18nService);
+  handle(ctx: RouterContext, next: () => Promise<void>): Promise<void>;
+}
+//#endregion
+//#region src/errors/error-codes.d.ts
+/**
+ * Centralized Error Code Registry
+ *
+ * Error codes are organized by category with specific ranges:
+ * - 1000-1999: Validation errors
+ * - 2000-2999: Database errors (generic)
+ * - 3000-3999: Authentication & Authorization
+ * - 4000-4999: Resource errors
+ * - 5000-5999: Domain-specific business logic (per module)
+ * - 9000-9999: System/Internal errors
+ *   - 9000-9099: Router errors
+ *   - 9100-9199: Configuration errors
+ *   - 9200-9299: Infrastructure errors
+ *   - 9300-9399: I18n errors
+ */
+declare const ERROR_CODES: {
+  /**
+   * Database Errors (2000-2999)
+   * Generic database errors thrown by Prisma client extensions
+   */
+  readonly DATABASE: {
+    /** Generic database error */readonly GENERIC: 2000; /** Record not found in database */
+    readonly RECORD_NOT_FOUND: 2001; /** Unique constraint violation */
+    readonly UNIQUE_CONSTRAINT: 2002; /** Foreign key constraint violation */
+    readonly FOREIGN_KEY_CONSTRAINT: 2003; /** Database connection failed */
+    readonly CONNECTION_FAILED: 2004; /** Database timeout */
+    readonly TIMEOUT: 2005; /** Null constraint violation */
+    readonly NULL_CONSTRAINT: 2006; /** Too many database connections */
+    readonly TOO_MANY_CONNECTIONS: 2007; /** Transaction conflict or deadlock */
+    readonly TRANSACTION_CONFLICT: 2008;
+  };
+  /**
+   * Authentication Errors (3000-3099)
+   * Authentication-related failures
+   */
+  readonly AUTH: {
+    /** Invalid credentials provided */readonly INVALID_CREDENTIALS: 3000; /** Session expired or invalid */
+    readonly SESSION_EXPIRED: 3001; /** Account locked or disabled */
+    readonly ACCOUNT_LOCKED: 3002; /** Invalid or expired token */
+    readonly INVALID_TOKEN: 3003; /** Context not initialized */
+    readonly CONTEXT_NOT_INITIALIZED: 3004; /** User not authenticated */
+    readonly USER_NOT_AUTHENTICATED: 3005; /** Email verification required before login */
+    readonly EMAIL_NOT_VERIFIED: 3007; /** Password doesn't meet minimum length */
+    readonly PASSWORD_TOO_SHORT: 3008; /** Password exceeds maximum length */
+    readonly PASSWORD_TOO_LONG: 3009; /** Account with email already exists */
+    readonly ACCOUNT_ALREADY_EXISTS: 3010; /** User creation failed */
+    readonly FAILED_TO_CREATE_USER: 3011; /** Session creation failed */
+    readonly FAILED_TO_CREATE_SESSION: 3012; /** User update failed */
+    readonly FAILED_TO_UPDATE_USER: 3013; /** Social account already linked */
+    readonly SOCIAL_ACCOUNT_LINKED: 3014; /** Last account cannot be unlinked */
+    readonly CANNOT_UNLINK_LAST_ACCOUNT: 3015;
+  };
+  /**
+   * Authorization Errors (3100-3199)
+   * Permission and access control failures
+   */
+  readonly AUTHZ: {
+    /** Insufficient permissions */readonly FORBIDDEN: 3100; /** Resource access denied */
+    readonly ACCESS_DENIED: 3101; /** User lacks required role */
+    readonly INSUFFICIENT_PERMISSIONS: 3102;
+  };
+  /**
+   * Resource Errors (4000-4999)
+   * Generic resource-related errors
+   */
+  readonly RESOURCE: {
+    /** Generic resource not found */readonly NOT_FOUND: 4000; /** Route/endpoint not found */
+    readonly ROUTE_NOT_FOUND: 4004; /** Resource conflict or duplicate */
+    readonly CONFLICT: 4100; /** Resource already exists */
+    readonly ALREADY_EXISTS: 4101;
+  };
+  /**
+   * Validation Errors (1000-1999)
+   * Input validation failures
+   */
+  readonly VALIDATION: {
+    /** Generic validation error */readonly GENERIC: 1000; /** Required field missing */
+    readonly REQUIRED_FIELD: 1001; /** Invalid format */
+    readonly INVALID_FORMAT: 1002; /** Schema validation failed */
+    readonly SCHEMA_VALIDATION: 1003; /** Request validation failed (OpenAPI, etc.) */
+    readonly REQUEST_VALIDATION: 1004;
+  };
+  /**
+   * Router Errors (9000-9099)
+   * Router and controller-related INTERNAL errors
+   */
+  readonly ROUTER: {
+    /** Controller registration error */readonly CONTROLLER_REGISTRATION_ERROR: 9005; /** Controller method not found */
+    readonly CONTROLLER_METHOD_NOT_FOUND: 9006; /** OpenAPI route registration failed */
+    readonly OPENAPI_ROUTE_REGISTRATION: 9008;
+  };
+  /**
+   * I18n Errors (9300-9399)
+   * Internationalization and localization errors
+   */
+  readonly I18N: {
+    /** Translation key missing from all locales */readonly TRANSLATION_MISSING: 9300; /** Requested locale not supported */
+    readonly LOCALE_NOT_SUPPORTED: 9301;
+  };
+  /**
+   * System Errors (9000-9999)
+   * Internal system errors and unexpected failures
+   */
+  readonly SYSTEM: {
+    /** Internal server error */readonly INTERNAL_ERROR: 9000; /** Generic configuration error */
+    readonly CONFIGURATION_ERROR: 9100; /** ConfigService not initialized */
+    readonly CONFIG_NOT_INITIALIZED: 9101; /** Module already registered */
+    readonly MODULE_ALREADY_REGISTERED: 9102; /** Circular module dependency detected */
+    readonly MODULE_CIRCULAR_DEPENDENCY: 9103; /** Module dependency not found */
+    readonly MODULE_DEPENDENCY_NOT_FOUND: 9104; /** Invalid error code range */
+    readonly INVALID_ERROR_CODE_RANGE: 9105; /** Invalid module provider configuration */
+    readonly INVALID_MODULE_PROVIDER: 9106; /** ConfigModule.forRoot() was not called */
+    readonly CONFIG_MODULE_NOT_INITIALIZED: 9107; /** Generic infrastructure error */
+    readonly INFRASTRUCTURE_ERROR: 9200; /** Execution context not initialized */
+    readonly EXECUTION_CONTEXT_NOT_INITIALIZED: 9201; /** Request container not initialized */
+    readonly REQUEST_CONTAINER_NOT_INITIALIZED: 9202; /** Queue binding not found */
+    readonly QUEUE_BINDING_NOT_FOUND: 9203; /** Cron job execution failed */
+    readonly CRON_EXECUTION_FAILED: 9204; /** Queue provider not supported */
+    readonly QUEUE_PROVIDER_NOT_SUPPORTED: 9205; /** body() called on WebSocket gateway context */
+    readonly WEBSOCKET_BODY_NOT_AVAILABLE: 9206; /** Duplicate WebSocket event decorator on a gateway */
+    readonly WEBSOCKET_DUPLICATE_EVENT_HANDLER: 9207; /** Seeder name collision — two seeders share the same class name */
+    readonly SEEDER_NAME_COLLISION: 9208; /** Seeder not registered in the SeederRegistry */
+    readonly SEEDER_NOT_REGISTERED: 9209;
+  };
+};
+/**
+ * Recursively extract all leaf values from a nested object type
+ * Similar to DeepKeys but extracts values instead of keys
+ *
+ * Example:
+ *   { DATABASE: { GENERIC: 2000, NOT_FOUND: 2001 }, AUTH: { INVALID: 3000 } }
+ *   becomes
+ *   2000 | 2001 | 3000
+ */
+type DeepValues<T> = T extends object ? { [K in keyof T]: DeepValues<T[K]> }[keyof T] : T;
+/**
+ * Type helper to extract all error code values
+ * Union type of all numeric error codes defined in ERROR_CODES
+ *
+ * Type: 2000 | 2001 | 2002 | ... | 9203
+ */
+type ErrorCode = DeepValues<typeof ERROR_CODES>;
+//#endregion
+//#region src/errors/application-error.d.ts
+/**
+ * ApplicationError
+ *
+ * Abstract base class for all application errors.
+ * This class should never be used directly - always extend it to create specific error types.
+ *
+ * Features:
+ * - Type-safe error codes from ERROR_CODES registry
+ * - Type-safe message keys from i18n module
+ * - Localized message keys (translated by GlobalErrorHandler)
+ * - Structured metadata for logging and interpolation
+ * - Proper Error prototype chain
+ * - Automatic timestamp generation
+ * - Serialization for RPC transmission
+ *
+ * Message Localization:
+ * - Each error class passes an i18n key (e.g., 'errors.userNotFound') to super()
+ * - `Error.message` contains the i18n key for useful stack traces and fallback display
+ * - Metadata provides interpolation parameters (e.g., { userId: '123' })
+ * - GlobalErrorHandler translates the message key using I18nService before sending response
+ * - This ensures errors are localized based on the user's locale (from X-Locale header)
+ */
+declare abstract class ApplicationError extends Error {
+  /**
+   * Controls whether stack traces are captured.
+   * Set to false in production to skip the expensive Error.captureStackTrace() call,
+   * since stack traces are stripped from responses in production anyway.
+   */
+  static captureStackTraces: boolean;
+  /**
+   * Type-safe error code from ERROR_CODES registry
+   * See error-codes.ts for the complete registry
+   */
+  readonly code: ErrorCode;
+  /**
+   * ISO timestamp when the error was created
+   */
+  readonly timestamp: string;
+  /**
+   * Additional structured data about the error
+   * Used for:
+   * 1. Logging and debugging
+   * 2. Message interpolation (e.g., { userId: '123', email: 'user@example.com' })
+   */
+  readonly metadata?: Record<string, unknown>;
+  /**
+   * @param i18nKey - Type-safe i18n message key (e.g., 'errors.userNotFound')
+   * @param code - Type-safe error code from ERROR_CODES registry
+   * @param metadata - Optional data for logging and interpolation
+   */
+  constructor(i18nKey: MessageKeys, code: ErrorCode, metadata?: Record<string, unknown>);
+  /**
+   * Filter metadata to include only user-facing properties
+   *
+   * User-facing properties (validation/constraint errors):
+   * - issues: Validation errors from SchemaValidationError
+   * - fields: Constraint violation fields
+   * - field: Single field constraint/foreign key
+   *
+   * Internal properties (excluded from response):
+   * - path, method: Route debugging
+   * - controllerName, reason: Controller errors
+   * - details, etc.: Internal debugging info
+   *
+   * @param metadata - Raw metadata object
+   * @returns Filtered metadata with only whitelisted properties
+   */
+  private static filterMetadata;
+  /**
+   * Serialize error to ErrorResponse format for RPC transmission
+   *
+   * @param env - Environment (development | production)
+   * @param translatedMessage - Optional translated message (from GlobalErrorHandler)
+   * @returns ErrorResponse object suitable for JSON serialization
+   */
+  toErrorResponse(env: Environment, translatedMessage?: string): ErrorResponse;
+  /**
+   * JSON serialization (used by JSON.stringify)
+   * Defaults to development mode for backward compatibility
+   * Note: This will use the untranslated message key - use GlobalErrorHandler for proper localization
+   */
+  toJSON(): ErrorResponse;
+}
+//#endregion
+//#region src/errors/get-http-status.d.ts
+/**
+ * Maps error codes to HTTP status codes
+ *
+ * This utility is used by the frontend to set appropriate HTTP status codes
+ * when returning errors from API routes.
+ *
+ * @param code - Numeric error code from ERROR_CODES registry
+ * @returns HTTP status code (200-599)
+ */
+declare function getHttpStatus(code: number): ContentfulStatusCode;
+//#endregion
+//#region src/errors/global-error-handler.d.ts
+/**
+ * GlobalErrorHandler
+ *
+ * Centralized error handler registered in the DI container.
+ * Responsible for:
+ * - Intercepting all errors in the application
+ * - Logging errors with appropriate severity via Logger service
+ * - Translating error message keys using I18nService (when available)
+ * - Serializing errors for RPC transmission
+ * - Wrapping unexpected errors in InternalError
+ *
+ * **Translation Availability by Context:**
+ *
+ * ✅ **HTTP Requests**: Errors are fully translated
+ *    - GlobalErrorHandler resolved from request container
+ *    - I18nService available via AsyncLocalStorage with user's locale
+ *    - Full translation with parameter interpolation
+ *
+ * ✅ **Queue Processing**: Errors are fully translated
+ *    - Error handling executes inside AsyncLocalStorage scope
+ *    - Locale extracted from queue message metadata
+ *    - Request container created with mock RouterContext
+ *    - I18nService available with correct locale
+ *
+ * ⚠️ **RPC/Startup**: Message keys returned as-is (i18n unavailable)
+ *    - No request context available during service binding or startup
+ *    - No locale information available
+ *    - Frontend can translate message keys using its own i18n if needed
+ *    - This is expected behavior, not a bug
+ *
+ * **Implementation Note:**
+ * The `isAvailable()` check exists to gracefully handle RPC/startup contexts
+ * where no request container exists. For HTTP and Queue contexts, i18n is
+ * always available thanks to AsyncLocalStorage scope propagation. This follows
+ * the "Laravel philosophy" - transparent dependency injection for request contexts,
+ * with explicit handling only for legitimate non-request edge cases.
+ */
+declare class GlobalErrorHandler {
+  private readonly logger;
+  private readonly i18n;
+  private readonly env;
+  private readonly environment;
+  constructor(logger: LoggerService, i18n: II18nService, env: StratalEnv);
+  /**
+   * Handle an error, log it, and serialize for response
+   *
+   * @param error - The error to handle
+   * @returns Serialized ErrorResponse for RPC transmission
+   */
+  handle(error: unknown): ErrorResponse;
+  /**
+   * Translate error message key using I18nService
+   * Uses error metadata as interpolation parameters
+   *
+   * No try/catch - if translation fails, it's a bug that should fail loudly
+   *
+   * **Note**: This method is only called when isAvailable() returns true,
+   * so the service is guaranteed to be resolved.
+   *
+   * @param error - ApplicationError with messageKey and metadata
+   * @returns Translated message string
+   */
+  private translateError;
+  /**
+   * Log an ApplicationError with appropriate severity
+   */
+  private log;
+  /**
+   * Log an unexpected error
+   */
+  private logUnexpectedError;
+  /**
+   * Determine log severity based on error code
+   */
+  private getSeverity;
+}
+//#endregion
+//#region src/errors/internal-error.d.ts
+/**
+ * InternalError
+ *
+ * Represents an unexpected internal server error.
+ * Used to wrap unknown errors that don't fit into specific error categories.
+ *
+ * This error is thrown when:
+ * - An unexpected exception occurs
+ * - An error type is not recognized
+ * - A system-level failure happens
+ */
+declare class InternalError extends ApplicationError {
+  constructor(metadata?: Record<string, unknown>);
+}
+//#endregion
+//#region src/errors/is-application-error.d.ts
+/**
+ * Type guard to check if an error is an ApplicationError
+ *
+ * @param error - The error to check
+ * @returns True if the error is an ApplicationError instance
+ */
+declare function isApplicationError(error: unknown): error is ApplicationError;
+//#endregion
+//#region src/errors/request-container-not-initialized.error.d.ts
+/**
+ * RequestContainerNotInitializedError
+ *
+ * Thrown when attempting to access the request-scoped container before it has been initialized.
+ * This typically indicates that the RouterService middleware hasn't run yet,
+ * or the router context is being accessed outside of a request lifecycle.
+ */
+declare class RequestContainerNotInitializedError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/errors/stratal-not-initialized.error.d.ts
+/**
+ * StratalNotInitializedError
+ *
+ * Thrown when attempting to resolve the Application instance before Stratal has been instantiated.
+ * This typically indicates that the Stratal instance is not exported as the default export.
+ */
+declare class StratalNotInitializedError extends ApplicationError {
+  constructor();
+}
+//#endregion
+export { I18nModuleOptions as $, Container as $t, Delete as A, RouteConfig as At, getControllerVersion as B, SECURITY_SCHEMES as Bt, successMessageSchema as C, isErrorResponse as Cn, IController as Ct, getDecoratedMethods as D, HttpRouteMetadata as Dt, Route as E, ControllerOptions as Et, getHttpDecoratedMethods as F, SecurityScheme as Ft, MiddlewareConsumerImpl as G, Transient as Gt, RouteRegistrationService as H, StratalEnv as Ht, getHttpRouteMetadata as I, VersioningOptions as It, TranslationMissingError as J, ParamInjection as Jt, createMiddlewareConsumer as K, INJECT_PARAM_METADATA_KEY as Kt, Controller as L, HTTP_METHODS as Lt, Patch as M, RouteResponseObject as Mt, Post as N, RouterEnv as Nt, getRouteConfig as O, RouteBody as Ot, Put as P, RouterVariables as Pt, I18nModule as Q, DI_TOKENS as Qt, getControllerOptions as R, ROUTER_CONTEXT_KEYS as Rt, paginationQuerySchema as S, ErrorResponse as Sn, Middleware as St, validationErrorResponseSchema as T, RouterContext as Tt, HonoApp as U, RequestScopeOperationNotAllowedError as Ut, ROUTER_TOKENS as V, VERSION_NEUTRAL as Vt, MiddlewareConfigurationService as W, ConditionalBindingFallbackError as Wt, setupI18nCompiler as X, CONTAINER_TOKEN as Xt, LocaleNotSupportedError as Y, getMethodInjections as Yt, I18N_TOKENS as Z, DIToken as Zt, ControllerRegistrationError as _, Messages as _n, MiddlewareConfigEntry as _t, GlobalErrorHandler as a, injectable$1 as an, ExistingProvider as at, errorResponseSchema as b, messages as bn, MiddlewareRouteTarget as bt, ERROR_CODES as c, ConditionalBindingBuilder as cn, ModuleClass as ct, SSEMessage as d, ConditionalBindingUse as dn, OnInitialize as dt, ContainerOptions as en, ResolvedI18nOptions as et, SSEStreamingApi$1 as f, PredicateContainer as fn, OnShutdown as ft, OpenAPIRouteRegistrationError as g, WhenOptions as gn, MiddlewareBuilder as gt, OpenAPIValidationError as h, Scope as hn, ValueProvider as ht, InternalError as i, inject$1 as in, DynamicModule as it, Get as j, RouteResponse as jt, All as k, RouteBodyObject as kt, ErrorCode as l, ConditionalBindingBuilderImpl as ln, ModuleContext as lt, RouteNotFoundError as m, ExtensionDecorator as mn, RegistryEntry as mt, RequestContainerNotInitializedError as n, container$1 as nn, AsyncModuleOptions as nt, getHttpStatus as o, instancePerContainerCachingFactory$1 as on, FactoryProvider as ot, StreamingApi$1 as p, ContainerLike as pn, Provider as pt, LocaleExtractionMiddleware as q, InjectParam as qt, isApplicationError as r, delay as rn, ClassProvider as rt, ApplicationError as s, singleton as sn, InjectionToken$2 as st, StratalNotInitializedError as t, DependencyContainer$1 as tn, resolveI18nOptions as tt, I18nContextMiddleware as u, ConditionalBindingGive as un, ModuleOptions as ut, HonoAppAlreadyConfiguredError as v, getLocales as vn, MiddlewareConfigurable as vt, uuidParamSchema as w, ContextQueryResult as wt, paginatedResponseSchema as x, Environment as xn, RouteInfo as xt, commonErrorSchemas as y, getMessages as yn, MiddlewareConsumer as yt, getControllerRoute as z, ROUTE_METADATA_KEYS as zt };
+//# sourceMappingURL=index-D69rxo8H.d.mts.map