@velajs/vela 1.19.0 → 1.19.1

package/dist/index-DhShDLCM.d.ts

@@ -0,0 +1,2310 @@
+import { a as OnApplicationBootstrap, i as BeforeApplicationShutdown } from "./schedule.registry-DVm7Jp5w.js";
+import { A as NestInterceptor, B as InferTokens, D as ExceptionFilter, E as CanActivate, F as Constructor, H as InjectableOptions, J as ProviderOptions, M as PipeTransform, N as WsArgumentsHost, O as ExecutionContext, P as Container, R as ForwardRef, S as PipeType, T as CallHandler, U as InjectionToken, X as Token, Z as Type, d as ComponentTypeMap, f as DynamicModule, i as DiscoveryService, j as NestMiddleware, l as ComponentInstance, u as ComponentType, v as ModuleImport, w as ArgumentMetadata, x as ParameterMetadata } from "./discovery.service-Cpf1QcZ5.js";
+import { A as CreateOpenApiDocumentOptions, D as ApiDocMetadata, E as VelaApplication, L as OpenApiPathItem, M as JsonSchema, N as OpenApiDocument, S as BootstrapOptions, U as ControllerOptions, V as RouteManager, X as ContributesEntrypoints, Z as Entrypoint, k as ApiResponseOptions, nt as ExceptionHandler, tt as ErrorReportContext } from "./metadata.registry-D1od8ZBt.js";
+import { CORE_CATALOG as CORE_CATALOG$1, Catalog, Catalog as Catalog$1, ErrorBodyResult, ErrorBodyResult as ErrorBodyResult$1, ErrorCatalogEntry, VelaError, VelaErrorOptions, composeCatalogs as composeCatalogs$1, defineErrorCatalog, isVelaError as isVelaError$1, toErrorBody as toErrorBody$1 } from "@velajs/errors";
+import { Context, Hono, MiddlewareHandler } from "hono";
+import { env, getRuntimeKey } from "hono/adapter";
+//#region src/factory/adapter.d.ts
+/** The framework's resolved world, handed to adapter hooks. */
+interface AdapterContext {
+  app: VelaApplication;
+  container: Container;
+  routeManager: RouteManager;
+  discovery: DiscoveryService;
+}
+/**
+ * The contract a runtime binding implements to plug a platform into a Vela
+ * app — what `@velajs/cloudflare` (bindings + Durable Object WebSocket) and
+ * the Node/Bun WebSocket transport do, made first-class:
+ *
+ * ```ts
+ * const app = await VelaFactory.create(AppModule, {
+ *   adapters: [cloudflareAdapter({ bindings })],
+ * });
+ * ```
+ *
+ * - `requestMiddleware` is prepended to the global middleware chain (runs
+ *   before consumer middleware — e.g. capture `c.env` for binding services).
+ * - `onBootstrap` runs after DI + lifecycle hooks, with `app.entrypoints`
+ *   available, BEFORE routes are built — register platform services here.
+ * - `onRoutesBuilt` runs after the Hono app exists — mount platform routes
+ *   (WebSocket upgrades, health endpoints) here via `ctx.app.getHonoApp()`.
+ */
+interface RuntimeAdapter {
+  name: string;
+  requestMiddleware?: MiddlewareHandler[];
+  onBootstrap?(ctx: AdapterContext): void | Promise<void>;
+  onRoutesBuilt?(ctx: AdapterContext): void | Promise<void>;
+}
+//#endregion
+//#region src/factory.d.ts
+interface VelaCreateOptions extends BootstrapOptions {
+  /**
+   * Runtime adapters binding this app to a platform (Cloudflare bindings,
+   * WebSocket transports, …). Their `requestMiddleware` is prepended to the
+   * global middleware chain; `onBootstrap`/`onRoutesBuilt` hooks run around
+   * route building. See {@link RuntimeAdapter}.
+   */
+  adapters?: RuntimeAdapter[];
+}
+declare const VelaFactory: {
+  create(rootModule: Type, options?: VelaCreateOptions): Promise<VelaApplication>;
+};
+//#endregion
+//#region src/openapi/document.d.ts
+declare function createOpenApiDocument(rootModule: Type, options?: CreateOpenApiDocumentOptions): OpenApiDocument;
+//#endregion
+//#region src/openapi/decorators.d.ts
+/**
+ * Attach OpenAPI documentation to a route handler (or controller).
+ *
+ * ```ts
+ * @Get('/:id')
+ * @ApiDoc({ summary: 'Get a user', description: '...', operationId: 'getUser' })
+ * findOne(@Param('id') id: string) { ... }
+ * ```
+ */
+declare function ApiDoc(metadata: ApiDocMetadata): MethodDecorator & ClassDecorator;
+/**
+ * Attach OpenAPI tags to a controller or handler. Handler-level tags merge
+ * with controller-level tags; duplicates are de-duplicated in the output.
+ */
+declare function ApiTags(...tags: string[]): MethodDecorator & ClassDecorator;
+/**
+ * Document a response for a given status code. Stackable: apply multiple
+ * times on the same handler to declare different statuses.
+ *
+ * ```ts
+ * @Get('/:id')
+ * @ApiResponse(200, { description: 'Found', schema: UserDto })
+ * @ApiResponse(404, { description: 'Not found', schema: ErrorDto })
+ * findOne() { ... }
+ * ```
+ */
+declare function ApiResponse(status: number | string, options: ApiResponseOptions): MethodDecorator;
+//#endregion
+//#region src/openapi/zod-to-json-schema.d.ts
+declare function zodToJsonSchema(schema: unknown): JsonSchema;
+//#endregion
+//#region src/container/decorators.d.ts
+declare function Injectable(options?: InjectableOptions): ClassDecorator;
+declare function Optional(): ParameterDecorator;
+declare function Inject(token: Token | ForwardRef): ParameterDecorator;
+//#endregion
+//#region src/container/mixin.d.ts
+/**
+ * Creates a reusable injectable mixin class from a base class.
+ * Applies @Injectable() so the returned class can be registered as a provider.
+ *
+ * @example
+ * ```ts
+ * function RoleGuardMixin(role: string) {
+ *   class MixedRoleGuard implements CanActivate {
+ *     canActivate(ctx: ExecutionContext) {
+ *       return ctx.getRequest().headers.get('x-role') === role;
+ *     }
+ *   }
+ *   return mixin(MixedRoleGuard);
+ * }
+ *
+ * const AdminGuard = RoleGuardMixin('admin');
+ *
+ * @UseGuards(AdminGuard)
+ * @Get('/admin')
+ * adminOnly() { ... }
+ * ```
+ */
+declare function mixin<T>(mixinClass: Type<T>): Type<T>;
+//#endregion
+//#region src/http/decorators.d.ts
+/**
+ * Marks a class as a controller.
+ * Accepts a path string or an options object with `path` and `version`.
+ *
+ * @example
+ * ```ts
+ * @Controller('/users')
+ * @Controller({ path: '/users', version: 1 })
+ * @Controller({ path: '/users', version: [1, 2] })
+ * ```
+ */
+declare function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator;
+/**
+ * Override the version for a specific route method.
+ *
+ * @example
+ * ```ts
+ * @Controller({ prefix: '/users', version: 1 })
+ * class UserController {
+ *   @Get()
+ *   listV1() { ... }          // GET /v1/users
+ *
+ *   @Version(2)
+ *   @Get()
+ *   listV2() { ... }          // GET /v2/users
+ * }
+ * ```
+ */
+declare function Version(version: number | number[]): MethodDecorator;
+/** Per-route options for the HTTP method decorators (`@Get`, `@Post`, …). */
+interface RouteOptions {
+  /**
+   * A stable, human-readable name for this route. Enables URL generation
+   * (`UrlGeneratorService.urlFor(name, …)`), surfaces on `app.describeRoutes()`,
+   * and — when set — becomes the OpenAPI `operationId`.
+   */
+  name?: string;
+}
+declare const Get: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Post: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Put: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Patch: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Delete: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Options: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Head: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const All: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Sse: (path?: string, options?: RouteOptions) => MethodDecorator;
+declare const Param: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+declare const Query: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+declare const Body: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+declare const Headers$1: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+declare const Req: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects the Hono `Context` as the response handle.
+ * In Hono, request and response state are unified in the `Context` object,
+ * so `@Res()` and `@Req()` both return it.
+ *
+ * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
+ *
+ * @example
+ * ```ts
+ * @Get('/set-cookie')
+ * handle(@Res() c: Context) {
+ *   c.setCookie('session', 'abc123', { httpOnly: true });
+ *   return { ok: true };
+ * }
+ * ```
+ */
+declare const Res: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+declare const Ip: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+declare const Cookie: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
+ *
+ * - `@Cookie()` — all cookies as an object
+ * - `@Cookie('token')` — the value of the `token` cookie
+ *
+ * @example
+ * ```ts
+ * @Get('/me')
+ * handle(@Cookie('session') session: string) { ... }
+ * ```
+ */
+declare const Cookies: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects the raw request body as a `Uint8Array`.
+ * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
+ * need the raw bytes before any JSON parsing.
+ *
+ * @example
+ * ```ts
+ * @Post('/webhook')
+ * async handle(@RawBody() body: Uint8Array) {
+ *   const sig = new TextDecoder().decode(body);
+ *   // verify HMAC...
+ * }
+ * ```
+ */
+declare function RawBody(): ParameterDecorator;
+/**
+ * Factory for creating custom parameter decorators.
+ *
+ * @example
+ * ```ts
+ * const CurrentUser = createParamDecorator(
+ *   (data: unknown, ctx: ExecutionContext) => {
+ *     const req = ctx.getRequest();
+ *     return req.headers.get('x-user-id');
+ *   }
+ * );
+ *
+ * // Usage:
+ * @Get()
+ * handle(@CurrentUser() userId: string) { ... }
+ *
+ * // With data argument:
+ * const Header = createParamDecorator(
+ *   (data: string, ctx: ExecutionContext) => {
+ *     return ctx.getRequest().headers.get(data);
+ *   }
+ * );
+ *
+ * @Get()
+ * handle(@Header('x-request-id') requestId: string) { ... }
+ * ```
+ */
+declare function createParamDecorator<TData = unknown>(factory: (data: TData, ctx: ExecutionContext) => unknown): (data?: TData, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Override the HTTP status code for a handler's response.
+ *
+ * @example
+ * ```ts
+ * @Post()
+ * @HttpCode(201)
+ * create(@Body() data: CreateDto) { return data; }
+ * ```
+ */
+declare function HttpCode(statusCode: number): MethodDecorator;
+/**
+ * Set a response header declaratively.
+ * Can be applied multiple times to set multiple headers.
+ *
+ * @example
+ * ```ts
+ * @Get()
+ * @Header('Cache-Control', 'no-cache')
+ * @Header('X-Custom', 'value')
+ * handle() { return { ok: true }; }
+ * ```
+ */
+declare function Header(name: string, value: string): MethodDecorator;
+/**
+ * Redirect to another URL. The handler's return value can override the URL.
+ *
+ * @example
+ * ```ts
+ * @Get('/old')
+ * @Redirect('/new', 301)
+ * handleOld() {}
+ *
+ * // Dynamic redirect — return { url, statusCode? } to override
+ * @Get('/go')
+ * @Redirect('/default')
+ * handleGo(@Query('to') to?: string) {
+ *   if (to) return { url: to };
+ * }
+ * ```
+ */
+declare function Redirect(url: string, statusCode?: number): MethodDecorator;
+/**
+ * Composes multiple decorators into one. Applies them in order (top to bottom),
+ * matching how stacked decorators behave when written separately.
+ *
+ * @example
+ * ```ts
+ * const Auth = (...roles: string[]) => applyDecorators(
+ *   UseGuards(JwtGuard, RolesGuard),
+ *   SetMetadata('roles', roles),
+ * );
+ *
+ * @Auth('admin')
+ * @Get('/admin')
+ * handle() { ... }
+ * ```
+ */
+type ComposedDecorator = <T>(target: T, propertyKey?: string | symbol, descriptor?: PropertyDescriptor | number) => void;
+declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): ComposedDecorator;
+//#endregion
+//#region src/http/lazy-param.decorator.d.ts
+/**
+ * Factory for parameter decorators whose value materializes lazily — the
+ * factory does not run during argument extraction; it runs the first time
+ * the handler reads a property on the resolved value.
+ *
+ * Why this exists: vela's argument resolver runs *before* guards
+ * (handler-executor order: extract args → guards → handler). A custom
+ * `createParamDecorator` factory that depends on guard-populated state
+ * (e.g. a value a guard places into `REQUEST_CONTEXT`) therefore observes
+ * an empty slot. `createLazyParamDecorator` defers factory execution to
+ * first property access on the proxied result, by which point guards have
+ * run and the slot is populated.
+ *
+ * The proxy explicitly short-circuits `prop === 'then'` so `await value`
+ * does not consider the proxy a thenable, which would otherwise trigger
+ * eager resolution. This single invariant is what makes the helper safe to
+ * pass through `async` boundaries without surprise.
+ *
+ * @example
+ * ```ts
+ * const CurrentUser = createLazyParamDecorator(
+ *   (_data: unknown, ctx: ExecutionContext) => {
+ *     const reqCtx = ctx.getContext().get('container').resolve(REQUEST_CONTEXT);
+ *     return reqCtx.get('user');     // populated by AuthGuard
+ *   },
+ * );
+ *
+ * @UseGuards(AuthGuard)
+ * @Get('/me')
+ * me(@CurrentUser() user: User) {
+ *   return { id: user.id };          // factory runs here, after AuthGuard
+ * }
+ * ```
+ */
+declare function createLazyParamDecorator<TData = unknown>(factory: (data: TData, ctx: ExecutionContext) => unknown): (data?: TData, ...pipes: PipeType[]) => ParameterDecorator;
+//#endregion
+//#region src/http/route-map.d.ts
+/**
+ * Augmentable map of route name → its path params. Users opt in to type-safe
+ * URL generation by augmenting this interface — no build step, no codegen:
+ *
+ * ```ts
+ * declare module '@velajs/vela' {
+ *   interface VelaRouteMap {
+ *     'users.index': Record<string, never>;
+ *     'users.show': { id: string };
+ *   }
+ * }
+ * ```
+ *
+ * Until augmented it stays empty, so `RouteName` falls back to `string` and
+ * `RouteParams<N>` to a loose `Record<string, string> | undefined` — untyped
+ * callers keep working unchanged.
+ */
+interface VelaRouteMap {}
+/**
+ * Every valid route name. Falls back to `string` when `VelaRouteMap` has not
+ * been augmented, so `urlFor`/`signedUrl` accept any name in an untyped app.
+ */
+type RouteName = keyof VelaRouteMap extends never ? string : Extract<keyof VelaRouteMap, string>;
+/**
+ * The params object required to build a named route's URL. When `VelaRouteMap`
+ * is augmented, resolves to the declared params shape for `N`; otherwise a
+ * loose `Record<string, string> | undefined`.
+ */
+type RouteParams<N extends RouteName> = N extends keyof VelaRouteMap ? VelaRouteMap[N] : Record<string, string> | undefined;
+//#endregion
+//#region src/http/url/url-generator.service.d.ts
+/** Value accepted for a path param or query entry. */
+type UrlParamValue = string | number | boolean;
+/** Extra options for {@link UrlGeneratorService.urlFor}. */
+interface UrlForOptions {
+  /** Additional query-string entries merged after any leftover params. */
+  query?: Record<string, UrlParamValue>;
+}
+/** Options for {@link UrlGeneratorService.signedUrl}. */
+interface SignedUrlGenerateOptions {
+  /** Time-to-live in seconds; enforced on verification via the `expires` param. */
+  expiresIn?: number;
+  /** Override the signing secret (else the `URL_SIGNING_SECRET` token / `CONFIG_ENV`). */
+  secret?: string;
+}
+/**
+ * Builds URLs for named routes (Laravel-flavoured `route()` ergonomics).
+ *
+ * Route descriptions are read LAZILY from the {@link RouteManager} on first use
+ * — post-build, so composition (global prefix + version + controller prefix) is
+ * already baked into each path — and it never instantiates controllers, so it
+ * plays nicely with lazy modules. Registered as an app-level singleton by
+ * `bootstrap`, so it is injectable anywhere.
+ */
+declare class UrlGeneratorService {
+  private readonly routeManager;
+  private readonly secretToken?;
+  private readonly env;
+  private routeMap;
+  constructor(routeManager: RouteManager, secretToken?: string | undefined, env?: Record<string, unknown>);
+  /**
+   * Build the path for a named route, filling `:param` placeholders from
+   * `params`. Params that don't match a placeholder become query-string
+   * entries; `opts.query` is merged after them.
+   *
+   * @throws if no route carries `name`, or a required `:param` is missing.
+   */
+  urlFor<N extends RouteName>(name: N, params?: RouteParams<N>, opts?: UrlForOptions): string;
+  /**
+   * Build a named-route URL and HMAC-sign it (path + query). The secret comes
+   * from `options.secret`, else the {@link URL_SIGNING_SECRET} token, else
+   * `CONFIG_ENV`; a descriptive error is thrown when none is available.
+   */
+  signedUrl<N extends RouteName>(name: N, params?: RouteParams<N>, options?: SignedUrlGenerateOptions): Promise<string>;
+  /**
+   * Lazily index named route descriptions. Rebuilt while empty (routes may not
+   * be built yet), cached once populated.
+   */
+  private routes;
+}
+//#endregion
+//#region src/http/url/signed-url.guard.d.ts
+/**
+ * Verifies the HMAC signature (and `expires`) of the incoming request URL,
+ * using the same secret source as {@link UrlGeneratorService.signedUrl}: the
+ * {@link URL_SIGNING_SECRET} token, else `CONFIG_ENV`. Throws
+ * `ForbiddenException` (403) when the signature is missing, tampered, or
+ * expired. Registered app-wide by `bootstrap`; apply it per-route with
+ * {@link SignedUrl}.
+ */
+declare class SignedUrlGuard implements CanActivate {
+  private readonly secretToken?;
+  private readonly env;
+  constructor(secretToken?: string | undefined, env?: Record<string, unknown>);
+  canActivate(context: ExecutionContext): Promise<boolean>;
+}
+/**
+ * Guards a route with {@link SignedUrlGuard} — the request must carry a valid,
+ * unexpired HMAC signature (produced by `UrlGeneratorService.signedUrl`).
+ *
+ * ```ts
+ * @Get('download', { name: 'file.download' })
+ * @SignedUrl()
+ * download() { ... }
+ * ```
+ */
+declare function SignedUrl(): ReturnType<typeof applyDecorators>;
+//#endregion
+//#region src/http/url/signing-secret.d.ts
+/**
+ * Optional DI token holding the HMAC secret used to sign / verify URLs. Provide
+ * it globally (e.g. from a platform adapter or a `@Global` module) so both
+ * {@link UrlGeneratorService} and the signed-URL guard can read it:
+ *
+ * ```ts
+ * { provide: URL_SIGNING_SECRET, useValue: env.URL_SIGNING_SECRET }
+ * ```
+ */
+declare const URL_SIGNING_SECRET: InjectionToken<string>;
+//#endregion
+//#region src/http/request-context.d.ts
+interface RequestContext {
+  readonly id: string;
+  readonly receivedAt: Date;
+  readonly request: Request;
+  readonly hono: Context;
+  set<T>(key: string | symbol, value: T): void;
+  get<T>(key: string | symbol): T | undefined;
+  has(key: string | symbol): boolean;
+}
+declare const REQUEST_CONTEXT: InjectionToken<RequestContext>;
+//#endregion
+//#region src/http/ambient.d.ts
+/**
+ * Returns Hono's `contextStorage()` middleware. Register it as the FIRST global
+ * middleware so `getCurrentContainer()` works everywhere downstream. When using
+ * `VelaFactory.create(module, { ambientContainer: true })` this is wired
+ * automatically — call this only for manual/raw Hono setups.
+ */
+declare function enableAmbientContainer(): MiddlewareHandler;
+/**
+ * The current request's DI container. Throws with actionable guidance if
+ * ambient access isn't enabled or this runs outside a request.
+ */
+declare function getCurrentContainer(): Container;
+/** The current request's {@link RequestContext} (via the ambient container). */
+declare function getCurrentRequestContext(): RequestContext;
+//#endregion
+//#region src/http/request-container.d.ts
+/**
+ * Returns the request-scoped child container for the current request.
+ *
+ * `@Inject(Container)` resolves the ROOT container (request children share the
+ * provider map and never rebind `Container`), so module authors who need
+ * request-scoped resolution from inside a handler, param-decorator factory, or
+ * scoped middleware must read the child seeded by RouteManager instead. The
+ * child is created before guards, pipes, params, and handlers run, so it is
+ * always present on the Vela request path.
+ *
+ * Throws outside a Vela-managed request rather than materializing an orphan
+ * child (mirrors the REQUEST_CONTEXT fail-fast).
+ */
+declare function getRequestContainer(c: Context): Container;
+//#endregion
+//#region src/services/logger.d.ts
+declare const LogLevel: {
+  readonly VERBOSE: 0;
+  readonly DEBUG: 1;
+  readonly LOG: 2;
+  readonly WARN: 3;
+  readonly ERROR: 4;
+  readonly SILENT: 5;
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+interface LoggerService {
+  log(message: unknown, ...optionalParams: unknown[]): void;
+  error(message: unknown, ...optionalParams: unknown[]): void;
+  warn(message: unknown, ...optionalParams: unknown[]): void;
+  debug?(message: unknown, ...optionalParams: unknown[]): void;
+  verbose?(message: unknown, ...optionalParams: unknown[]): void;
+}
+type ContextProvider = () => Record<string, unknown>;
+type LoggerLevelName = 'LOG' | 'ERROR' | 'WARN' | 'DEBUG' | 'VERBOSE';
+type Writer = (level: LoggerLevelName, line: string, ...rest: unknown[]) => void;
+declare class Logger implements LoggerService {
+  static level: LogLevel;
+  private static globalLogger;
+  private static globalContextProviders;
+  private static globalWriter;
+  private context?;
+  private instanceContextProviders;
+  private instanceWriter?;
+  static setLogLevel(level: LogLevel): void;
+  static overrideLogger(logger: LoggerService | false): void;
+  /** Register a context provider run on every log line from every logger. */
+  static addContextProvider(provider: ContextProvider): void;
+  /** Remove all registered global context providers. */
+  static clearContextProviders(): void;
+  /** Replace the default console writer. Useful on edge runtimes that have
+   *  a different output sink (e.g. `env.LOGS.writeDataPoint` on Workers). */
+  static setWriter(writer: Writer): void;
+  /** Restore the default console-based writer. */
+  static resetWriter(): void;
+  constructor(context?: string);
+  setContext(context: string): void;
+  /** Add a context provider that runs only for THIS logger instance.
+   *  Children created via extend() inherit these providers by copy. */
+  addContextProvider(provider: ContextProvider): this;
+  /** Override the writer for this logger (and any extend() children). */
+  setWriter(writer: Writer): this;
+  /** Create a child logger with a nested namespace. Context becomes
+   *  `parent:child`; instance-level providers and writers are inherited
+   *  by copy so later mutations on either logger stay isolated. */
+  extend(namespace: string): Logger;
+  log(message: unknown, ...optionalParams: unknown[]): void;
+  error(message: unknown, ...optionalParams: unknown[]): void;
+  warn(message: unknown, ...optionalParams: unknown[]): void;
+  debug(message: unknown, ...optionalParams: unknown[]): void;
+  verbose(message: unknown, ...optionalParams: unknown[]): void;
+  private emit;
+  private formatMessage;
+  private collectContext;
+  private formatContextObj;
+}
+//#endregion
+//#region src/config/register-as.d.ts
+/**
+ * The result of {@link registerAs}: a namespaced config factory plus the DI
+ * token it is provided under.
+ */
+interface ConfigNamespace<TKey extends string = string, TEnv = Record<string, unknown>, TConfig extends object = object> {
+  /** Injection token for this namespace's resolved config (`Symbol.for('vela:config:<ns>')`). */
+  readonly KEY: InjectionToken<TConfig>;
+  /** The namespace name (e.g. `'database'`). */
+  readonly namespace: TKey;
+  /** Factory receiving the ambient env and returning the namespace config. */
+  readonly factory: (env: TEnv) => TConfig;
+  /** Provider registration injecting {@link CONFIG_ENV} — spread into a module's providers. */
+  asProvider(): ProviderOptions<TConfig>;
+}
+/** Any config namespace — structural typing for the module `load` list. */
+type AnyConfigNamespace = ConfigNamespace<string, any, object>;
+/**
+ * Create a namespaced configuration factory (NestJS `registerAs` parity).
+ *
+ * The `KEY` is minted with `Symbol.for` so it keeps a stable identity across
+ * module re-evaluation (HMR / repeated imports) — a fresh `InjectionToken`
+ * would mint a new identity each eval and break dedup. It is typed as
+ * `InjectionToken<TConfig>` purely for injection-site DX.
+ *
+ * @example
+ * ```ts
+ * export const dbConfig = registerAs('database', (env: Env) => ({
+ *   url: env.DATABASE_URL,
+ *   pool: 10,
+ * }));
+ * // ConfigModule.forRoot({ load: [dbConfig] });
+ * // cfg.get('database.url');                              // via ConfigService
+ * // constructor(@Inject(dbConfig.KEY) db: InferConfigType<typeof dbConfig>) {}
+ * ```
+ */
+declare function registerAs<TKey extends string, TEnv, TConfig extends object>(namespace: TKey, factory: (env: TEnv) => TConfig): ConfigNamespace<TKey, TEnv, TConfig>;
+/**
+ * Extract a namespace's config shape from a {@link registerAs} result.
+ *
+ * @example `type Db = InferConfigType<typeof dbConfig>` → `{ url: string; pool: number }`
+ */
+type InferConfigType<T> = T extends ConfigNamespace<string, any, infer C> ? C : never;
+/**
+ * Zero-codegen typed config shape from a tuple of namespaces — pass as the
+ * `ConfigService` generic to type dot-notation reads.
+ *
+ * @example `ConfigService<ConfigType<[typeof dbConfig, typeof mailConfig]>>`
+ */
+type ConfigType<L extends readonly AnyConfigNamespace[]> = { [N in L[number] as N['namespace']]: InferConfigType<N>; };
+//#endregion
+//#region src/config/config.types.d.ts
+/**
+ * A schema for validating the fully-merged config. Kept structural so zod stays
+ * an OPTIONAL peer — a zod schema (has `.parse`) or a plain function both work;
+ * core never imports zod. Throwing rejects the config.
+ */
+type ConfigSchema = ((config: Record<string, unknown>) => unknown) | {
+  parse: (config: unknown) => unknown;
+};
+/**
+ * Options for {@link ConfigModule}.
+ *
+ * NOTE: `load` and `validateSchema` are **`forRoot`-only** — they are read
+ * structurally from the call-time options bag. On the `forRootAsync` path the
+ * options come from a DI-resolved factory, so only the flat `config` record is
+ * supported there (async namespaces are out of scope; declare them via
+ * `forRoot`).
+ */
+interface ConfigModuleOptions<T extends Record<string, unknown> = Record<string, unknown>> {
+  /** Flat config record — the pre-namespace `config` path (still supported). */
+  config?: T;
+  /** Config namespaces created via `registerAs()`, merged under their namespace name. `forRoot`-only. */
+  load?: AnyConfigNamespace[];
+  /** Eager validator for the flat `config` record; runs at `forRoot()` call time. */
+  validate?: (config: T) => T;
+  /** Schema validating the MERGED config (flat + namespaces); runs lazily on first read. `forRoot`-only. */
+  validateSchema?: ConfigSchema;
+  isGlobal?: boolean;
+}
+/**
+ * All valid dot-notation paths of a config object type.
+ * @example `ConfigPath<{ database: { url: string } }>` → `'database' | 'database.url'`
+ */
+type ConfigPath<T> = { [K in keyof T & string]: T[K] extends Record<string, unknown> ? K | `${K}.${ConfigPath<T[K]>}` : K; }[keyof T & string];
+/**
+ * The value type at a dot-notation path.
+ * @example `ConfigPathValue<{ database: { url: string } }, 'database.url'>` → `string`
+ */
+type ConfigPathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? T[K] extends Record<string, unknown> ? ConfigPathValue<T[K], Rest> : never : never : P extends keyof T ? T[P] : never;
+//#endregion
+//#region src/config/config.module.d.ts
+declare const ConfigurableModuleClass$6: ConfigurableModuleClassType<ConfigModuleOptions<Record<string, unknown>>, "forRoot", "create", {
+  isGlobal?: boolean;
+}>;
+declare class ConfigModule extends ConfigurableModuleClass$6 {
+  /**
+   * Preserve (a) per-call generic inference over the flat config record and
+   * (b) the eager-validation contract: `validate` runs at call time so bad
+   * config fails fast, then is stripped so the derived `CONFIG_OPTIONS`
+   * provider is a passthrough (no double validation). `validateSchema` (the
+   * merged-config schema) is deferred to first read — its input needs env.
+   */
+  static forRoot<T extends Record<string, unknown>>(options?: ConfigModuleOptions<T> & {
+    isGlobal?: boolean;
+    key?: string;
+  }): DynamicModule;
+}
+//#endregion
+//#region src/config/config.store.d.ts
+/**
+ * Singleton source of truth for merged configuration.
+ *
+ * Holds the flat `config` record plus a `namespace → KEY` map. Namespaces are
+ * resolved LAZILY — the KEY is pulled from the container on the first read of
+ * that namespace and cached — so the store never forces namespace factories to
+ * materialize at construction. Resolution uses the synchronous container seam
+ * (`resolve`), which stays compatible with lazy modules.
+ *
+ * The merged shape is `{ ...config, [ns]: value }` — a namespace shadows a flat
+ * key of the same name.
+ *
+ * Constructed via a factory provider in {@link ConfigModule} so it can close
+ * over the `load` list and `validateSchema` without extra tokens.
+ */
+declare class ConfigStore {
+  private readonly container;
+  private readonly config;
+  private readonly validateSchema?;
+  private readonly namespaceKeys;
+  private readonly cache;
+  private validated;
+  private validationError;
+  constructor(container: Pick<Container, 'resolve'>, config?: Record<string, unknown>, namespaces?: ReadonlyArray<AnyConfigNamespace>, validateSchema?: ConfigSchema | undefined);
+  /** Read a value by dot-notation path; `undefined` if absent. */
+  get(path: string): unknown;
+  /** Read a value by dot-notation path; throws if absent. */
+  getOrThrow(path: string): unknown;
+  /** Whether a dot-notation path resolves to a defined value. */
+  has(path: string): boolean;
+  /** The full merged config object (flat record + resolved namespaces). */
+  all(): Record<string, unknown>;
+  private read;
+  /** Resolve a namespace's KEY through the container on first use, then cache. */
+  private resolveNamespace;
+  private merged;
+  /**
+   * Validate the merged config once, on first read. Deferred (not at bootstrap)
+   * because the merged shape needs namespace factories — and their env — which
+   * are only available after bootstrap on edge runtimes.
+   */
+  private ensureValidated;
+}
+//#endregion
+//#region src/config/config.service.d.ts
+/**
+ * Typed, dot-notation reads over the merged config. Stays a singleton (NestJS
+ * parity); delegates to the {@link ConfigStore}. Pass `ConfigType<[...]>` as the
+ * generic to type namespaced paths (`cfg.get('database.url')` → `string`).
+ */
+declare class ConfigService<T extends Record<string, unknown> = Record<string, unknown>> {
+  private readonly store;
+  constructor(store: ConfigStore);
+  /** Read a config value; `undefined` when absent, or the supplied default. */
+  get<P extends ConfigPath<T>>(path: P): ConfigPathValue<T, P> | undefined;
+  get<P extends ConfigPath<T>>(path: P, defaultValue: ConfigPathValue<T, P>): ConfigPathValue<T, P>;
+  /** Read a config value; throws when the path is absent. */
+  getOrThrow<P extends ConfigPath<T>>(path: P): ConfigPathValue<T, P>;
+  /** Whether a config path resolves to a defined value. */
+  has<P extends ConfigPath<T>>(path: P): boolean;
+  /** The full merged config object (flat record + resolved namespaces). */
+  getAll(): T;
+}
+//#endregion
+//#region src/config/config.tokens.d.ts
+declare const CONFIG_OPTIONS: InjectionToken<Record<string, unknown>>;
+/**
+ * Ambient environment record consumed by config-namespace factories
+ * (`registerAs`). It is the multi-runtime substitute for stratal's
+ * Cloudflare-specific `env` token: core never touches `process.env`.
+ *
+ * The token self-provides `{}` by default (so factories resolve even with no
+ * platform binding), and stays OVERRIDABLE — a platform adapter
+ * (`@velajs/cloudflare`) or a future `./config-node` subpath provides a global
+ * `CONFIG_ENV` and that registration wins over the default.
+ */
+declare const CONFIG_ENV: InjectionToken<Record<string, unknown>>;
+//#endregion
+//#region src/fetch/fetch.types.d.ts
+interface HttpModuleOptions {
+  /** Base URL prepended to all requests. */
+  baseURL?: string;
+  /** Default headers sent with every request. */
+  headers?: Record<string, string>;
+  /** Default timeout in milliseconds (uses AbortSignal.timeout). */
+  timeout?: number;
+}
+interface RequestConfig {
+  headers?: Record<string, string>;
+  params?: Record<string, string | number | boolean>;
+  timeout?: number;
+}
+interface HttpRequestConfig extends RequestConfig {
+  method: string;
+  url: string;
+  body?: unknown;
+}
+interface HttpResponse<T = unknown> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Headers;
+}
+//#endregion
+//#region src/fetch/fetch.module.d.ts
+declare const ConfigurableModuleClass$5: ConfigurableModuleClassType<HttpModuleOptions, "forRoot", "create", {
+  isGlobal?: boolean;
+}>;
+declare class HttpModule extends ConfigurableModuleClass$5 {}
+//#endregion
+//#region src/fetch/fetch.service.d.ts
+declare const HTTP_MODULE_OPTIONS: InjectionToken<HttpModuleOptions>;
+declare class HttpRequestException extends Error {
+  readonly status: number;
+  readonly statusText: string;
+  readonly response: Response;
+  constructor(status: number, statusText: string, response: Response);
+}
+declare class HttpService {
+  private readonly baseURL;
+  private readonly defaultHeaders;
+  private readonly defaultTimeout;
+  constructor(options: HttpModuleOptions);
+  get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+  post<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+  put<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+  patch<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+  delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+  head(url: string, config?: RequestConfig): Promise<HttpResponse<void>>;
+  request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
+  private buildUrl;
+  private parseBody;
+}
+//#endregion
+//#region src/cors/cors.types.d.ts
+interface CorsOptions {
+  origin?: string | string[] | ((origin: string) => string | undefined | null);
+  allowMethods?: string[];
+  allowHeaders?: string[];
+  exposeHeaders?: string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+//#endregion
+//#region src/cors/cors.module.d.ts
+declare const ConfigurableModuleClass$4: ConfigurableModuleClassType<CorsOptions, "forRoot", "create", {
+  isGlobal?: boolean;
+}>;
+declare class CorsModule extends ConfigurableModuleClass$4 {}
+//#endregion
+//#region src/cors/cors.tokens.d.ts
+declare const CORS_OPTIONS: InjectionToken<CorsOptions>;
+//#endregion
+//#region src/cache/cache.types.d.ts
+/** A value that may be returned synchronously or as a promise. */
+type Awaitable<T> = T | Promise<T>;
+interface CacheModuleOptions {
+  ttl?: number;
+  max?: number;
+  isGlobal?: boolean;
+  /**
+   * Custom SYNC backing store (replaces the default in-memory store). For async
+   * (KV/tiered) caching use {@link AsyncCacheStore} + `TieredCacheStore`
+   * programmatically — the interceptor/CacheService path is synchronous.
+   */
+  store?: CacheStore;
+}
+/**
+ * Synchronous cache backing store. This is the original, stable contract used by
+ * `CacheService` and `CacheInterceptor` — unchanged.
+ */
+interface CacheStore {
+  get<T = unknown>(key: string): T | undefined;
+  set<T = unknown>(key: string, value: T, ttl?: number): void;
+  del(key: string): void;
+  clear(): void;
+}
+/**
+ * Asynchronous cache backing store (additive). Implemented by remote/tiered
+ * stores (`TieredCacheStore`, and `KVCacheStore` in `@velajs/cloudflare`) where
+ * reads/writes are inherently async. Use it programmatically — inject the store
+ * under your own token — rather than as the synchronous `CACHE_MANAGER`.
+ */
+interface AsyncCacheStore {
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  del(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+/** A store that may be sync or async (used to compose tiers). */
+type AnyCacheStore = CacheStore | AsyncCacheStore;
+interface CacheEntry<T = unknown> {
+  value: T;
+  expiresAt: number;
+}
+//#endregion
+//#region src/cache/cache.module.d.ts
+declare const ConfigurableModuleClass$3: ConfigurableModuleClassType<CacheModuleOptions, "forRoot", "create", {
+  isGlobal: boolean;
+}>;
+declare class CacheModule extends ConfigurableModuleClass$3 {}
+//#endregion
+//#region src/cache/cache.service.d.ts
+declare class CacheService {
+  private store;
+  constructor(store: CacheStore);
+  get<T = unknown>(key: string): T | undefined;
+  set<T = unknown>(key: string, value: T, ttl?: number): void;
+  del(key: string): void;
+  clear(): void;
+}
+//#endregion
+//#region src/cache/cache.interceptor.d.ts
+declare class CacheInterceptor implements NestInterceptor {
+  private cacheStore;
+  private options;
+  private reflector;
+  constructor(cacheStore: CacheStore, options: CacheModuleOptions);
+  intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}
+//#endregion
+//#region src/cache/cache.store.d.ts
+declare class MemoryCacheStore implements CacheStore {
+  private store;
+  private defaultTtl;
+  private max;
+  constructor(ttl?: number, max?: number);
+  get<T = unknown>(key: string): T | undefined;
+  set<T = unknown>(key: string, value: T, ttl?: number): void;
+  del(key: string): void;
+  clear(): void;
+  private evict;
+}
+//#endregion
+//#region src/cache/tiered-cache.store.d.ts
+/**
+ * Composes an ordered list of cache tiers (fastest first, e.g. in-memory L1 →
+ * KV L2). Tiers may be sync ({@link CacheStore}) or async ({@link AsyncCacheStore}) —
+ * results are awaited uniformly. Reads are read-through: the first tier with a
+ * hit wins, and nearer tiers that missed are backfilled. Writes/deletes/clears
+ * fan out to all tiers. Always async ({@link AsyncCacheStore}).
+ *
+ * Runtime-agnostic — the concrete tiers (memory here, KV in `@velajs/cloudflare`)
+ * live wherever fits.
+ */
+declare class TieredCacheStore implements AsyncCacheStore {
+  private readonly tiers;
+  constructor(tiers: AnyCacheStore[]);
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  del(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/cache/cache.decorators.d.ts
+declare const CacheKey: (key: string) => (target: object, propertyKey?: string | symbol) => void;
+declare const CacheTTL: (seconds: number) => (target: object, propertyKey?: string | symbol) => void;
+//#endregion
+//#region src/cache/cache.tokens.d.ts
+declare const CACHE_MANAGER: InjectionToken<CacheStore>;
+declare const CACHE_MODULE_OPTIONS: InjectionToken<CacheModuleOptions>;
+declare const CACHE_KEY_METADATA = "vela:cache-key";
+declare const CACHE_TTL_METADATA = "vela:cache-ttl";
+//#endregion
+//#region src/event-emitter/event-emitter.module.d.ts
+declare class EventEmitterModule {}
+//#endregion
+//#region src/event-emitter/event-emitter.types.d.ts
+type EventHandler = (...args: unknown[]) => void | Promise<void>;
+interface OnEventMetadata {
+  event: string;
+  methodName: string;
+}
+//#endregion
+//#region src/event-emitter/event-emitter.service.d.ts
+declare class EventEmitter {
+  private exactListeners;
+  private exactOnceListeners;
+  private wildcardListeners;
+  on(event: string, handler: EventHandler): this;
+  once(event: string, handler: EventHandler): this;
+  off(event: string, handler: EventHandler): this;
+  emit(event: string, ...args: unknown[]): Promise<void>;
+  removeAllListeners(event?: string): this;
+  listenerCount(event: string): number;
+  private getOrCreateWildcard;
+}
+//#endregion
+//#region src/event-emitter/event-emitter.subscriber.d.ts
+declare class EventEmitterSubscriber implements OnApplicationBootstrap {
+  private readonly discovery;
+  private emitter;
+  constructor(discovery: DiscoveryService, emitter: EventEmitter);
+  onApplicationBootstrap(): void;
+}
+//#endregion
+//#region src/event-emitter/event-emitter.decorators.d.ts
+declare function OnEvent(event: string): MethodDecorator;
+//#endregion
+//#region src/event-emitter/event-emitter.tokens.d.ts
+declare const ON_EVENT_METADATA = "vela:on-event";
+//#endregion
+//#region src/schedule/schedule.module.d.ts
+/**
+ * Zero-config module (Tier C): providers live on the `@Module` bag; the
+ * `forRoot()` static is NestJS-parity sugar returning the bare dynamic module
+ * (default key — repeated calls dedup).
+ */
+declare class ScheduleModule {
+  static forRoot(): DynamicModule;
+}
+//#endregion
+//#region src/schedule/schedule.decorators.d.ts
+declare function Cron(expression: string): MethodDecorator;
+declare function Interval(ms: number): MethodDecorator;
+//#endregion
+//#region src/schedule/schedule.tokens.d.ts
+declare const CRON_METADATA = "vela:cron";
+declare const INTERVAL_METADATA = "vela:interval";
+//#endregion
+//#region src/schedule/schedule.types.d.ts
+interface CronMetadata {
+  expression: string;
+  methodName: string;
+}
+interface IntervalMetadata {
+  ms: number;
+  methodName: string;
+}
+//#endregion
+//#region src/schedule/cron-matcher.d.ts
+type CronMatcher = (date: Date) => boolean;
+declare function parseCron(expression: string): CronMatcher | null;
+//#endregion
+//#region src/websocket/websocket.types.d.ts
+/** The JSON envelope carried over the raw WebSocket. `id` is an optional client correlation id echoed on the reply. */
+interface WsMessage<T = unknown> {
+  id?: string;
+  event: string;
+  data?: T;
+}
+/** A handler's structured reply. Returning one frames `{ event, data }` back to the sender. */
+interface WsResponse<T = unknown> {
+  event: string;
+  data: T;
+}
+/**
+ * A single connected socket, normalized across runtimes. Per-connection state
+ * lives in `data`; mutations to `data`/room membership are persisted by
+ * `commit()` (on Cloudflare this writes the hibernation attachment).
+ */
+interface WsClient<TData = Record<string, unknown>> {
+  readonly id: string;
+  readonly rooms: ReadonlySet<string>;
+  data: TData;
+  /** Frame and send `{ event, data }` (optionally correlated by `id`) to this socket. */
+  send(event: string, data?: unknown, id?: string): void;
+  /** Send an already-serialized string. Escape hatch for custom framing. */
+  sendRaw(payload: string): void;
+  join(room: string): void | Promise<void>;
+  leave(room: string): void | Promise<void>;
+  /** Persist `data`/room mutations made during a handler. */
+  commit(): void | Promise<void>;
+  close(code?: number, reason?: string): void;
+  /** The native socket (`WSContext` on node/bun/deno, `WebSocket` in a Cloudflare DO). */
+  readonly raw: unknown;
+}
+/** Fluent broadcast builder. Terminal `.emit()` produces a `BroadcastCommand`. */
+interface BroadcastOperator {
+  to(room: string): BroadcastOperator;
+  in(room: string): BroadcastOperator;
+  except(room: string): BroadcastOperator;
+  emit(event: string, data?: unknown): void | Promise<void>;
+}
+/** The server handle injected via `@WebSocketServer()`. Server-origin broadcasts never exclude anyone. */
+interface WsServer {
+  emit(event: string, data?: unknown): void | Promise<void>;
+  to(room: string): BroadcastOperator;
+  in(room: string): BroadcastOperator;
+  except(room: string): BroadcastOperator;
+}
+/** An `ExecutionContext` whose transport is a WebSocket gateway. `switchToWs()` is guaranteed present. */
+interface WsExecutionContext extends ExecutionContext {
+  switchToWs(): WsArgumentsHost;
+}
+interface OnGatewayInit {
+  afterInit(server: WsServer): void | Promise<void>;
+}
+interface OnGatewayConnection {
+  handleConnection(client: WsClient): void | Promise<void>;
+}
+interface OnGatewayDisconnect {
+  handleDisconnect(client: WsClient): void | Promise<void>;
+}
+interface WebSocketGatewayOptions {
+  /** Route path the upgrade is served on (e.g. `/rooms/:id/ws`). */
+  path?: string;
+  /** Cloudflare Durable Object binding name that hosts this gateway's sockets. */
+  binding?: string;
+}
+/** Stored per `@SubscribeMessage` — a flat class-level list, mirroring `@OnEvent`. */
+interface SubscribeMessageMetadata {
+  event: string;
+  methodName: string;
+}
+/** Class-level meta written by `@ReservedWsEvent(event)`. */
+interface ReservedWsEventMetadata {
+  /** The reserved (`$`-prefixed) envelope event this provider handles. */
+  event: string;
+}
+/**
+ * A provider claiming a reserved (`$`-prefixed) envelope event across EVERY
+ * gateway path. Discovered by `WsDispatcher` at bootstrap via the
+ * `@ReservedWsEvent` decorator; inbound frames for the event route here
+ * (after app-wide guards), never to gateways. `handleSocketClose` fires for
+ * every closing socket so the handler can drop per-connection state.
+ */
+interface ReservedWsEventHandler {
+  handleReservedEvent(path: string, client: WsClient, message: WsMessage): void | Promise<void>;
+  handleSocketClose?(path: string, client: WsClient): void | Promise<void>;
+}
+/**
+ * A fully serializable broadcast instruction. Crosses isolate / Durable-Object /
+ * Redis boundaries as JSON, so every sync driver speaks the same command.
+ */
+interface BroadcastCommand {
+  /** Target rooms. An empty array means GLOBAL (every connection). */
+  rooms: string[];
+  exceptRooms?: string[];
+  exceptIds?: string[];
+  /** The exact bytes written to each socket: `JSON.stringify({ event, data })`. */
+  frame: string;
+  /** Origin instance/DO id — lets pub/sub drivers drop their own echo. */
+  origin?: string;
+}
+//#endregion
+//#region src/websocket/websocket.decorators.d.ts
+/**
+ * Marks a class as a WebSocket gateway. Mirrors `@Controller` for the socket
+ * transport: registers the class as an injectable singleton and stores its
+ * routing options (`path`, Cloudflare `binding`).
+ *
+ * @example
+ * ```ts
+ * @WebSocketGateway({ path: '/rooms/:id/ws', binding: 'CHAT_ROOM' })
+ * class ChatGateway {}
+ * ```
+ */
+declare function WebSocketGateway(options?: WebSocketGatewayOptions): ClassDecorator;
+/**
+ * Binds a gateway method to an inbound event. Stackable — one class-level list,
+ * exactly like `@OnEvent` (`event-emitter.decorators.ts`).
+ */
+declare function SubscribeMessage(event: string): MethodDecorator;
+/**
+ * Claims a reserved (`$`-prefixed) envelope event for a framework-module
+ * provider (see `ReservedWsEventHandler`). Reserved frames route to the
+ * decorated provider across every gateway path — gateways themselves may not
+ * subscribe to `$…` events. Stack with `@Injectable()` like `@Processor`.
+ *
+ * @example
+ * ```ts
+ * @ReservedWsEvent('$live')
+ * @Injectable()
+ * class LiveEngine implements ReservedWsEventHandler { … }
+ * ```
+ */
+declare function ReservedWsEvent(event: string): ClassDecorator;
+/** Injects the inbound message payload (the envelope's `data`) into a handler parameter. */
+declare const MessageBody: () => ParameterDecorator;
+/** Injects the connected socket (`WsClient`) into a handler parameter. */
+declare const ConnectedSocket: () => ParameterDecorator;
+/**
+ * Injects the gateway server handle (`WsServer`). Constructor injection only —
+ * the container has no property-injection pass, so this is sugar for
+ * `@Inject(WS_SERVER)` on a constructor parameter.
+ *
+ * @example
+ * ```ts
+ * constructor(@WebSocketServer() private server: WsServer) {}
+ * ```
+ */
+declare function WebSocketServer(): ParameterDecorator;
+//#endregion
+//#region src/websocket/ws-sync.d.ts
+/**
+ * Owns LOCAL room membership and local fan-out for the connections a single
+ * node/isolate holds. The Cloudflare transport backs this with hibernation
+ * tags + attachment; node/bun/deno back it with the in-memory implementation
+ * below. Always edge-safe (no `node:*`).
+ */
+interface RoomRegistry {
+  /** Register a connection (called on connect) so global broadcasts can reach it. */
+  register(client: WsClient): void;
+  join(client: WsClient, room: string): void | Promise<void>;
+  leave(client: WsClient, room: string): void | Promise<void>;
+  /** Remove a connection and all its room memberships (called on disconnect). */
+  leaveAll(client: WsClient): void | Promise<void>;
+  /** Deliver a command to the sockets THIS node holds, applying every exclusion. */
+  deliverLocal(cmd: BroadcastCommand): void | Promise<void>;
+  localIdsInRoom(room: string): string[];
+}
+/**
+ * Pluggable cross-instance transport for broadcast commands. `local()` is the
+ * zero-config single-instance default; `durableObject()` (Cloudflare) and
+ * `redis()` (node) are additive and chosen at the composition root.
+ */
+interface SyncDriver {
+  readonly kind: string;
+  /** Wire the local registry so the driver can deliver to locally-held sockets. */
+  bind(registry: RoomRegistry): void;
+  /** Route a command so every node that may hold a matching socket delivers it. */
+  dispatch(cmd: BroadcastCommand): void | Promise<void>;
+  countRoom?(room: string): Promise<number>;
+  start?(): void | Promise<void>;
+  stop?(): void | Promise<void>;
+}
+/** Single-instance default: deliver straight to the local registry, no cross-node hop. */
+declare function local(): SyncDriver;
+/** In-memory `RoomRegistry` for node/bun/deno and tests. Edge-safe (plain Maps). */
+declare class InMemoryRoomRegistry implements RoomRegistry {
+  private readonly rooms;
+  private readonly clientRooms;
+  private readonly clients;
+  register(client: WsClient): void;
+  join(client: WsClient, room: string): void;
+  leave(client: WsClient, room: string): void;
+  leaveAll(client: WsClient): void;
+  localIdsInRoom(room: string): string[];
+  deliverLocal(cmd: BroadcastCommand): void;
+}
+//#endregion
+//#region src/websocket/websocket.module.d.ts
+interface WebSocketModuleOptions {
+  /**
+   * Cross-instance sync driver. Defaults to `local()` (single instance). Use
+   * `durableObject()` from `@velajs/cloudflare` or `redis()` from
+   * `@velajs/vela/websocket-node` for horizontal scale.
+   */
+  sync?: SyncDriver;
+  /**
+   * Local room registry the transport reads/writes. Defaults to the in-memory
+   * implementation (node/bun/deno); the Cloudflare transport supplies its own.
+   */
+  registry?: RoomRegistry;
+}
+/**
+ * Registers the WebSocket gateway machinery: the message dispatcher (discovers
+ * `@WebSocketGateway` classes via DiscoveryService at bootstrap), the room
+ * registry, the sync driver, and the `@WebSocketServer()`-injected server
+ * handle.
+ *
+ * Construction lives in chained provider factories — registry → driver
+ * (bound to THAT registry) → server — so the single shared registry instance
+ * is preserved and everything materializes at bootstrap's eager
+ * instantiation, before any lifecycle hook or message dispatch.
+ *
+ * The instance key derives from the sync driver kind: two `forRoot()` calls
+ * with the same driver kind dedup (HMR-idempotent); pass an explicit `key`
+ * to run multiple same-kind instances side by side.
+ */
+declare const ConfigurableModuleClass$2: ConfigurableModuleClassType<WebSocketModuleOptions, "forRoot", "create", {
+  isGlobal?: boolean;
+}>;
+declare class WebSocketModule extends ConfigurableModuleClass$2 {}
+//#endregion
+//#region src/websocket/ws-dispatcher.d.ts
+/** Metadata carried by each `'websocket'` entrypoint a transport consumes. */
+interface WsEntrypointMeta {
+  /** The gateway's route path (from `@WebSocketGateway({ path })`). */
+  path: string;
+  /** The dispatcher that routes frames for this gateway. */
+  dispatcher: WsDispatcher;
+}
+/**
+ * Discovers `@WebSocketGateway` classes at bootstrap (via `DiscoveryService`)
+ * and routes inbound messages to `@SubscribeMessage` handlers. Transports read
+ * the gateways from `app.entrypoints.ofKind('websocket')` (this dispatcher
+ * contributes them) and call `handleOpen`, `dispatchMessage`, `handleClose`,
+ * and `handleError`; the guard → pipe → interceptor → filter pipeline
+ * (including `APP_*` global components) runs through the shared
+ * `PipelineRunner`.
+ */
+declare class WsDispatcher implements OnApplicationBootstrap, ContributesEntrypoints {
+  private readonly container;
+  private readonly discovery;
+  private readonly server?;
+  private readonly routeManager?;
+  private readonly gateways;
+  private readonly reserved;
+  constructor(container: Container, discovery: DiscoveryService, server?: WsServer | undefined, routeManager?: RouteManager | undefined);
+  /** Paths of every discovered `@WebSocketGateway` — used by transports to register routes. */
+  get gatewayPaths(): string[];
+  onApplicationBootstrap(): Promise<void>;
+  /** One `'websocket'` entrypoint per discovered gateway (authoritative). */
+  collectEntrypoints(): Entrypoint<WsEntrypointMeta>[];
+  handleOpen(path: string, client: WsClient): Promise<void>;
+  handleClose(path: string, client: WsClient, _code: number, _reason: string): Promise<void>;
+  handleError(path: string, _client: WsClient, err: unknown): Promise<void>;
+  dispatchMessage(path: string, client: WsClient, raw: string | ArrayBuffer): Promise<void>;
+  /**
+   * Route a reserved (`$…`) frame to its claiming handler. App-wide (`APP_*` /
+   * `useGlobalGuards`) guards protect reserved frames exactly like gateway
+   * messages — guards-first, WS convention; handler/class-tier components are
+   * the claiming module's own concern (e.g. live resolvers run their scoped
+   * guards at subscribe).
+   */
+  private dispatchReserved;
+  private reply;
+  private runFilters;
+  private trySend;
+  private reportBootstrapError;
+  private parse;
+  private buildGatewayEntry;
+}
+//#endregion
+//#region src/websocket/ws-server.d.ts
+/**
+ * Accumulates `{ rooms, exceptRooms, exceptIds }` across a fluent chain and, on
+ * `.emit()`, produces a serializable `BroadcastCommand` handed to the active
+ * `SyncDriver`. The driver decides local-vs-remote delivery.
+ */
+declare class BroadcastOperatorImpl implements BroadcastOperator {
+  private readonly driver;
+  private readonly rooms;
+  private readonly exceptRooms;
+  private readonly exceptIds;
+  constructor(driver: SyncDriver, rooms?: Set<string>, exceptRooms?: Set<string>, exceptIds?: Set<string>);
+  to(room: string): this;
+  in(room: string): this;
+  except(room: string): this;
+  emit(event: string, data?: unknown): void | Promise<void>;
+}
+/**
+ * The `@WebSocketServer()`-injected handle. Server-origin broadcasts never
+ * pre-exclude anyone (a client-origin `client.to()` seeds `exceptIds` with the
+ * sender — that lives in the transport's client, not here).
+ */
+declare class WsServerImpl implements WsServer {
+  private readonly driver;
+  constructor(driver: SyncDriver);
+  emit(event: string, data?: unknown): void | Promise<void>;
+  to(room: string): BroadcastOperator;
+  in(room: string): BroadcastOperator;
+  except(room: string): BroadcastOperator;
+}
+//#endregion
+//#region src/websocket/ws-execution-context.d.ts
+/**
+ * WebSocket sibling of `buildExecutionContext` (`http/execution-context.ts`).
+ * Guards/pipes/interceptors/filters that read `getClass()`/`getHandler()` or
+ * call `switchToWs()` reuse unchanged; the HTTP-only accessors throw rather
+ * than fabricate a fake `Request`.
+ */
+declare function buildWsExecutionContext(client: WsClient, data: unknown, controller: Type, handlerName: string | symbol, pattern: string): WsExecutionContext;
+//#endregion
+//#region src/websocket/ws-exception.d.ts
+/**
+ * WebSocket analogue of `HttpException`. Thrown from guards/pipes/handlers to
+ * signal a client-facing error; the dispatcher serializes it to an
+ * `{ event: 'exception', data }` frame unless a matching exception filter
+ * handles it first.
+ */
+declare class WsException extends Error {
+  private readonly err;
+  constructor(err: string | Record<string, unknown>);
+  getError(): string | Record<string, unknown>;
+}
+/**
+ * Default serialization of an uncaught error into the outbound exception frame.
+ *
+ * A `WsException` ships its own payload verbatim (string → `{ message }`,
+ * object → as-is). Every other error routes through `toErrorBody` — the single
+ * wire-redaction seam shared with the HTTP edge — so unbranded/internal errors
+ * are redacted to their catalog title and only branded `VelaError`s echo a
+ * client-safe `{ code, message, ... }`.
+ */
+declare function toErrorFrame(error: unknown, catalog?: Catalog<string>): {
+  event: 'exception';
+  data: unknown;
+};
+//#endregion
+//#region src/websocket/ws-argument-resolver.d.ts
+/**
+ * Builds handler arguments for a gateway message. WS sibling of the HTTP
+ * `ArgumentResolver`, but sourced from the envelope (`data`) and the socket
+ * (`client`) instead of the Hono `Context`.
+ *
+ * With no parameter decorators the handler receives `(client, data)` — the
+ * NestJS gateway convention. Pipes run only over `@MessageBody()` values, where
+ * validation/transformation is meaningful.
+ */
+declare function resolveWsArgs(paramMeta: ParameterMetadata[], client: WsClient, data: unknown, pipes: PipeTransform[], paramTypes?: unknown[]): Promise<unknown[]>;
+//#endregion
+//#region src/websocket/websocket.tokens.d.ts
+declare const WS_GATEWAY_METADATA = "vela:ws-gateway";
+declare const WS_SUBSCRIBE_METADATA = "vela:ws-subscribe";
+declare const WS_RESERVED_METADATA = "vela:ws-reserved";
+/**
+ * Event names starting with this prefix are RESERVED for framework modules
+ * (`$live`, …): app gateways may not subscribe to them, and inbound frames
+ * carrying them route to `@ReservedWsEvent` handlers instead of gateways.
+ */
+declare const RESERVED_WS_EVENT_PREFIX = "$";
+declare const WsParamType: {
+  readonly SOCKET: 'ws_socket';
+  readonly BODY: 'ws_body';
+  readonly SERVER: 'ws_server';
+};
+type WsParamType = (typeof WsParamType)[keyof typeof WsParamType];
+/**
+ * The connected gateway server handle. Injected into gateways/controllers via
+ * `@WebSocketServer()` (constructor injection only — the container has no
+ * property-injection pass) or `@Inject(WS_SERVER)`.
+ */
+declare const WS_SERVER: InjectionToken<WsServer>;
+/** The active cross-instance sync driver (`local()` by default). */
+declare const WS_SYNC_DRIVER: InjectionToken<SyncDriver>;
+/** The local room-membership registry a transport reads/writes. */
+declare const WS_ROOM_REGISTRY: InjectionToken<RoomRegistry>;
+declare const WS_MODULE_OPTIONS: InjectionToken<WebSocketModuleOptions>;
+//#endregion
+//#region src/health/health.module.d.ts
+declare class HealthModule {}
+//#endregion
+//#region src/health/health.types.d.ts
+type HealthCheckStatus = 'ok' | 'error' | 'shutting_down';
+interface HealthIndicatorResult {
+  [key: string]: {
+    status: 'up' | 'down';
+    [key: string]: unknown;
+  };
+}
+interface HealthCheckResult {
+  status: HealthCheckStatus;
+  info: HealthIndicatorResult;
+  error: HealthIndicatorResult;
+  details: HealthIndicatorResult;
+}
+type HealthIndicatorFunction = () => Promise<HealthIndicatorResult>;
+type ResponseCheckCallback = (response: Response) => boolean | Promise<boolean>;
+//#endregion
+//#region src/health/health.service.d.ts
+declare class HealthCheckService implements BeforeApplicationShutdown {
+  private isShuttingDown;
+  beforeApplicationShutdown(): void;
+  check(indicators: HealthIndicatorFunction[]): Promise<HealthCheckResult>;
+}
+//#endregion
+//#region src/health/health.indicator.d.ts
+interface HealthIndicatorBuilder {
+  up(data?: Record<string, unknown>): HealthIndicatorResult;
+  down(data?: Record<string, unknown>): HealthIndicatorResult;
+}
+declare class HealthIndicatorService {
+  check(key: string): HealthIndicatorBuilder;
+}
+//#endregion
+//#region src/health/health.http.d.ts
+interface HttpPingOptions {
+  method?: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+  expectedStatus?: number;
+}
+declare class HttpHealthIndicator {
+  private indicator;
+  constructor(indicator: HealthIndicatorService);
+  pingCheck(key: string, url: string, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
+  responseCheck(key: string, url: string, callback: ResponseCheckCallback, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
+}
+//#endregion
+//#region src/throttler/throttler.types.d.ts
+interface ThrottleConfig {
+  limit: number;
+  ttl: number;
+}
+interface ThrottlerStorageRecord {
+  count: number;
+  ttlMs: number;
+}
+interface ThrottlerStore {
+  increment(key: string, ttlMs: number): ThrottlerStorageRecord | Promise<ThrottlerStorageRecord>;
+  reset(key: string): void | Promise<void>;
+}
+interface RateLimitInfo {
+  limit: number;
+  remaining: number;
+  reset: number;
+}
+interface ThrottlerModuleOptions extends ThrottleConfig {
+  storage?: ThrottlerStore;
+  getTracker?: (request: Request) => string;
+  generateKey?: (tracker: string, context: {
+    className: string;
+    handlerName: string;
+  }) => string;
+}
+//#endregion
+//#region src/throttler/throttler.module.d.ts
+declare const ConfigurableModuleClass$1: ConfigurableModuleClassType<ThrottlerModuleOptions, "forRoot", "create", {
+  isGlobal?: boolean;
+}>;
+declare class ThrottlerModule extends ConfigurableModuleClass$1 {}
+//#endregion
+//#region src/throttler/throttler.guard.d.ts
+declare class ThrottlerGuard implements CanActivate {
+  private options;
+  private storage;
+  private reflector;
+  constructor(options: ThrottlerModuleOptions, storage: ThrottlerStore);
+  canActivate(context: ExecutionContext): Promise<boolean>;
+}
+//#endregion
+//#region src/throttler/throttler.storage.d.ts
+declare class ThrottlerStorage implements ThrottlerStore {
+  private current;
+  private previous;
+  private lastSwap;
+  private readonly swapIntervalMs;
+  increment(key: string, ttlMs: number): ThrottlerStorageRecord;
+  reset(key: string): void;
+  private maybeSwap;
+}
+//#endregion
+//#region src/throttler/throttler.decorators.d.ts
+declare const Throttle: (config: ThrottleConfig) => (target: object, propertyKey?: string | symbol) => void;
+declare const SkipThrottle: () => (target: object, propertyKey?: string | symbol) => void;
+//#endregion
+//#region src/throttler/throttler.tokens.d.ts
+declare const THROTTLER_OPTIONS: InjectionToken<ThrottlerModuleOptions>;
+declare const THROTTLER_STORAGE: InjectionToken<ThrottlerStore>;
+declare const THROTTLE_METADATA = "vela:throttle";
+declare const SKIP_THROTTLE_METADATA = "vela:skip-throttle";
+//#endregion
+//#region src/module/stable-hash.d.ts
+/**
+ * Deterministic, sync, edge-safe hash for module-instance discrimination.
+ *
+ * Walks values (objects/arrays/primitives/functions/class instances) into a
+ * sorted, source-fingerprinting JSON string, then runs FNV-1a (32-bit) for a
+ * compact 8-hex-char output.
+ *
+ * Functions and class instances are tolerated — they become `__fn:source` or
+ * `__cls:ClassName` markers. Two distinct closures with the same source code
+ * collide; module authors who care about that should pass an explicit `key`.
+ *
+ * Not cryptographic. Sufficient for discriminating module instances within
+ * an app.
+ */
+declare function stableHash(value: unknown): string;
+//#endregion
+//#region src/module/configurable-module.types.d.ts
+/**
+ * Arbitrary extra keys a module accepts alongside its options bag (e.g.
+ * `isGlobal`). Kept separate from the options type so the extras-transform can
+ * reshape the generated {@link DynamicModule} without polluting `Opts`.
+ */
+type ConfigurableModuleExtras = Record<string, unknown>;
+/**
+ * Reshape the generated definition based on the resolved extras. Runs after the
+ * options provider + `key` are computed; the return value is the final
+ * `DynamicModule`. Mirrors NestJS's `extras` transform.
+ */
+type ConfigurableModuleExtrasTransform<E extends ConfigurableModuleExtras> = (definition: DynamicModule, extras: E) => DynamicModule;
+/**
+ * The contract a `useClass`/`useExisting` async-options factory must satisfy:
+ * a single method (default name `create`) returning the module options.
+ */
+type ConfigurableModuleOptionsFactory<Opts, MethodName extends string> = { [K in MethodName]: () => Opts | Promise<Opts>; };
+/**
+ * Async configuration accepted by the generated `<method>Async` static.
+ *
+ * Superset of `AsyncModuleOptions` (`registry/types.ts`): adds NestJS's
+ * `useClass`/`useExisting` while preserving the headline `const Inject` tuple
+ * inference for `useFactory` params (no `as const` needed at the call site).
+ */
+interface ConfigurableModuleAsyncOptions<Opts, MethodName extends string = 'create', Inject extends readonly Token<unknown>[] = readonly Token<unknown>[]> {
+  imports?: ModuleImport[];
+  inject?: Inject;
+  useFactory?: (...args: InferTokens<Inject>) => Opts | Promise<Opts>;
+  useClass?: Type<ConfigurableModuleOptionsFactory<Opts, MethodName>>;
+  useExisting?: Token<ConfigurableModuleOptionsFactory<Opts, MethodName>>;
+  /** Explicit instance discriminator (see {@link DynamicModule.key}). */
+  key?: string;
+}
+interface ConfigurableModuleBuilderOptions {
+  /** Names the generated base class + the auto-minted options token, and feeds diagnostics. */
+  moduleName?: string;
+  /**
+   * Reuse an existing options token instead of minting one. **Critical for
+   * migrations** so the module's public token keeps its identity.
+   */
+  optionsInjectionToken?: InjectionToken<unknown>;
+}
+/**
+ * The generated base class type, carrying dynamically-named `<method>` and
+ * `<method>Async` statics. A module does `class Foo extends ConfigurableModuleClass {}`
+ * and gets `Foo.forRoot(...)` / `Foo.forRootAsync(...)` for free.
+ */
+type ConfigurableModuleClassType<Opts, MethodKey extends string, FactoryMethodKey extends string, Extras extends ConfigurableModuleExtras> = (new () => object) & Record<MethodKey, (options: Opts & Partial<Extras> & {
+  key?: string;
+}) => DynamicModule> & Record<`${MethodKey}Async`, <const Inject extends readonly Token<unknown>[]>(options: ConfigurableModuleAsyncOptions<Opts, FactoryMethodKey, Inject> & Partial<Extras> & {
+  key?: string;
+}) => DynamicModule>;
+interface ConfigurableModuleHost<Opts, MethodKey extends string = 'forRoot', FactoryMethodKey extends string = 'create', Extras extends ConfigurableModuleExtras = {
+  isGlobal?: boolean;
+}> {
+  /** Base class to `extends`. */
+  ConfigurableModuleClass: ConfigurableModuleClassType<Opts, MethodKey, FactoryMethodKey, Extras>;
+  /** The options token — inject it into derived providers (`inject: [MODULE_OPTIONS_TOKEN]`). */
+  MODULE_OPTIONS_TOKEN: InjectionToken<Opts>;
+  /** Type-only helper: the shape accepted by the sync `<method>` static. */
+  OPTIONS_TYPE: Opts & Partial<Extras> & {
+    key?: string;
+  };
+  /** Type-only helper: the shape accepted by the `<method>Async` static. */
+  ASYNC_OPTIONS_TYPE: ConfigurableModuleAsyncOptions<Opts, FactoryMethodKey> & Partial<Extras> & {
+    key?: string;
+  };
+}
+/**
+ * Low-level engine spec (see `defineConfigurableModule`). Used for the cases a
+ * class-mixin can't express — notably runtime-generated module classes whose
+ * providers depend on a call-time argument (e.g. Cloudflare binding modules).
+ */
+interface DefineConfigurableModuleSpec<Args> {
+  /** The module class to reference in `{ module }`. */
+  module: Type;
+  /** Static method name to generate (e.g. `forRoot`). */
+  methodName?: string;
+  /** Derive the instance `key` from the call args. */
+  keyFrom: (args: Args) => string;
+  /** Build the provider list from the call args. */
+  providers: (args: Args) => DynamicModule['providers'];
+  /** Optional exports (usually prefer declaring these on `@Module`). */
+  exports?: DynamicModule['exports'];
+  /** Optional imports. */
+  imports?: (args: Args) => DynamicModule['imports'];
+  /** Mark the produced module global. */
+  global?: boolean;
+}
+//#endregion
+//#region src/module/configurable-module.builder.d.ts
+/**
+ * Blessed key-derivation helper for hand-written `forRoot` statics: the one
+ * documented way to derive a `DynamicModule.key` from an options bag so
+ * identical configurations dedup (HMR-idempotent) and distinct ones coexist.
+ * Alias of {@link stableHash} with a module-authoring name.
+ */
+declare const moduleKey: (options: unknown) => string;
+/**
+ * NestJS-parity builder that generates `forRoot`/`forRootAsync` (and `key`,
+ * `global`, factory-param inference) from a tiny spec — so a module is just its
+ * tokens + options type + service + a `@Module({...})` bag, while vela keeps its
+ * encapsulation (`exports`/visibility) and multi-instance `key` dedup.
+ *
+ * Since 1.11 this is a thin adapter over {@link defineModule} — the single
+ * authoring engine. Prefer `defineModule` for new modules: it additionally
+ * supports contributions (providers/controllers/imports/exports/global
+ * components) computed as functions of the options.
+ *
+ * @example
+ * ```ts
+ * const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } =
+ *   new ConfigurableModuleBuilder<FooOptions>({ moduleName: 'Foo' }).build();
+ *
+ * @Module({
+ *   providers: [FooService], // derived providers inject MODULE_OPTIONS_TOKEN
+ *   exports: [FooService],
+ * })
+ * export class FooModule extends ConfigurableModuleClass {}
+ * ```
+ */
+declare class ConfigurableModuleBuilder<Opts, MethodKey extends string = 'forRoot', FactoryMethodKey extends string = 'create', Extras extends ConfigurableModuleExtras = {
+  isGlobal?: boolean;
+}> {
+  private readonly options;
+  private classMethodName;
+  private factoryMethodName;
+  private extrasDefaults;
+  private extrasTransform;
+  constructor(options?: ConfigurableModuleBuilderOptions);
+  /** Declare extra call-site keys (e.g. `isGlobal`) + how they reshape the definition. */
+  setExtras<NewExtras extends ConfigurableModuleExtras>(defaults: NewExtras, transform: ConfigurableModuleExtrasTransform<NewExtras>): ConfigurableModuleBuilder<Opts, MethodKey, FactoryMethodKey, NewExtras>;
+  /** Rename the sync static (default `forRoot`); the async static becomes `<name>Async`. */
+  setClassMethodName<NewMethodKey extends string>(name: NewMethodKey): ConfigurableModuleBuilder<Opts, NewMethodKey, FactoryMethodKey, Extras>;
+  /** Rename the method a `useClass`/`useExisting` options factory must implement (default `create`). */
+  setFactoryMethodName<NewFactoryMethodKey extends string>(name: NewFactoryMethodKey): ConfigurableModuleBuilder<Opts, MethodKey, NewFactoryMethodKey, Extras>;
+  build(): ConfigurableModuleHost<Opts, MethodKey, FactoryMethodKey, Extras>;
+}
+/**
+ * Lower-level engine for cases a class-mixin can't express — chiefly a
+ * runtime-generated module class whose providers depend on a call-time arg
+ * (Cloudflare binding modules). Returns an object with a single static named by
+ * `spec.methodName` (default `forRoot`).
+ */
+declare function defineConfigurableModule<Args>(spec: DefineConfigurableModuleSpec<Args>): Record<string, (args: Args) => DynamicModule>;
+//#endregion
+//#region src/module/define-module.d.ts
+/** The `global:` slot's component groups, lowered to `APP_*` registrations. */
+interface GlobalComponentSlot {
+  guards?: Array<Type | ComponentInstance>;
+  pipes?: Array<Type | ComponentInstance>;
+  interceptors?: Array<Type | ComponentInstance>;
+  filters?: Array<Type | ComponentInstance>;
+  middleware?: Array<Type | ComponentInstance>;
+}
+/** What a module instance contributes, computed from its call-time options. */
+interface ModuleContributions {
+  providers?: Array<Type | ProviderOptions>;
+  controllers?: Type[];
+  imports?: ModuleImport[];
+  exports?: Array<Type | InjectionToken>;
+  /**
+   * Standardized global-component registration — the one idiom replacing both
+   * the `@Module({ providers: [{ provide: APP_GUARD, useExisting: X }] })`
+   * pattern and the conditional-push-into-forRoot pattern. Class entries are
+   * registered as providers and wired via `useExisting`; instances via `useValue`.
+   */
+  global?: GlobalComponentSlot;
+}
+interface ModuleSetupContext<Opts> {
+  /** The options token — derived providers do `inject: [OPTIONS]`. */
+  readonly OPTIONS: InjectionToken<Opts>;
+  /**
+   * Structural options known at call time. For `forRoot` this is the full
+   * bag; for `forRootAsync` it is only the structural fields passed alongside
+   * the factory (the DI-resolved options exist only at resolution time —
+   * read them through `OPTIONS`, never here).
+   */
+  readonly options: Partial<Opts>;
+  /** The instance key in effect (for deriving per-instance token names). */
+  readonly key: string;
+}
+interface DefineModuleSpec<Opts, Extras extends ConfigurableModuleExtras = {
+  isGlobal?: boolean;
+}, MethodKey extends string = 'forRoot', FactoryMethodKey extends string = 'create'> {
+  /** Names the generated base class, the minted options token, and diagnostics. */
+  name: string;
+  /**
+   * Reuse an existing options token instead of minting one — critical for
+   * migrations so the module's public token keeps its identity.
+   */
+  optionsToken?: InjectionToken<Opts>;
+  /**
+   * Structural contributions as a function of the call-time options. Runs at
+   * `forRoot`/`forRootAsync` call time, once per module instance.
+   */
+  setup?: (ctx: ModuleSetupContext<Opts>) => ModuleContributions;
+  /**
+   * Dedup key from the structural options. Defaults to `stableHash(options)`.
+   * Modules whose options carry stateful instances (drivers, registries)
+   * should derive from the stable identifying subset — or document that
+   * callers pass an explicit `key` for multi-instance setups.
+   */
+  key?: (options: Partial<Opts>) => string;
+  /** Call-site extras defaults (default `{ isGlobal: false }`). */
+  extras?: Extras;
+  /** Reshape the definition from resolved extras (default: `isGlobal` → `global: true`). */
+  transform?: ConfigurableModuleExtrasTransform<Extras>;
+  /** Rename the sync static (default `forRoot`); the async static becomes `<name>Async`. */
+  methodName?: MethodKey;
+  /** Method a `useClass`/`useExisting` options factory must implement (default `create`). */
+  factoryMethodName?: FactoryMethodKey;
+  /**
+   * Default every generated module instance to deferred (first-use)
+   * materialization. Call sites can also opt in per instance by passing
+   * `lazy: true` alongside the options (recognized like `isGlobal`).
+   * See MODULE_AUTHORING.md "Lazy modules".
+   */
+  lazy?: boolean;
+}
+/**
+ * The one blessed module-authoring engine. Generates `forRoot` AND
+ * `forRootAsync` statics with: `stableHash` key derivation (multi-instance
+ * dedup that survives HMR), typed `inject` tuple inference on the async
+ * factory, an `isGlobal` extra, and — the piece `ConfigurableModuleBuilder`
+ * could not express — providers/controllers/imports/exports/global components
+ * computed **as functions of the options**.
+ *
+ * ```ts
+ * const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = defineModule<CorsOptions>({
+ *   name: 'Cors',
+ *   setup: ({ OPTIONS }) => ({
+ *     providers: [{
+ *       provide: APP_MIDDLEWARE,
+ *       useFactory: (o: CorsOptions) => buildCorsMiddleware(o),
+ *       inject: [OPTIONS],
+ *     }],
+ *     exports: [OPTIONS],
+ *   }),
+ * });
+ * export class CorsModule extends ConfigurableModuleClass {}
+ * ```
+ *
+ * `ConfigurableModuleBuilder` remains supported (NestJS parity) and is a thin
+ * adapter over this engine.
+ */
+declare function defineModule<Opts, Extras extends ConfigurableModuleExtras = {
+  isGlobal?: boolean;
+}, MethodKey extends string = 'forRoot', FactoryMethodKey extends string = 'create'>(spec: DefineModuleSpec<Opts, Extras, MethodKey, FactoryMethodKey>): ConfigurableModuleHost<Opts, MethodKey, FactoryMethodKey, Extras>;
+/**
+ * Lower `useFactory`/`useClass`/`useExisting` async options into provider
+ * registrations. Structural fields from the call site merge UNDER the resolved
+ * options (`{ ...structural, ...resolved }`) so sync-declared fields act as
+ * defaults and the factory stays authoritative.
+ */
+declare function buildAsyncOptionsProviders<Opts>(optionsToken: Token, factoryMethodName: string, async: Pick<ConfigurableModuleAsyncOptions<Opts>, 'inject' | 'useFactory' | 'useClass' | 'useExisting'>, structural?: Record<string, unknown>): Array<ProviderOptions>;
+//#endregion
+//#region src/module/lazy-provider.d.ts
+interface LazyProviderSpec<T, Inject extends readonly Token<unknown>[]> {
+  /** Token under which the memoized thunk `() => T` is provided. */
+  provide: Token<() => T>;
+  inject?: Inject;
+  useFactory: (...deps: InferTokens<Inject>) => T;
+  /** Memoize the first call's result (default true). */
+  memoize?: boolean;
+}
+/**
+ * Provide a zero-arg thunk `() => T` whose factory runs on FIRST CALL, not at
+ * provider construction — for values that don't exist yet when the module
+ * graph is built (Cloudflare bindings are only live at request time).
+ *
+ * The shared primitive replacing the hand-rolled
+ * `useFactory: (...deps) => () => build(...deps)` closure that auth and
+ * storage each copy-pasted.
+ *
+ * ```ts
+ * lazyProvider({
+ *   provide: STORAGE_DRIVER_BUILDER,
+ *   inject: [MODULE_OPTIONS_TOKEN],
+ *   useFactory: (options) => options.driver(),
+ * })
+ * ```
+ */
+declare function lazyProvider<T, const Inject extends readonly Token<unknown>[] = readonly Token<unknown>[]>(spec: LazyProviderSpec<T, Inject>): ProviderOptions;
+/**
+ * The one idiom for registering an app-wide component from a module's
+ * providers. Returns registrations to spread:
+ *
+ * ```ts
+ * providers: [MyService, ...provideGlobal('guard', AuthGuard)]
+ * ```
+ *
+ * Class components are registered as providers and wired via `useExisting`
+ * (so DI constructs them with their dependencies); instances via `useValue`.
+ * Inside `defineModule`, prefer the equivalent `global:` contribution slot.
+ */
+declare function provideGlobal(kind: ComponentType, component: Type | object): Array<Type | ProviderOptions>;
+/**
+ * A first-class side-effect-only module: contributes providers/exports without
+ * being a configurable module — the supported form of the "empty marker
+ * module" trick (i18n's `registerMessages`). Content-derived `key` makes
+ * identical contributions dedup (HMR-idempotent) while distinct ones coexist.
+ *
+ * ```ts
+ * export function registerMessages(messages: Messages): DynamicModule {
+ *   return sideEffectModule('I18nMessages', {
+ *     providers: [{ provide: I18N_MESSAGES, useValue: messages }],
+ *     exports: [I18N_MESSAGES],
+ *   });
+ * }
+ * ```
+ */
+declare function sideEffectModule(name: string, contributions?: Omit<ModuleContributions, 'global'> & {
+  key?: string;
+}): DynamicModule;
+/**
+ * Blessed token-minting convention: always an `InjectionToken` (never a raw
+ * string), named for diagnostics. Namespace it `'<pkg>:<area>:<thing>'`.
+ */
+declare function moduleToken<T>(name: string): InjectionToken<T>;
+//#endregion
+//#region src/entrypoint/execution-scope.d.ts
+/**
+ * Run one unit of non-HTTP work (a queue batch, a scheduled tick, an RPC
+ * call) inside a fresh request-scoped child container — the non-HTTP
+ * equivalent of the per-request child the HTTP pipeline creates:
+ *
+ * ```ts
+ * await runInEntrypointScope(app.getContainer(), async (scope) => {
+ *   const consumer = scope.resolve(ep.token);
+ *   await consumer.process(batch);
+ * });
+ * ```
+ *
+ * Request-scoped providers (and singletons bubbled to request scope) resolve
+ * per invocation instead of leaking one boot-time instance across every
+ * dispatch; the child's request-scoped disposables are disposed (LIFO) when
+ * `fn` settles — success or failure. `REQUEST_CONTEXT` is deliberately NOT
+ * seeded: it is an HTTP primitive, and resolving it here keeps throwing its
+ * explicit misuse error.
+ */
+declare function runInEntrypointScope<T>(container: Container, fn: (scope: Container) => T | Promise<T>): Promise<T>;
+//#endregion
+//#region src/entrypoint/execution-context.d.ts
+/** ExecutionContext flavor handed to components around entrypoint dispatch. */
+interface EntrypointExecutionContext extends ExecutionContext {
+  /** The dispatch payload (queue batch, scheduled event, …). */
+  getPayload<T = unknown>(): T;
+}
+/**
+ * Entrypoint sibling of `buildExecutionContext` (HTTP) and
+ * `buildWsExecutionContext`: lets guards/interceptors/filters written against
+ * `getClass()`/`getHandler()`/`getType()` run unchanged around queue batches,
+ * scheduled ticks, and any custom entrypoint kind. Transport-specific
+ * accessors throw rather than fabricate fakes.
+ */
+declare function buildEntrypointExecutionContext(kind: string, targetClass: Type, handlerName: string | symbol, payload: unknown): EntrypointExecutionContext;
+//#endregion
+//#region src/http/route-contributor.d.ts
+/**
+ * Context passed to {@link RouteContributor.buildRoutes} for each controller
+ * the contributor claims. The contributor receives the framework's resolved
+ * view of the world so generated routes behave identically to hand-written
+ * ones: same global prefix, same global guard instances, same path joining.
+ */
+interface RouteContributorContext {
+  /** The claimed controller class. */
+  controller: Type;
+  /** Controller-level prefix as registered with `@Controller(...)`. */
+  controllerPrefix: string;
+  /** The metadata value (under `claimsMetaKey`) that claimed this controller. */
+  meta: unknown;
+  /** Application-wide path prefix (e.g. `/api`), already normalized. */
+  globalPrefix: string;
+  /** Global guard instances, pre-resolved from the root container. */
+  globalGuards: CanActivate[];
+  /** The app's root container — resolve controller/services from here. */
+  container: Container;
+  /** Path joiner used by the framework — handles slash normalization. */
+  joinPaths: (...parts: string[]) => string;
+}
+/** Context for {@link RouteContributor.buildOpenApiPaths}. */
+interface RouteContributorOpenApiContext {
+  controller: Type;
+  meta: unknown;
+  /** Application-wide path prefix (e.g. `/api`), already normalized. */
+  globalPrefix: string;
+  /** Controller-level prefix as registered with `@Controller(...)`. */
+  controllerPrefix: string;
+}
+/**
+ * A route generator that claims controllers by class-level metadata and
+ * mounts routes for them — the public extension point behind `@Crud()` (and
+ * any future metadata-driven route generator: storage HTTP surfaces, admin
+ * panels, RPC bridges).
+ *
+ * Register once at import time (`registerRouteContributor`); the framework
+ * consults contributors during `RouteManager.build` — AFTER all explicit
+ * `@Get`/`@Post` routes, so generated `/:id` catch-alls never shadow custom
+ * routes — and during OpenAPI document generation.
+ *
+ * This contract exists instead of dynamic `import()` because esbuild leaves
+ * `await import(variable)` as a runtime import Cloudflare Workers cannot
+ * resolve.
+ */
+interface RouteContributor {
+  /** Stable identifier; re-registering the same id overwrites (HMR-friendly). */
+  id: string;
+  /** Class-level metadata key whose presence claims a controller. */
+  claimsMetaKey: string;
+  buildRoutes(app: Hono, ctx: RouteContributorContext): void | Promise<void>;
+  buildOpenApiPaths?(ctx: RouteContributorOpenApiContext): Record<string, OpenApiPathItem>;
+}
+/** Register a contributor. Last registration per `id` wins. */
+declare function registerRouteContributor(contributor: RouteContributor): void;
+/** All registered contributors (registration order). */
+declare function getRouteContributors(): RouteContributor[];
+//#endregion
+//#region src/pipeline/pipeline-runner.d.ts
+interface PipelineRunOptions {
+  context: ExecutionContext;
+  /** Pre-merged (global ++ scoped), pre-instantiated. */
+  guards: CanActivate[];
+  interceptors: NestInterceptor[];
+  /** Extract handler arguments (pipes already bound inside the closure). */
+  resolveArgs: () => Promise<unknown[]>;
+  /** Call the actual handler. */
+  invoke: (args: unknown[]) => Promise<unknown>;
+  /**
+   * HTTP runs argument extraction + pipes BEFORE guards (a deliberate vela
+   * deviation — see handler-executor); WebSocket runs guards first. Default
+   * false (guards first).
+   */
+  argsBeforeGuards?: boolean;
+  /** Error thrown when a guard rejects (default `ForbiddenException`). */
+  onGuardReject?: () => Error;
+}
+/**
+ * The transport-agnostic guard → pipe → interceptor execution core shared by
+ * the HTTP `HandlerExecutor` and the WebSocket `WsDispatcher` (and any future
+ * entrypoint dispatcher: queue consumers, scheduled jobs, …). Exception
+ * FILTERS stay with the caller — their terminal behavior is transport-specific
+ * (HTTP maps to a Response, WS sends an error frame).
+ */
+declare class PipelineRunner {
+  static run(options: PipelineRunOptions): Promise<unknown>;
+  /** Interceptor onion — innermost is the core handler. */
+  static chainInterceptors(interceptors: NestInterceptor[], context: ExecutionContext, coreHandler: () => Promise<unknown>): Promise<unknown>;
+}
+//#endregion
+//#region src/pipeline/scoped-components.d.ts
+interface ResolvedComponentMap {
+  guard: CanActivate;
+  pipe: PipeTransform;
+  interceptor: NestInterceptor;
+  filter: ExceptionFilter;
+  middleware: NestMiddleware;
+}
+/**
+ * Public seam for custom dispatchers: the `@UseGuards`/`@UsePipes`/
+ * `@UseInterceptors`/`@UseFilters` components scoped to a handler (class-level
+ * then method-level, declaration order), resolved to instances through the
+ * given container (classes constructed with DI; instances passed through).
+ *
+ * Order is preserved exactly as declared — conventions stay with the CALLER:
+ * filters run closest-first, so dispatchers reverse them
+ * (`resolveScopedComponents('filter', ...).reverse()`), and app-wide `APP_*`
+ * components are a separate, transport-specific decision.
+ *
+ * Promoted to the public API by the QueueModule work (the "openness proof"):
+ * it was the one capability custom entrypoint dispatchers needed that only
+ * the internal `ComponentManager` provided.
+ */
+declare function resolveScopedComponents<T extends ComponentType>(type: T, targetClass: Constructor, methodName: string | symbol, container: Container): ResolvedComponentMap[T][];
+//#endregion
+//#region src/pipeline/decorators.d.ts
+declare function UseMiddleware(...middleware: ComponentTypeMap['middleware'][]): (target: object, propertyKey?: string | symbol) => void;
+declare function UseGuards(...guards: ComponentTypeMap['guard'][]): (target: object, propertyKey?: string | symbol) => void;
+declare function UsePipes(...pipes: ComponentTypeMap['pipe'][]): (target: object, propertyKey?: string | symbol) => void;
+declare function UseInterceptors(...interceptors: ComponentTypeMap['interceptor'][]): (target: object, propertyKey?: string | symbol) => void;
+declare function UseFilters(...filters: ComponentTypeMap['filter'][]): (target: object, propertyKey?: string | symbol) => void;
+declare function Catch(...exceptions: Type<Error>[]): ClassDecorator;
+declare function getCatchTypes(filter: unknown): Type<Error>[];
+declare function shouldFilterCatch(filter: unknown, exception: unknown): boolean;
+//#endregion
+//#region src/pipeline/reflector.d.ts
+interface CreateDecoratorOptions {
+  key?: string;
+}
+interface ReflectableDecorator<TParam> {
+  (value: TParam): ClassDecorator & MethodDecorator;
+  KEY: string;
+}
+/**
+ * Decorator that attaches custom metadata to a class or method.
+ * Read via Reflector in guards/interceptors.
+ *
+ * @example
+ * ```ts
+ * const Roles = (...roles: string[]) => SetMetadata('roles', roles);
+ *
+ * @Controller('/admin')
+ * @Roles('admin')
+ * class AdminController { ... }
+ * ```
+ */
+declare function SetMetadata<V = unknown>(key: string, value: V): (target: object, propertyKey?: string | symbol) => void;
+/**
+ * Reads custom metadata set by @SetMetadata().
+ * Use in guards/interceptors via ExecutionContext.
+ *
+ * @example
+ * ```ts
+ * class RolesGuard implements CanActivate {
+ *   private reflector = new Reflector();
+ *
+ *   canActivate(context: ExecutionContext): boolean {
+ *     const roles = this.reflector.get<string[]>('roles', context);
+ *     if (!roles) return true;
+ *     const user = ...; // extract from request
+ *     return roles.some(r => user.roles.includes(r));
+ *   }
+ * }
+ * ```
+ */
+declare class Reflector {
+  /**
+   * Create a type-safe decorator that sets metadata with a typed key.
+   *
+   * @example
+   * ```ts
+   * const Roles = Reflector.createDecorator<string[]>();
+   * // Roles(['admin']) — class or method decorator
+   * // reflector.get(Roles, context) — typed as string[] | undefined
+   * ```
+   */
+  static createDecorator<TParam = unknown>(options?: CreateDecoratorOptions): ReflectableDecorator<TParam>;
+  private resolveKey;
+  /**
+   * Get metadata value from handler first, then class.
+   * Handler-level metadata takes priority over class-level.
+   */
+  get<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
+  /**
+   * Get metadata only from the handler (method) level.
+   */
+  getHandler<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
+  /**
+   * Get metadata only from the class level.
+   */
+  getClass<T = unknown>(key: string | ReflectableDecorator<T>, context: Pick<ExecutionContext, 'getClass'>): T | undefined;
+  /**
+   * Get all metadata values for a key from both handler and class.
+   * Returns [handlerValue, classValue] (either may be undefined).
+   */
+  getAll<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): [T | undefined, T | undefined];
+  /**
+   * Returns handler value if defined, else class value, else undefined.
+   * First defined value wins.
+   */
+  getAllAndOverride<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
+  /**
+   * Collects handler + class values, filters undefineds.
+   * - 0 values → []
+   * - 1 value → return it
+   * - Arrays → concatenate
+   * - Objects → Object.assign({}, ...values)
+   * - Otherwise → wrap in array
+   */
+  getAllAndMerge<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | T[];
+}
+//#endregion
+//#region src/pipeline/pipes.d.ts
+declare class ParseIntPipe implements PipeTransform<string, number> {
+  transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseFloatPipe implements PipeTransform<string, number> {
+  transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseBoolPipe implements PipeTransform<string, boolean> {
+  transform(value: string, metadata: ArgumentMetadata): boolean;
+}
+declare class DefaultValuePipe<T = unknown> implements PipeTransform<T | undefined, T> {
+  private readonly defaultValue;
+  constructor(defaultValue: T);
+  transform(value: T | undefined, _metadata: ArgumentMetadata): T;
+}
+declare class RequiredPipe implements PipeTransform {
+  transform(value: unknown, metadata: ArgumentMetadata): unknown;
+}
+declare class ZodValidationPipe implements PipeTransform {
+  private readonly schema;
+  constructor(schema: {
+    parse(data: unknown): unknown;
+  });
+  transform(value: unknown, _metadata: ArgumentMetadata): unknown;
+}
+interface ParseUUIDPipeOptions {
+  version?: '3' | '4' | '5';
+}
+declare class ParseUUIDPipe implements PipeTransform<string, string> {
+  private readonly options?;
+  constructor(options?: ParseUUIDPipeOptions | undefined);
+  transform(value: string, metadata: ArgumentMetadata): string;
+}
+declare class ParseEnumPipe<T extends Record<string, string | number>> implements PipeTransform<string, T[keyof T]> {
+  private readonly allowedValues;
+  private readonly valuesLabel;
+  constructor(enumType: T);
+  transform(value: string, metadata: ArgumentMetadata): T[keyof T];
+}
+interface ParseArrayPipeOptions {
+  separator?: string;
+  optional?: boolean;
+}
+declare class ParseArrayPipe implements PipeTransform {
+  private readonly options?;
+  constructor(options?: ParseArrayPipeOptions | undefined);
+  transform(value: unknown, metadata: ArgumentMetadata): unknown[];
+}
+//#endregion
+//#region src/errors/http-exception.d.ts
+type ExceptionResponse = string | Record<string, unknown>;
+declare class HttpException extends Error {
+  readonly statusCode: number;
+  private readonly _response;
+  constructor(response: ExceptionResponse, statusCode: number);
+  getStatus(): number;
+  getResponse(): Record<string, unknown>;
+  getRawResponse(): ExceptionResponse;
+}
+declare class BadRequestException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class UnauthorizedException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class ForbiddenException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class NotFoundException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class MethodNotAllowedException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class NotAcceptableException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class RequestTimeoutException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class ConflictException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class GoneException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class PayloadTooLargeException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class UnsupportedMediaTypeException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class UnprocessableEntityException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class TooManyRequestsException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class InternalServerErrorException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class NotImplementedException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class BadGatewayException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class ServiceUnavailableException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+declare class GatewayTimeoutException extends HttpException {
+  constructor(message?: ExceptionResponse);
+}
+//#endregion
+//#region src/exceptions/errors.module.d.ts
+/**
+ * Options for {@link ErrorsModule.forRoot}. Both fields are optional — an empty
+ * `forRoot()` provides just the core catalog (`CORE_CATALOG`) and no custom
+ * handler, which is the framework default anyway.
+ */
+interface ErrorsModuleOptions {
+  /**
+   * App-specific catalogs composed **onto** `CORE_CATALOG` via
+   * {@link composeCatalogs}. Composition is eager (at `forRoot` call time), so a
+   * duplicate code across two catalogs fails fast with `duplicate error code`.
+   */
+  catalogs?: Catalog<string>[];
+  /**
+   * The application-wide {@link ExceptionHandler}. A class is wired with
+   * `useClass` (constructed through DI); a plain handler object with `useValue`.
+   */
+  handler?: Type<ExceptionHandler> | ExceptionHandler;
+}
+declare const ConfigurableModuleClass: ConfigurableModuleClassType<ErrorsModuleOptions, "forRoot", "create", {
+  isGlobal?: boolean;
+}>;
+/**
+ * Registers the application-wide error surface: the composed
+ * {@link ERROR_CATALOG} that every transport edge redacts against, and an
+ * optional {@link APP_EXCEPTION_HANDLER}. The imperative sibling is
+ * `app.useGlobalExceptionHandler(handler)`.
+ *
+ * ```ts
+ * @Module({
+ *   imports: [ErrorsModule.forRoot({ catalogs: [ordersCatalog], handler: SentryHandler })],
+ * })
+ * class AppModule {}
+ * ```
+ */
+declare class ErrorsModule extends ConfigurableModuleClass {}
+//#endregion
+//#region src/exceptions/reporter.d.ts
+/**
+ * The resolved reporting facade every transport edge (HTTP, WS, live, queue,
+ * schedule) uses. `report` is fire-and-forget and fully contained — a broken
+ * or throwing handler can never mask the original error. `render` gives a
+ * handler the chance to override the client-bound response.
+ */
+interface ErrorReporter {
+  catalog: Catalog<string>;
+  report(error: unknown, ctx: ErrorReportContext): void;
+  render(error: unknown, executionCtx: unknown): Response | ErrorBodyResult | undefined;
+}
+/**
+ * Build an {@link ErrorReporter} from a container. Reads the optional
+ * {@link APP_EXCEPTION_HANDLER} and {@link ERROR_CATALOG} providers; with
+ * neither registered the reporter logs (unless diagnostics is `'silent'`) and
+ * exposes the core catalog.
+ */
+declare const resolveErrorReporter: (container: Container) => ErrorReporter;
+//#endregion
+//#region src/validation/create-zod-dto.d.ts
+interface ZodLikeSchema {
+  parse(data: unknown): unknown;
+}
+type InferOutput<T extends ZodLikeSchema> = ReturnType<T['parse']>;
+interface CreateZodDtoOptions {
+  /** Override the generated class name (useful for debugging and OpenAPI). */
+  name?: string;
+}
+declare function createZodDto<T extends ZodLikeSchema>(schema: T, options?: CreateZodDtoOptions): {
+  new (initial?: InferOutput<T>): InferOutput<T>;
+  schema: T;
+};
+//#endregion
+//#region src/validation/validation.pipe.d.ts
+declare class ValidationPipe implements PipeTransform {
+  transform(value: unknown, metadata: ArgumentMetadata): unknown;
+}
+//#endregion
+//#region src/serialization/serialize.decorator.d.ts
+declare const SERIALIZE_METADATA = "vela:serialize";
+declare function Serialize(dto: {
+  schema: {
+    parse(data: unknown): unknown;
+  };
+}): MethodDecorator;
+//#endregion
+//#region src/serialization/serializer.interceptor.d.ts
+declare class SerializerInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}
+//#endregion
+export { CreateDecoratorOptions as $, Sse as $i, WebSocketGatewayOptions as $n, ConfigModuleOptions as $r, ThrottlerGuard as $t, InternalServerErrorException as A, All as Ai, WsServerImpl as An, CacheService as Ar, ModuleContributions as At, UnprocessableEntityException as B, HttpCode as Bi, MessageBody as Bn, CorsOptions as Br, ConfigurableModuleExtras as Bt, BadGatewayException as C, SignedUrlGenerateOptions as Ci, WS_SYNC_DRIVER as Cn, CACHE_MODULE_OPTIONS as Cr, LazyProviderSpec as Ct, GatewayTimeoutException as D, RouteParams as Di, toErrorFrame as Dn, TieredCacheStore as Dr, sideEffectModule as Dt, ForbiddenException as E, RouteName as Ei, WsException as En, CacheTTL as Er, provideGlobal as Et, PayloadTooLargeException as F, Delete as Fi, InMemoryRoomRegistry as Fn, CacheEntry as Fr, defineConfigurableModule as Ft, ParseBoolPipe as G, Post as Gi, BroadcastCommand as Gn, HttpModuleOptions as Gr, stableHash as Gt, DefaultValuePipe as H, Options as Hi, SubscribeMessage as Hn, HttpRequestException as Hr, ConfigurableModuleHost as Ht, RequestTimeoutException as I, Get as Ii, RoomRegistry as In, CacheModuleOptions as Ir, moduleKey as It, ParseIntPipe as J, RawBody as Ji, OnGatewayDisconnect as Jn, CONFIG_ENV as Jr, THROTTLER_STORAGE as Jt, ParseEnumPipe as K, Put as Ki, BroadcastOperator as Kn, HttpRequestConfig as Kr, SKIP_THROTTLE_METADATA as Kt, ServiceUnavailableException as L, Head as Li, SyncDriver as Ln, CacheStore as Lr, ConfigurableModuleAsyncOptions as Lt, NotAcceptableException as M, Controller as Mi, WsEntrypointMeta as Mn, AnyCacheStore as Mr, buildAsyncOptionsProviders as Mt, NotFoundException as N, Cookie as Ni, WebSocketModule as Nn, AsyncCacheStore as Nr, defineModule as Nt, GoneException as O, VelaRouteMap as Oi, buildWsExecutionContext as On, MemoryCacheStore as Or, DefineModuleSpec as Ot, NotImplementedException as P, Cookies as Pi, WebSocketModuleOptions as Pn, Awaitable as Pr, ConfigurableModuleBuilder as Pt, ZodValidationPipe as Q, RouteOptions as Qi, SubscribeMessageMetadata as Qn, ConfigModule as Qr, ThrottlerStorage as Qt, TooManyRequestsException as R, Header as Ri, local as Rn, CORS_OPTIONS as Rr, ConfigurableModuleBuilderOptions as Rt, ErrorsModuleOptions as S, SignedUrlGuard as Si, WS_SUBSCRIBE_METADATA as Sn, CACHE_MANAGER as Sr, runInEntrypointScope as St, ConflictException as T, UrlGeneratorService as Ti, resolveWsArgs as Tn, CacheKey as Tr, moduleToken as Tt, ParseArrayPipe as U, Param as Ui, WebSocketGateway as Un, HttpService as Ur, ConfigurableModuleOptionsFactory as Ut, UnsupportedMediaTypeException as V, Ip as Vi, ReservedWsEvent as Vn, HTTP_MODULE_OPTIONS as Vr, ConfigurableModuleExtrasTransform as Vt, ParseArrayPipeOptions as W, Patch as Wi, WebSocketServer as Wn, HttpModule as Wr, DefineConfigurableModuleSpec as Wt, ParseUUIDPipeOptions as X, Req as Xi, ReservedWsEventHandler as Xn, ConfigService as Xr, SkipThrottle as Xt, ParseUUIDPipe as Y, Redirect as Yi, OnGatewayInit as Yn, CONFIG_OPTIONS as Yr, THROTTLE_METADATA as Yt, RequiredPipe as Z, Res as Zi, ReservedWsEventMetadata as Zn, ConfigStore as Zr, Throttle as Zt, CreateZodDtoOptions as _, getCurrentRequestContext as _i, WS_GATEWAY_METADATA as _n, EventEmitter as _r, RouteContributorOpenApiContext as _t, VelaError as a, Injectable as aa, ConfigType as ai, ThrottlerStore as an, CronMatcher as ar, UseGuards as at, resolveErrorReporter as b, URL_SIGNING_SECRET as bi, WS_ROOM_REGISTRY as bn, EventEmitterModule as br, EntrypointExecutionContext as bt, defineErrorCatalog as c, ApiDoc as ca, ContextProvider as ci, HealthIndicatorService as cn, IntervalMetadata as cr, UsePipes as ct, isVelaError$1 as d, createOpenApiDocument as da, LoggerLevelName as di, HealthCheckStatus as dn, Cron as dr, ResolvedComponentMap as dt, Version as ea, ConfigPath as ei, ThrottlerModule as en, WsClient as er, ReflectableDecorator as et, toErrorBody$1 as f, VelaCreateOptions as fa, LoggerService as fi, HealthIndicatorFunction as fn, Interval as fr, resolveScopedComponents as ft, ValidationPipe as g, getCurrentContainer as gi, RESERVED_WS_EVENT_PREFIX as gn, EventEmitterSubscriber as gr, RouteContributorContext as gt, Serialize as h, RuntimeAdapter as ha, enableAmbientContainer as hi, HealthModule as hn, OnEvent as hr, RouteContributor as ht, ErrorCatalogEntry as i, Inject as ia, ConfigNamespace as ii, ThrottlerStorageRecord as in, WsServer as ir, UseFilters as it, MethodNotAllowedException as j, Body as ji, WsDispatcher as jn, CacheModule as jr, ModuleSetupContext as jt, HttpException as k, createLazyParamDecorator as ki, BroadcastOperatorImpl as kn, CacheInterceptor as kr, GlobalComponentSlot as kt, env as l, ApiResponse as la, LogLevel as li, HealthCheckService as ln, CRON_METADATA as lr, getCatchTypes as lt, SERIALIZE_METADATA as m, AdapterContext as ma, getRequestContainer as mi, ResponseCheckCallback as mn, ON_EVENT_METADATA as mr, PipelineRunner as mt, Catalog$1 as n, createParamDecorator as na, ConfigSchema as ni, ThrottleConfig as nn, WsMessage as nr, SetMetadata as nt, VelaErrorOptions as o, Optional as oa, InferConfigType as oi, HttpHealthIndicator as on, parseCron as or, UseInterceptors as ot, SerializerInterceptor as p, VelaFactory as pa, Writer as pi, HealthIndicatorResult as pn, ScheduleModule as pr, PipelineRunOptions as pt, ParseFloatPipe as q, Query as qi, OnGatewayConnection as qn, HttpResponse as qr, THROTTLER_OPTIONS as qt, ErrorBodyResult$1 as r, mixin as ra, AnyConfigNamespace as ri, ThrottlerModuleOptions as rn, WsResponse as rr, Catch as rt, composeCatalogs$1 as s, zodToJsonSchema as sa, registerAs as si, HttpPingOptions as sn, CronMetadata as sr, UseMiddleware as st, CORE_CATALOG$1 as t, applyDecorators as ta, ConfigPathValue as ti, RateLimitInfo as tn, WsExecutionContext as tr, Reflector as tt, getRuntimeKey as u, ApiTags as ua, Logger as ui, HealthCheckResult as un, INTERVAL_METADATA as ur, shouldFilterCatch as ut, createZodDto as v, REQUEST_CONTEXT as vi, WS_MODULE_OPTIONS as vn, EventHandler as vr, getRouteContributors as vt, BadRequestException as w, UrlForOptions as wi, WsParamType as wn, CACHE_TTL_METADATA as wr, lazyProvider as wt, ErrorsModule as x, SignedUrl as xi, WS_SERVER as xn, CACHE_KEY_METADATA as xr, buildEntrypointExecutionContext as xt, ErrorReporter as y, RequestContext as yi, WS_RESERVED_METADATA as yn, OnEventMetadata as yr, registerRouteContributor as yt, UnauthorizedException as z, Headers$1 as zi, ConnectedSocket as zn, CorsModule as zr, ConfigurableModuleClassType as zt };
+//# sourceMappingURL=index-DhShDLCM.d.ts.map