@velajs/vela 1.19.0 → 1.19.1

package/dist/metadata.registry-D1od8ZBt.d.ts

@@ -0,0 +1,842 @@
+import { A as NestInterceptor, C as RouteDefinition, D as ExceptionFilter, E as CanActivate, F as Constructor, L as Diagnostics, M as PipeTransform, O as ExecutionContext, P as Container, S as PipeType, U as InjectionToken, V as InjectMetadata, X as Token, Z as Type, _ as MiddlewareType, b as ModuleOptions, d as ComponentTypeMap, et as HttpMethod, f as DynamicModule, g as InterceptorType, h as HttpHandlerMeta, i as DiscoveryService, j as NestMiddleware, m as GuardType, p as FilterType, rt as Scope, u as ComponentType, w as ArgumentMetadata, x as ParameterMetadata, y as ModuleMetadata } from "./discovery.service-Cpf1QcZ5.js";
+import { Catalog, ErrorBodyResult } from "@velajs/errors";
+import { Context, Hono, MiddlewareHandler } from "hono";
+//#region src/exceptions/exception-handler.d.ts
+/**
+ * A predicate for classifying an error, used by {@link ExceptionHandler.dontReport}.
+ *
+ * Three shapes are accepted:
+ * - `string` — a Vela error code; matches when the error is a branded
+ *   `VelaError` whose `code` equals the string.
+ * - a predicate `(error: unknown) => boolean` — **must be an arrow function**.
+ *   A class and a predicate are both `typeof 'function'`; {@link matchesAny}
+ *   discriminates on `prototype`, which arrow functions do not have.
+ * - an error class constructor — matches via `instanceof`.
+ *
+ * Bound functions (e.g. `SomeClass.bind(null)`) also lack `.prototype`, so they
+ * are treated as predicates and invoked — never as class matchers. Since a bound
+ * constructor cannot be called without `new`, using one here throws; pass the
+ * unbound class instead.
+ */
+type ErrorMatcher = string | ((error: unknown) => boolean) | (new (...args: never[]) => Error);
+/**
+ * Ambient context handed to every reporting/rendering hook. `edge` names the
+ * transport that caught the error; open-ended extra keys (via the index
+ * signature) let a handler's `context()` enrich the payload.
+ */
+interface ErrorReportContext {
+  edge: 'http' | 'ws' | 'live' | 'queue' | 'schedule' | 'hono';
+  /** e.g. `'CatsController.findAll'` or a query name. */
+  source?: string;
+  /** e.g. `'exception filter threw'`. */
+  note?: string;
+  [key: string]: unknown;
+}
+/**
+ * The application-wide exception handler contract. Provide an implementation
+ * under {@link APP_EXCEPTION_HANDLER} to customize how errors are reported and
+ * rendered. Every member is optional — an empty object is a valid handler.
+ */
+interface ExceptionHandler {
+  /** Fire-and-forget reporting (logging, Sentry, …). May be async. */
+  report?(error: unknown, ctx: ErrorReportContext): void | Promise<void>;
+  /** Errors matching any of these are never reported. */
+  dontReport?: ErrorMatcher[];
+  /** Extra fields merged into the report context. Must be side-effect free. */
+  context?(error: unknown, ctx: ErrorReportContext): Record<string, unknown>;
+  /** Override the client-bound response for an error. */
+  render?(error: unknown, ctx: unknown): Response | ErrorBodyResult | undefined;
+}
+/**
+ * True when `error` matches any of `matchers`. A string matches a branded
+ * {@link VelaError} by `code`; an arrow-function predicate is called; anything
+ * else with a `prototype` is treated as an error class and matched via
+ * `instanceof`. Predicates therefore MUST be arrow functions — a regular
+ * `function` expression has a `prototype` and would be mistaken for a class.
+ * Bound functions (e.g. `SomeClass.bind(null)`) lack `.prototype` too, so they
+ * are invoked as predicates — don't pass a bound class as a class matcher.
+ */
+declare const matchesAny: (matchers: ErrorMatcher[] | undefined, error: unknown) => boolean;
+//#endregion
+//#region src/entrypoint/entrypoint.types.d.ts
+/**
+ * A declared entrypoint kind: a named category of non-HTTP (or non-standard)
+ * entry surface that some module knows how to dispatch — WebSocket gateways,
+ * queue consumers, scheduled jobs, CLI commands. Core ships NO fixed set;
+ * any module registers its own kind and any runtime adapter can query it.
+ *
+ * `metaKey` binds the kind to a decorator's metadata key: every provider
+ * carrying that metadata becomes an entrypoint of this kind at bootstrap.
+ */
+interface EntrypointKind {
+  kind: string;
+  metaKey: string;
+  /**
+   * 'class': one entrypoint per decorated provider (`@WebSocketGateway`).
+   * 'method': one entrypoint per decorated method (`@Cron`, `@QueueConsumer`
+   * handler methods) — flattened from the class-level list convention.
+   */
+  level: 'class' | 'method';
+}
+/** One concrete entrypoint discovered at bootstrap. */
+interface Entrypoint<M = unknown> {
+  kind: string;
+  token: Token;
+  /** The resolved provider backing the entrypoint (undefined if request-scoped). */
+  instance: unknown;
+  /** Present for method-level kinds. */
+  methodName?: string | symbol;
+  meta: M;
+}
+/**
+ * Escape hatch for providers whose entrypoints are computed rather than purely
+ * decorator-declared (e.g. `WsDispatcher` aggregates per-gateway routing state
+ * before contributing). Implementers are detected among the app's eagerly
+ * instantiated providers after `onApplicationBootstrap` hooks have run.
+ */
+interface ContributesEntrypoints {
+  collectEntrypoints(discovery: DiscoveryService): Entrypoint[] | Promise<Entrypoint[]>;
+}
+declare function contributesEntrypoints(x: unknown): x is ContributesEntrypoints;
+//#endregion
+//#region src/entrypoint/entrypoint.registry.d.ts
+/**
+ * Declare an entrypoint kind. Idempotent per `kind` (last declaration wins so
+ * an HMR-re-evaluated module can re-declare); typically called at module
+ * import time next to the decorator definition:
+ *
+ * ```ts
+ * export const WS_GATEWAY_METADATA = 'vela:ws:gateway';
+ * registerEntrypointKind({ kind: 'websocket', metaKey: WS_GATEWAY_METADATA, level: 'class' });
+ * ```
+ */
+declare function registerEntrypointKind(k: EntrypointKind): void;
+/** All declared kinds (registration order). */
+declare function getEntrypointKinds(): EntrypointKind[];
+/**
+ * The per-application view of every entrypoint: built once after
+ * `onApplicationBootstrap` hooks have run (so `ContributesEntrypoints`
+ * providers have finished their own discovery), queried by runtime adapters:
+ *
+ * ```ts
+ * for (const ep of app.entrypoints.ofKind('websocket')) { ... }
+ * ```
+ *
+ * Per-app (never global): two applications in one process each build their
+ * own registry from their own container.
+ */
+declare class EntrypointRegistry {
+  private readonly byKind;
+  static build(discovery: DiscoveryService, eagerInstances: readonly unknown[], options?: {
+    deferLazy?: boolean;
+  }): Promise<EntrypointRegistry>;
+  private add;
+  ofKind<M = unknown>(kind: string): Entrypoint<M>[];
+  kinds(): string[];
+  all(): Entrypoint[];
+}
+//#endregion
+//#region src/module/middleware.d.ts
+interface RouteInfo {
+  path: string;
+  method?: HttpMethod;
+}
+interface MiddlewareRouteDefinition {
+  middleware: Array<Type<NestMiddleware> | NestMiddleware>;
+  routes: RouteInfo[];
+  excludes: RouteInfo[];
+  /** Stable-sort key; lower runs first. Default 0. */
+  priority?: number;
+}
+interface MiddlewareConfigProxy {
+  exclude(...routes: Array<string | RouteInfo>): MiddlewareConfigProxy;
+  withPriority(priority: number): MiddlewareConfigProxy;
+  forRoutes(...routes: Array<string | Constructor | RouteInfo>): MiddlewareConsumer;
+}
+interface MiddlewareConsumer {
+  apply(...middleware: Array<Type<NestMiddleware> | NestMiddleware>): MiddlewareConfigProxy;
+}
+interface NestModule {
+  configure(consumer: MiddlewareConsumer): void;
+}
+//#endregion
+//#region src/http/types.d.ts
+interface RouteMetadata {
+  method: HttpMethod;
+  path: string;
+  handlerName: string | symbol;
+  version?: number | number[];
+  /** Route name for URL generation / OpenAPI operationId (`@Get(path, { name })`). */
+  name?: string;
+}
+interface ControllerOptions$1 {
+  path?: string;
+  version?: number | number[];
+}
+interface ControllerMetadata {
+  prefix: string;
+  version?: number | number[];
+}
+interface ControllerRegistration {
+  controller: Type;
+  metadata: ControllerMetadata;
+  routes: RouteMetadata[];
+}
+//#endregion
+//#region src/http/route.manager.d.ts
+/**
+ * One explicit controller route as the framework registered it — recorded by
+ * `build()` with the SAME composed path handed to Hono (global prefix +
+ * version segment + controller prefix + route path), so introspection tooling
+ * (`vela route list`) never re-derives composition. Contributed routes
+ * (`RouteContributor`, e.g. `@velajs/crud`) mount directly on the Hono app
+ * and are not described here — diff `app.getHonoApp().routes` for those.
+ */
+interface RouteDescription {
+  /** As declared on the handler — `@Head()` reports HEAD (Hono serves it under GET). */
+  method: string;
+  /** Fully composed path exactly as registered. */
+  path: string;
+  controller: string;
+  handler: string;
+  version?: number;
+  /** Route name (`@Get(path, { name })`) — the URL-generation / `operationId` key. */
+  name?: string;
+}
+interface RouteManagerOptions {
+  getClientIp?: (c: Context) => string | null;
+  middleware?: MiddlewareHandler[];
+  globalPrefix?: string;
+  /**
+   * Opt into ambient request-container access (`getCurrentContainer()` /
+   * `getCurrentRequestContext()`). Registers Hono's `contextStorage()` as the
+   * first middleware. Off by default — the explicit child container is unchanged.
+   */
+  ambientContainer?: boolean;
+}
+declare class RouteManager {
+  private container;
+  private static readonly METHOD_REGISTRAR;
+  private controllers;
+  private globalMiddleware;
+  private globalPipes;
+  private globalGuards;
+  private globalInterceptors;
+  private globalFilters;
+  private globalPrefix;
+  private consumerMiddlewareDefinitions;
+  private routeDescriptions;
+  private readonly handlerExecutor;
+  private readonly ambientContainer;
+  constructor(container: Container, options?: RouteManagerOptions);
+  /**
+   * The global-tier components (`APP_*` provider tokens + imperative
+   * `app.useGlobalX()` instances). Exposed so non-HTTP transports (the
+   * WebSocket dispatcher) can apply the same app-wide guards/pipes/interceptors/
+   * filters as HTTP routes, read live so late registrations propagate.
+   */
+  getGlobalComponents(): {
+    guards: Array<GuardType | Token<CanActivate>>;
+    pipes: Array<PipeType | Token<PipeTransform>>;
+    interceptors: Array<InterceptorType | Token<NestInterceptor>>;
+    filters: Array<FilterType | Token<ExceptionFilter>>;
+  };
+  registerConsumerMiddleware(definitions: MiddlewareRouteDefinition[]): this;
+  setGlobalPrefix(prefix: string): this;
+  useGlobalMiddleware(...middleware: MiddlewareType[]): this;
+  useGlobalMiddlewareTokens(...middlewareTokens: Array<Token<NestMiddleware>>): this;
+  useGlobalPipes(...pipes: PipeType[]): this;
+  useGlobalPipeTokens(...pipeTokens: Array<Token<PipeTransform>>): this;
+  useGlobalGuards(...guards: GuardType[]): this;
+  useGlobalGuardTokens(...guardTokens: Array<Token<CanActivate>>): this;
+  useGlobalInterceptors(...interceptors: InterceptorType[]): this;
+  useGlobalInterceptorTokens(...interceptorTokens: Array<Token<NestInterceptor>>): this;
+  useGlobalFilters(...filters: FilterType[]): this;
+  useGlobalFilterTokens(...filterTokens: Array<Token<ExceptionFilter>>): this;
+  private getMiddlewarePriority;
+  private getRequestContainer;
+  private wrapMiddlewareWithFilters;
+  private mapMiddlewareError;
+  registerController(controller: Type): this;
+  /** The explicit controller routes recorded by the last `build()`. */
+  getRouteDescriptions(): RouteDescription[];
+  /** The global prefix in effect (set at bootstrap; '' when none). */
+  getGlobalPrefix(): string;
+  build(): Promise<Hono>;
+  private registerRoute;
+  private buildVersionedPaths;
+  private compilePathMatcher;
+  private compileRouteMatcher;
+  getControllers(): ControllerRegistration[];
+}
+//#endregion
+//#region src/openapi/types.d.ts
+interface OpenApiInfo {
+  title: string;
+  version: string;
+  description?: string;
+}
+interface JsonSchema {
+  type?: string | string[];
+  format?: string;
+  enum?: Array<string | number | boolean | null>;
+  const?: unknown;
+  description?: string;
+  nullable?: boolean;
+  default?: unknown;
+  items?: JsonSchema;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  additionalProperties?: boolean | JsonSchema;
+  oneOf?: JsonSchema[];
+  anyOf?: JsonSchema[];
+  allOf?: JsonSchema[];
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  $ref?: string;
+  [key: string]: unknown;
+}
+interface OpenApiParameter {
+  name: string;
+  in: 'path' | 'query' | 'header' | 'cookie';
+  required?: boolean;
+  description?: string;
+  schema?: JsonSchema;
+}
+interface OpenApiRequestBody {
+  description?: string;
+  required?: boolean;
+  content?: Record<string, {
+    schema: JsonSchema;
+  }>;
+}
+interface OpenApiResponse {
+  description: string;
+  content?: Record<string, {
+    schema: JsonSchema;
+  }>;
+}
+/**
+ * A single security requirement: maps a securityScheme name to the scopes it
+ * requires (empty array for apiKey/http schemes). An operation- or document-
+ * level array is an OR of these objects. Kept as a plain record so callers can
+ * build them inline (`{ cookieAuth: [] }`).
+ */
+type OpenApiSecurityRequirement = Record<string, string[]>;
+interface OpenApiOperation {
+  summary?: string;
+  description?: string;
+  operationId?: string;
+  deprecated?: boolean;
+  tags?: string[];
+  parameters?: OpenApiParameter[];
+  requestBody?: OpenApiRequestBody;
+  responses: Record<string, OpenApiResponse>;
+  /** Per-operation security requirements (overrides the document-level array). */
+  security?: OpenApiSecurityRequirement[];
+}
+/** An OpenAPI Server Object. Kept loose so callers can add `variables`. */
+interface OpenApiServer {
+  url: string;
+  description?: string;
+  variables?: Record<string, {
+    enum?: string[];
+    default: string;
+    description?: string;
+  }>;
+  [key: string]: unknown;
+}
+/**
+ * An OpenAPI Security Scheme Object (apiKey / http / oauth2 / openIdConnect /
+ * mutualTLS). Index signature keeps it open so any valid scheme shape passes
+ * without fighting the types (mirrors JsonSchema above).
+ */
+interface OpenApiSecurityScheme {
+  type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect' | 'mutualTLS';
+  description?: string;
+  name?: string;
+  in?: 'query' | 'header' | 'cookie';
+  scheme?: string;
+  bearerFormat?: string;
+  flows?: Record<string, unknown>;
+  openIdConnectUrl?: string;
+  [key: string]: unknown;
+}
+type HttpVerb = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options' | 'head';
+type OpenApiPathItem = { [verb in HttpVerb]?: OpenApiOperation; };
+interface OpenApiDocument {
+  openapi: '3.1.0';
+  info: OpenApiInfo;
+  servers?: OpenApiServer[];
+  paths: Record<string, OpenApiPathItem>;
+  components?: {
+    schemas?: Record<string, JsonSchema>;
+    securitySchemes?: Record<string, OpenApiSecurityScheme>;
+  };
+  security?: OpenApiSecurityRequirement[];
+  tags?: Array<{
+    name: string;
+    description?: string;
+  }>;
+}
+interface ApiDocMetadata {
+  summary?: string;
+  description?: string;
+  operationId?: string;
+  deprecated?: boolean;
+  tags?: string[];
+}
+interface ApiResponseOptions {
+  description: string;
+  /** Zod schema, DTO class (from createZodDto), or raw JSON Schema. */
+  schema?: unknown;
+}
+interface ApiResponseEntry extends ApiResponseOptions {
+  status: number | string;
+}
+interface CreateOpenApiDocumentOptions {
+  info?: Partial<OpenApiInfo>;
+  globalPrefix?: string;
+  /**
+   * Declare top-level tag groups with descriptions and an explicit order
+   * (mirrors NestJS `DocumentBuilder().addTag(name, description)`). Tags
+   * actually used by operations but NOT declared here are still emitted —
+   * appended after the declared ones in first-seen order. Declared tags
+   * with no operations are kept (lets you pre-declare ordering/description).
+   */
+  tags?: Array<{
+    name: string;
+    description?: string;
+  }>;
+  /**
+   * Top-level `servers` array (base URLs the API is served from). Emitted
+   * verbatim between `info` and `paths` when non-empty; omitted otherwise.
+   */
+  servers?: OpenApiServer[];
+  /**
+   * Named security schemes, emitted under `components.securitySchemes` (merged
+   * with generated `components.schemas`). Reference them from `security`.
+   */
+  securitySchemes?: Record<string, OpenApiSecurityScheme>;
+  /**
+   * Document-level default security requirements (applies to every operation
+   * unless the operation overrides it). Emitted verbatim when non-empty.
+   */
+  security?: OpenApiSecurityRequirement[];
+}
+type OpenApiUi = 'swagger' | 'scalar' | 'redoc';
+interface MountOpenApiOptions {
+  /** Pre-built OpenAPI document to serve. */
+  document: OpenApiDocument;
+  /** OpenAPI JSON spec path. @default '/openapi.json' */
+  specPath?: string;
+  /**
+   * UI(s) to mount. 'all' mounts swagger + scalar + redoc.
+   * @default 'scalar'
+   */
+  ui?: OpenApiUi | OpenApiUi[] | 'all';
+  /** Swagger UI path. @default '/docs' */
+  swaggerPath?: string;
+  /** Scalar path. @default '/scalar' */
+  scalarPath?: string;
+  /** ReDoc path. @default '/redoc' */
+  redocPath?: string;
+  /** Page title for the UIs. */
+  title?: string;
+  /** @deprecated use `specPath`. Back-compat alias; if set, overrides specPath default. */
+  path?: string;
+  /** @deprecated single-UI path override; applies to the single `ui` when a string. */
+  uiPath?: string;
+}
+//#endregion
+//#region src/application.d.ts
+declare class VelaApplication {
+  private readonly container;
+  private readonly routeManager;
+  private instances;
+  private honoApp;
+  private entrypointRegistry;
+  private disposed;
+  private readonly lazyManager;
+  private readonly knownInstances;
+  constructor(container: Container, routeManager: RouteManager);
+  private trackNew;
+  /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */
+  initRoutes(): Promise<void>;
+  private getApp;
+  get fetch(): Hono['fetch'];
+  getInstances(): unknown[];
+  getContainer(): Container;
+  setInstances(instances: unknown[]): void;
+  get<T>(token: Token<T>): T;
+  getHonoApp(): Hono;
+  /**
+   * Every explicit controller route as the framework registered it (fully
+   * composed paths — the `vela route list` seam). Requires built routes;
+   * contributed routes (`@velajs/crud`) mount directly on Hono and are
+   * observable via `getHonoApp().routes` instead.
+   */
+  describeRoutes(): RouteDescription[];
+  /** The global route prefix in effect ('' when none). */
+  getGlobalPrefix(): string;
+  useGlobalPipes(...pipes: PipeType[]): this;
+  useGlobalGuards(...guards: GuardType[]): this;
+  useGlobalInterceptors(...interceptors: InterceptorType[]): this;
+  useGlobalFilters(...filters: FilterType[]): this;
+  /**
+   * Register the application-wide {@link ExceptionHandler} imperatively — the
+   * sibling of `ErrorsModule.forRoot({ handler })`. A class is constructed
+   * through DI (`useClass`); a plain handler object is registered verbatim
+   * (`useValue`). Consumed by `resolveErrorReporter` at every transport edge,
+   * so it takes effect on the next request without a rebuild.
+   *
+   * ```ts
+   * app.useGlobalExceptionHandler({ report: (e) => sentry.capture(e) });
+   * ```
+   */
+  useGlobalExceptionHandler(handler: Type<ExceptionHandler> | ExceptionHandler): this;
+  /**
+   * Serve a pre-built OpenAPI document and one or more interactive doc UIs
+   * (Swagger UI, Scalar, ReDoc) on the underlying Hono app, mirroring the
+   * hono-crud docs convention. Edge-safe: each UI is a tiny self-contained
+   * HTML shell that loads its renderer from a CDN at runtime so nothing is
+   * bundled server-side and no extra dependency is required.
+   *
+   * Defaults: spec at `/openapi.json`, Scalar at `/scalar`, Swagger UI at
+   * `/docs`, ReDoc at `/redoc`. The deprecated `path` / `uiPath` aliases are
+   * retained for migration from the previous single-UI shape.
+   *
+   * ```ts
+   * const doc = createOpenApiDocument(AppModule);
+   * app.mountOpenApi({ document: doc });            // Scalar @ /scalar
+   * app.mountOpenApi({ document: doc, ui: 'all' }); // swagger + scalar + redoc
+   * ```
+   */
+  mountOpenApi(options: MountOpenApiOptions): this;
+  /**
+   * Pull instances materialized during the bootstrap phase (lazy modules
+   * dragged in by eager consumers) into the front of the instance list —
+   * dependency-before-consumer: a group absorbed because an eager provider
+   * injected it must be initialized before that consumer's hooks read it.
+   */
+  private absorbLazyInstances;
+  callOnModuleInit(): Promise<void>;
+  callOnApplicationBootstrap(): Promise<void>;
+  /**
+   * Materialize every still-pending lazy module (async-safe): construct the
+   * groups, replay their lifecycle hooks, and add their instances to the
+   * shutdown flow. Warmup escape hatch for tests and node runtimes that want
+   * eager-everything semantics back after bootstrap.
+   */
+  materializeLazyModules(): Promise<void>;
+  /**
+   * Every entrypoint contributed by the module graph, grouped by kind —
+   * what runtime adapters/transports query instead of re-scanning providers:
+   * `app.entrypoints.ofKind('websocket')`.
+   */
+  get entrypoints(): EntrypointRegistry;
+  close(signal?: string): Promise<void>;
+  /**
+   * Full teardown: run shutdown lifecycle hooks ({@link close}) then dispose
+   * container-held instances (LIFO) and clear cached singletons. Use for
+   * graceful shutdown and dev HMR so old and new DI graphs never coexist.
+   *
+   * On runtimes/TS supporting explicit resource management this is also exposed
+   * as `Symbol.asyncDispose`, enabling `await using app = await VelaFactory.create(...)`.
+   */
+  dispose(signal?: string): Promise<void>;
+}
+//#endregion
+//#region src/module/module-loader.d.ts
+/** What the loader records per lazy module instance (see LazyModuleManager). */
+interface LazyModuleGroupSpec {
+  moduleId: string;
+  tokens: Token[];
+  hasEntrypointContributor: boolean;
+}
+declare class ModuleLoader {
+  private container;
+  private router;
+  private processedModules;
+  private processingStack;
+  private collectedControllers;
+  private registeredProviders;
+  private moduleExportsCache;
+  private globalExports;
+  private consumerMiddlewareDefinitions;
+  private appProviderCounter;
+  private appProviderTokens;
+  private moduleIdByClassKey;
+  private seenModuleIds;
+  private lazyModuleIds;
+  private lazyGroups;
+  constructor(container: Container, router: RouteManager);
+  load(rootModule: Type): void;
+  private getModuleId;
+  private isProcessed;
+  private markProcessed;
+  private getCachedExports;
+  private cacheExports;
+  private processModule;
+  private warnOnMixedDefaultAndKeyed;
+  /** Registers the provider and returns the token it was registered under. */
+  private registerProvider;
+  private isAppToken;
+  private buildExportSet;
+  getControllers(): Type[];
+  getRegisteredProviders(): Token[];
+  getAppProviderTokens(token: Token): Token[];
+  getConsumerMiddlewareDefinitions(): MiddlewareRouteDefinition[];
+  /**
+   * Every lazy module instance recorded during load. Handed to the
+   * LazyModuleManager at bootstrap; empty when no module opted in.
+   */
+  getLazyGroups(): LazyModuleGroupSpec[];
+  /**
+   * A token is deferred iff EVERY module bucket holding it belongs to a lazy
+   * module instance — a token also registered by a non-lazy module stays on
+   * the eager pass (and resolving it there claims the lazy sibling, which is
+   * the "any use = init" semantic, not a bug).
+   */
+  private isLazyOnlyToken;
+  resolveAllInstances(): Promise<unknown[]>;
+  private routeError;
+}
+//#endregion
+//#region src/factory/bootstrap.d.ts
+interface BootstrapOptions extends RouteManagerOptions {
+  diagnostics?: Diagnostics;
+}
+interface BootstrapResult {
+  container: Container;
+  routeManager: RouteManager;
+  loader: ModuleLoader;
+}
+/**
+ * Wire the DI graph for `rootModule` and prepare the route manager — without
+ * running lifecycle hooks or building the Hono app. The single primitive
+ * shared by `VelaFactory.create` (HTTP), `@velajs/testing` (test), and any
+ * non-HTTP consumer (CLI tools, custom runtimes).
+ *
+ * Framework-internal tokens (`Container`, `ModuleRef`, `APP_*`) are marked
+ * global so they are resolvable from any module.
+ */
+declare function bootstrap(rootModule: Type, options?: BootstrapOptions): Promise<BootstrapResult>;
+//#endregion
+//#region src/container/module-ref.d.ts
+declare class ModuleRef {
+  private readonly container;
+  constructor(container: Container);
+  /**
+   * Retrieve a provider instance from the DI container.
+   * Returns the existing singleton (or cached value) for the token.
+   */
+  get<T>(token: Token<T>): T;
+  /**
+   * Resolve a provider, creating a new instance for TRANSIENT-scoped providers.
+   * For SINGLETON-scoped providers this is equivalent to get().
+   */
+  resolve<T>(token: Token<T>): T;
+  /**
+   * Instantiate a class outside of the DI container's singleton cache.
+   * Dependencies are resolved from the container. Each call returns a new instance.
+   */
+  create<T>(type: Type<T>): T;
+}
+//#endregion
+//#region src/module/decorators.d.ts
+declare function Global(): ClassDecorator;
+declare function Module(options?: ModuleOptions): ClassDecorator;
+declare function isModule(target: Constructor): boolean;
+/**
+ * Normalize a DynamicModule, defaulting `key` to `"default"`. Module authors
+ * call this from `forRoot()` so the loader always sees an explicit key.
+ */
+declare function defineDynamicModule(input: DynamicModule): DynamicModule;
+declare function getModuleMetadata(target: Constructor): ModuleMetadata | undefined;
+//#endregion
+//#region src/plugin/plugin.d.ts
+interface Plugin {
+  id: string;
+  version: string;
+  module: Type | DynamicModule;
+  dependsOn?: string[];
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Freeze and validate a plugin manifest. Returns the same object so it can
+ * be used in `composePlugins([definePlugin(...), ...])`.
+ */
+declare function definePlugin(plugin: Plugin): Plugin;
+declare class PluginRegistry {
+  private byId;
+  constructor(plugins: readonly Plugin[]);
+  list(): Plugin[];
+  get(id: string): Plugin | undefined;
+  dependents(id: string): Plugin[];
+}
+declare const PLUGIN_REGISTRY_TOKEN: InjectionToken<PluginRegistry>;
+declare class PluginRootModule {}
+/**
+ * Compose a list of plugins into a single dynamic module that imports each
+ * plugin's module in dependency order, registers a `PluginRegistry`, and
+ * exposes it globally so any plugin can introspect peers.
+ */
+declare function composePlugins(plugins: readonly Plugin[]): DynamicModule;
+//#endregion
+//#region src/pipeline/component.manager.d.ts
+/**
+ * Component registration + resolution for the controller/handler tiers.
+ * App-wide (global) components have exactly ONE source: the per-app
+ * `RouteManager` (`APP_*` provider tokens + `useGlobalX()`) — callers merge
+ * `routeManager.getGlobalComponents()` with {@link getScopedComponents}.
+ *
+ * Stateless by design: no process-global container (two apps in one process
+ * never cross-talk) — every `resolve*` takes the resolving container.
+ */
+declare class ComponentManager {
+  static registerController<T extends ComponentType>(type: T, controller: Constructor, ...components: ComponentTypeMap[T][]): void;
+  static registerHandler<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol, ...components: ComponentTypeMap[T][]): void;
+  static getScopedComponents<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
+  private static resolveAll;
+  static resolveMiddleware(items: MiddlewareType[], container: Container): NestMiddleware[];
+  static resolveGuards(items: GuardType[], container: Container): CanActivate[];
+  static resolvePipes(items: PipeType[], container: Container): PipeTransform[];
+  static resolveInterceptors(items: InterceptorType[], container: Container): NestInterceptor[];
+  static resolveFilters(items: FilterType[], container: Container): ExceptionFilter[];
+  static executePipes(value: unknown, metadata: ArgumentMetadata, pipes: PipeTransform[]): Promise<unknown>;
+  static runInterceptorChain(interceptors: NestInterceptor[], context: ExecutionContext, coreHandler: () => Promise<unknown>): Promise<unknown>;
+}
+//#endregion
+//#region src/pipeline/tokens.d.ts
+/**
+ * Register global guards via module providers instead of app.useGlobalGuards().
+ *
+ * @example
+ * ```ts
+ * @Module({
+ *   providers: [
+ *     AuthGuard,
+ *     { provide: APP_GUARD, useClass: AuthGuard },
+ *   ],
+ * })
+ * class AppModule {}
+ * ```
+ */
+declare const APP_GUARD: InjectionToken<CanActivate>;
+/**
+ * Register global pipes via module providers.
+ */
+declare const APP_PIPE: InjectionToken<PipeTransform<unknown, unknown>>;
+/**
+ * Register global interceptors via module providers.
+ */
+declare const APP_INTERCEPTOR: InjectionToken<NestInterceptor>;
+/**
+ * Register global filters via module providers.
+ */
+declare const APP_FILTER: InjectionToken<ExceptionFilter<unknown>>;
+/**
+ * Register global middleware via module providers.
+ */
+declare const APP_MIDDLEWARE: InjectionToken<NestMiddleware>;
+/**
+ * Register the application-wide exception handler via module providers.
+ * Consumed by the shared error reporter (`resolveErrorReporter`) at every
+ * transport edge to customize how errors are reported and rendered.
+ *
+ * @example
+ * ```ts
+ * @Module({
+ *   providers: [
+ *     { provide: APP_EXCEPTION_HANDLER, useValue: { report: (e) => sentry.capture(e) } },
+ *   ],
+ * })
+ * class AppModule {}
+ * ```
+ */
+declare const APP_EXCEPTION_HANDLER: InjectionToken<ExceptionHandler>;
+/**
+ * Provide the composed error catalog (`composeCatalogs(CORE_CATALOG, …)`)
+ * consulted when rendering wire-bound error bodies. Defaults to the core
+ * catalog when unset.
+ */
+declare const ERROR_CATALOG: InjectionToken<Catalog<string>>;
+//#endregion
+//#region src/registry/metadata.registry.d.ts
+interface ControllerOptions {
+  version?: number | number[];
+}
+declare class MetadataRegistry {
+  private static get routes();
+  private static get controllers();
+  private static get controllerOptions();
+  private static get modules();
+  private static get parameters();
+  private static get injectables();
+  private static get scopes();
+  private static get injectTokens();
+  private static get handlerHttpMeta();
+  private static get catchTypes();
+  private static get routeVersions();
+  private static get classMeta();
+  private static get handlerMeta();
+  private static get classMetaIndex();
+  private static get handlerMetaIndex();
+  private static get controllerComponents();
+  private static get handlerComponents();
+  static getRoutes(controller: Constructor): RouteDefinition[];
+  static addRoute(controller: Constructor, route: RouteDefinition): void;
+  static getControllerPath(controller: Constructor): string;
+  static setControllerPath(controller: Constructor, path: string): void;
+  static getControllerOptions(controller: Constructor): ControllerOptions;
+  static setControllerOptions(controller: Constructor, options: ControllerOptions): void;
+  static getModuleOptions(module: Constructor): ModuleOptions | undefined;
+  static setModuleOptions(module: Constructor, options: ModuleOptions): void;
+  static getParameters(controller: Constructor): Map<string | symbol, ParameterMetadata[]>;
+  static addParameter(controller: Constructor, methodName: string | symbol, param: ParameterMetadata): void;
+  static registerController<T extends ComponentType>(type: T, controller: Constructor, component: ComponentTypeMap[T]): void;
+  static getController<T extends ComponentType>(type: T, controller: Constructor): ComponentTypeMap[T][];
+  static registerHandler<T extends ComponentType>(type: T, controller: Constructor, methodName: string | symbol, component: ComponentTypeMap[T]): void;
+  static getHandler<T extends ComponentType>(type: T, controller: Constructor, methodName: string | symbol): ComponentTypeMap[T][];
+  static markInjectable(target: object): void;
+  static hasInjectable(target: object): boolean;
+  static setScope(target: object, scope: Scope): void;
+  static getScope(target: object): Scope | undefined;
+  static setInjectTokens(target: object, tokens: InjectMetadata[]): void;
+  static getInjectTokens(target: object): InjectMetadata[] | undefined;
+  static setHandlerHttpMeta(controller: Constructor, method: string | symbol, meta: HttpHandlerMeta): void;
+  static getHandlerHttpMeta(controller: Constructor, method: string | symbol): HttpHandlerMeta | undefined;
+  static setCatchTypes(filter: Constructor, types: Type<Error>[]): void;
+  static getCatchTypes(filter: Constructor): Type<Error>[] | undefined;
+  static hasCatchTypes(filter: Constructor): boolean;
+  static setRouteVersion(controller: Constructor, method: string | symbol, version: number | number[]): void;
+  static getRouteVersion(controller: Constructor, method: string | symbol): number | number[] | undefined;
+  static setCustomClassMeta(target: object, key: string, value: unknown): void;
+  static getCustomClassMeta(target: object, key: string): unknown;
+  static getCustomClassMetaAll(target: object): Map<string, unknown> | undefined;
+  static setCustomHandlerMeta(target: object, handler: string | symbol, key: string, value: unknown): void;
+  static getCustomHandlerMeta(target: object, handler: string | symbol, key: string): unknown;
+  static getCustomHandlerMetaAll(target: object, handler: string | symbol): Map<string, unknown> | undefined;
+  static appendCustomClassMeta<T>(target: object, key: string, item: T): void;
+  static appendCustomHandlerMeta<T>(target: object, handler: string | symbol, key: string, item: T): void;
+  static getClassesWithClassMeta(key: string): ReadonlySet<object>;
+  static getClassesWithHandlerMeta(key: string): ReadonlySet<object>;
+  /** Every (handler, value) pair on `target` carrying metadata under `key`. */
+  static getHandlersWithMeta(target: object, key: string): Array<{
+    handler: string | symbol;
+    value: unknown;
+  }>;
+  static setReflectMetadata(target: object, key: string, value: unknown, propertyKey?: string | symbol): void;
+  static getReflectMetadata<T = unknown>(target: object, key: string, propertyKey?: string | symbol): T | undefined;
+  static getParamTypes(target: object, propertyKey?: string | symbol): unknown[] | undefined;
+  static propagateControllerComponents(from: Constructor, to: Constructor): void;
+  static clear(): void;
+  static reset(): void;
+}
+//#endregion
+export { contributesEntrypoints as $, CreateOpenApiDocumentOptions as A, RouteDescription as B, BootstrapResult as C, ApiDocMetadata as D, VelaApplication as E, OpenApiOperation as F, NestModule as G, RouteManagerOptions as H, OpenApiParameter as I, getEntrypointKinds as J, RouteInfo as K, OpenApiPathItem as L, JsonSchema as M, OpenApiDocument as N, ApiResponseEntry as O, OpenApiInfo as P, EntrypointKind as Q, OpenApiRequestBody as R, BootstrapOptions as S, ModuleLoader as T, ControllerOptions$1 as U, RouteManager as V, MiddlewareConsumer as W, ContributesEntrypoints as X, registerEntrypointKind as Y, Entrypoint as Z, Module as _, APP_INTERCEPTOR as a, isModule as b, ERROR_CATALOG as c, Plugin as d, ErrorMatcher as et, PluginRegistry as f, Global as g, definePlugin as h, APP_GUARD as i, HttpVerb as j, ApiResponseOptions as k, ComponentManager as l, composePlugins as m, APP_EXCEPTION_HANDLER as n, ExceptionHandler as nt, APP_MIDDLEWARE as o, PluginRootModule as p, EntrypointRegistry as q, APP_FILTER as r, matchesAny as rt, APP_PIPE as s, MetadataRegistry as t, ErrorReportContext as tt, PLUGIN_REGISTRY_TOKEN as u, defineDynamicModule as v, bootstrap as w, ModuleRef as x, getModuleMetadata as y, OpenApiResponse as z };
+//# sourceMappingURL=metadata.registry-D1od8ZBt.d.ts.map