@velajs/vela 1.19.0 → 1.19.1

package/dist/discovery.service-Cpf1QcZ5.d.ts

@@ -0,0 +1,648 @@
+import { Context } from "hono";
+//#region src/constants.d.ts
+declare const METADATA_KEYS: {
+  readonly INJECTABLE: 'vela:injectable';
+  readonly INJECT: 'vela:inject';
+  readonly SCOPE: 'vela:scope';
+  readonly MODULE: 'vela:module';
+  readonly MODULE_OPTIONS: 'vela:module-options';
+  readonly CONTROLLER: 'vela:controller';
+  readonly ROUTES: 'vela:routes';
+  readonly PARAMS: 'vela:params';
+  readonly HTTP_CODE: 'vela:http-code';
+  readonly RESPONSE_HEADERS: 'vela:response-headers';
+  readonly REDIRECT: 'vela:redirect';
+  readonly CATCH: 'vela:catch';
+  readonly CRUD: 'vela:crud';
+};
+declare const HttpMethod: {
+  readonly GET: 'GET';
+  readonly POST: 'POST';
+  readonly PUT: 'PUT';
+  readonly PATCH: 'PATCH';
+  readonly DELETE: 'DELETE';
+  readonly OPTIONS: 'OPTIONS';
+  readonly HEAD: 'HEAD';
+  readonly ALL: 'ALL';
+};
+type HttpMethod = (typeof HttpMethod)[keyof typeof HttpMethod];
+declare const ParamType: {
+  readonly BODY: 'body';
+  readonly QUERY: 'query';
+  readonly PARAM: 'param';
+  readonly HEADERS: 'headers';
+  readonly REQUEST: 'request';
+  readonly RESPONSE: 'response';
+  readonly IP: 'ip';
+  readonly COOKIE: 'cookie';
+  readonly RAW_BODY: 'raw_body';
+};
+type ParamType = (typeof ParamType)[keyof typeof ParamType];
+declare const Scope: {
+  readonly SINGLETON: 'singleton';
+  readonly TRANSIENT: 'transient';
+  readonly REQUEST: 'request';
+};
+type Scope = (typeof Scope)[keyof typeof Scope];
+//#endregion
+//#region src/container/types.d.ts
+type Type<T = any> = new (...args: any[]) => T;
+type Constructor<T = unknown> = abstract new (...args: any[]) => T;
+interface InjectionTokenOptions<T> {
+  factory?: () => T;
+}
+declare class InjectionToken<T = unknown> {
+  private readonly description;
+  readonly options?: InjectionTokenOptions<T> | undefined;
+  constructor(description: string, options?: InjectionTokenOptions<T> | undefined);
+  toString(): string;
+}
+declare class ForwardRef<T = unknown> {
+  readonly factory: () => Token<T>;
+  constructor(factory: () => Token<T>);
+}
+declare function forwardRef<T>(factory: () => Token<T>): ForwardRef<T>;
+type Token<T = any> = Type<T> | InjectionToken<T> | string | symbol;
+/**
+ * Maps a single DI `Token<T>` to its resolved value type at the type level:
+ * - `InjectionToken<T>`           → `T`
+ * - `Type<T>` / `Constructor<T>`  → `T` (the instance type)
+ * - `ForwardRef<T>`               → `T`
+ * - `string` / `symbol`           → `unknown` (runtime-only tokens carry no
+ *                                   static type info; the consumer asserts).
+ *
+ * Used by `AsyncModuleOptions` to give `useFactory` parameters their real
+ * types based on the literal `inject` tuple — without `as const` at the call
+ * site (relies on the `const` type parameter on the consuming generic).
+ */
+type InferToken<T> = T extends InjectionToken<infer U> ? U : T extends ForwardRef<infer U> ? U : T extends (abstract new (...args: any[]) => infer U) ? U : unknown;
+/**
+ * Map every position of a `Token[]` tuple to its resolved value type.
+ * Pairs with `const Inject extends readonly Token<unknown>[]` generics to
+ * give `useFactory(...deps)` parameter types inferred from the literal
+ * `inject` array.
+ */
+type InferTokens<T extends readonly unknown[]> = { [K in keyof T]: InferToken<T[K]>; };
+interface InjectableOptions {
+  scope?: Scope;
+}
+interface InjectMetadata {
+  index: number;
+  token?: Token | ForwardRef;
+  optional?: boolean;
+}
+interface ProviderOptions<T = unknown> {
+  provide?: Token<T>;
+  scope?: Scope;
+  useValue?: T;
+  useFactory?: (...args: any[]) => T | Promise<T>;
+  useClass?: Type<T>;
+  inject?: readonly Token[];
+  useExisting?: Token<T>;
+}
+interface ModuleScope {
+  moduleId: string;
+  localProviders: Set<Token>;
+  importedModules: Set<string>;
+  exportedTokens: Set<Token>;
+  isGlobal: boolean;
+  /** Module instance opted into deferred (first-use) materialization. */
+  lazy?: boolean;
+}
+/**
+ * The container's seam into lazy-module materialization (implemented by
+ * `LazyModuleManager`). The container only ever *claims* a pending module at
+ * a resolution trigger and *drains* completed claims when the resolution
+ * stack has fully unwound — construction and hook replay live behind this
+ * interface so the container stays module-system-agnostic.
+ */
+interface LazyResolutionHook {
+  /** Is this module instance still deferred (untriggered)? */
+  isPending(moduleId: string): boolean;
+  /** Mark a pending module as triggered; idempotent. */
+  claim(moduleId: string): void;
+  /** Any claimed-but-unmaterialized groups? (cheap fast-path check) */
+  hasClaimed(): boolean;
+  /**
+   * A drain loop is currently running. The container must NOT start (or
+   * await) another drain from inside it — the running loop picks pending
+   * claims up; awaiting would self-deadlock on the async path.
+   */
+  isDraining(): boolean;
+  /** Complete claimed groups synchronously; throws if async work surfaces. */
+  drainSync(): void;
+  /** Complete claimed groups, awaiting async construction and hooks. */
+  drainAsync(): Promise<void>;
+}
+type Diagnostics = 'silent' | 'log' | 'throw';
+interface ContainerOptions {
+  diagnostics?: Diagnostics;
+}
+/**
+ * Human-readable token label — class name, `InjectionToken(desc)`, symbol
+ * string, or String() fallback. Public so introspection tooling (module
+ * graphs, entrypoint listings) renders tokens the same way vela's own errors
+ * do.
+ */
+declare function describeToken(token: Token): string;
+/**
+ * One module instance in the loaded graph, serializable (strings only) —
+ * what `Container.getModuleDescriptions()` returns for introspection tooling
+ * (`vela module graph`). Reads registration state only; never constructs.
+ */
+interface ModuleDescription {
+  moduleId: string;
+  /** moduleIds this instance imports. */
+  imports: string[];
+  isGlobal: boolean;
+  lazy: boolean;
+  /** Token labels registered in this instance's bucket (registration order). */
+  providers: string[];
+  /** Token labels this instance exports. */
+  exports: string[];
+}
+declare class ModuleVisibilityError extends Error {
+  readonly moduleId: string;
+  readonly token: Token;
+  constructor(moduleId: string, token: Token);
+}
+declare class MultipleProvidersFoundError extends Error {
+  readonly moduleId: string;
+  readonly token: Token;
+  readonly candidates: string[];
+  constructor(moduleId: string, token: Token, candidates: string[]);
+}
+declare const ROOT_MODULE_ID = "__root__";
+//#endregion
+//#region src/container/container.d.ts
+/**
+ * Per-module provider buckets. Each module instance owns its providers under
+ * its `moduleId`; the same logical token can have distinct registrations in
+ * different buckets, supporting multi-instance dynamic modules.
+ *
+ * The `__root__` bucket holds bootstrap-time framework primitives (Container,
+ * ModuleRef, REQUEST_CONTEXT, etc.) and any `register()` call that doesn't
+ * supply a `declaringModuleId`.
+ */
+declare class Container {
+  private providers;
+  private exporterIndex;
+  private resolutionStack;
+  private requestInstances;
+  private scopes;
+  private globals;
+  private diagnostics;
+  private root;
+  private disposables;
+  private lazyHook?;
+  private asyncDepth;
+  constructor(options?: ContainerOptions);
+  /** Install the lazy-module seam (bootstrap-time; root container only). */
+  setLazyHook(hook: LazyResolutionHook): void;
+  private claimLazyModule;
+  private maybeDrainSync;
+  register<T>(provider: Type<T> | ProviderOptions<T>, declaringModuleId?: string): this;
+  private registerClass;
+  private registerOptions;
+  private writeRegistration;
+  registerScope(scope: ModuleScope): void;
+  markGlobalToken(token: Token): void;
+  setRequestInstance(token: Token, value: unknown): void;
+  getDiagnostics(): Diagnostics;
+  resolve<T>(token: Token<T>, requestingModuleId?: string): T;
+  resolveAll<T>(token: Token<T>, requestingModuleId?: string): T[];
+  /**
+   * Find a single reachable registration for a token, applying the visibility
+   * walk: requester's bucket → globals → requester's importedModules
+   * (transitively, following re-exports).
+   *
+   * Returns `undefined` if no candidate exists. Throws
+   * `MultipleProvidersFoundError` if the imports walk yields more than one.
+   */
+  private findRegistration;
+  /** Typed bucket lookup — single seam where the Map<Token, Registration> erases T. */
+  private lookupInBucket;
+  /**
+   * Walk a scope's imports (and their imports' imports, …) collecting every
+   * registration reachable through re-export chains. A child only contributes
+   * if it explicitly exports the token — non-exported providers stay private.
+   */
+  private collectFromImports;
+  private findAllRegistrations;
+  /** True if any bucket has a registration for `token`. Sandbox-friendly. */
+  has(token: Token): boolean;
+  /** True if the specified module's bucket has a registration for `token`. */
+  hasInScope(token: Token, moduleId: string): boolean;
+  /** Module buckets that hold a registration for `token` (registration order). */
+  getOwnerModuleIds(token: Token): string[];
+  /**
+   * Force-replace a provider across module scopes — the supported form of the
+   * override loop test harnesses need (module-scoped resolution consults the
+   * module's own bucket first, so a root-only override would never win there).
+   *
+   * - `'all-existing'` (default): every non-root bucket that already holds the
+   *   token, plus `__root__` (so framework-internal lookups see it too).
+   * - `'root'`: only the `__root__` bucket.
+   * - `string[]`: exactly these bucket ids.
+   */
+  replaceProvider<T>(provider: Type<T> | ProviderOptions<T>, options?: {
+    buckets?: 'all-existing' | 'root' | string[];
+  }): this;
+  /**
+   * True when the token belongs exclusively to lazy modules that have not
+   * been materialized yet — resolving it would trigger materialization.
+   * Build-time probes (route-manager middleware priority, entrypoint
+   * snapshots) use this to defer instead of forcing the group.
+   */
+  isLazyPending(token: Token): boolean;
+  /**
+   * True when any registration of the token holds a constructed instance.
+   * Diagnostic helper (cold-start tests): checks WITHOUT resolving, so it
+   * never triggers lazy materialization.
+   */
+  isInstantiated(token: Token): boolean;
+  getProviderScope(token: Token): Scope | undefined;
+  getTokens(): Token[];
+  /**
+   * Every statically-provided (useValue) instance across ALL module buckets.
+   * Unlike resolving a token (which yields only the first bucket's registration),
+   * this surfaces per-instance values — e.g. one BindingRef per multi-instance
+   * binding module — so framework adapters can initialize all of them.
+   */
+  getUseValues(): unknown[];
+  /**
+   * Serializable description of every loaded module instance (load order),
+   * plus the `__root__` bucket (bootstrap primitives) when non-empty —
+   * the `vela module graph` seam. Reads registration state only: safe pre-
+   * and post-bootstrap, never constructs, never claims lazy modules.
+   */
+  getModuleDescriptions(): ModuleDescription[];
+  /**
+   * Compute request-scope bubbling for every registration (call once at
+   * bootstrap, after all providers are registered). A provider whose declared
+   * scope is not REQUEST but which (transitively) depends on a request-scoped
+   * provider is marked `effectiveScope = REQUEST`, so it is rebuilt per request
+   * instead of capturing the first request's instance — matching NestJS.
+   */
+  computeEffectiveScopes(): void;
+  /** The dependency tokens a registration would resolve when constructed. */
+  private dependencyTokensOf;
+  private tryFindRegistration;
+  /**
+   * Create a child container for request-scoped resolution.
+   * The child shares the parent's providers but caches REQUEST-scoped
+   * instances separately per child (per request).
+   */
+  createChild(): Container;
+  createDetached(): Container;
+  clear(): void;
+  /** Whether this container has any tracked disposables (cheap request-path check). */
+  hasDisposables(): boolean;
+  /**
+   * Dispose container-constructed instances (Symbol.asyncDispose /
+   * Symbol.dispose / .dispose()) in reverse creation order (LIFO). Errors are
+   * logged and skipped so one bad teardown never blocks the rest.
+   *
+   * A REQUEST child disposes only its own request-scoped instances; the root
+   * disposes shared SINGLETONs and clears their cached instance so a dev HMR
+   * generation cannot leak a stale graph. Shared provider maps are left intact
+   * for a request child (they belong to the root).
+   */
+  dispose(): Promise<void>;
+  private resolveRegistration;
+  private resolveClass;
+  /**
+   * Resolve one factory `inject` dependency. Since 1.11 the declaring module's
+   * scope is consulted FIRST (proper visibility semantics — a `forRootAsync`
+   * factory can inject providers reachable through its module's imports); on
+   * any failure the legacy no-requester lookup (root bucket, then first
+   * exporter) is kept as fallback, so every previously-resolving graph still
+   * resolves.
+   */
+  private resolveFactoryDependency;
+  private resolveFactoryDependencyAsync;
+  private resolveFactory;
+  resolveAsync<T>(token: Token<T>, requestingModuleId?: string): Promise<T>;
+  private resolveAsyncInner;
+  private createLazyProxy;
+  private tokenToString;
+}
+//#endregion
+//#region src/pipeline/types.d.ts
+/**
+ * HTTP-specific arguments host returned by `ExecutionContext.switchToHttp()`.
+ * In Vela/Hono, the `Context` object holds both request and response state.
+ *
+ * - `getRequest()` — the Web `Request` object
+ * - `getResponse()` — the Hono `Context` (use `c.header()`, `c.setCookie()`, etc.)
+ */
+interface HttpArgumentsHost {
+  getRequest<T = Request>(): T;
+  getResponse<T = Context>(): T;
+}
+/**
+ * WebSocket-specific arguments host returned by `ExecutionContext.switchToWs()`.
+ * Populated by `@velajs/vela/websocket` when a gateway message is dispatched.
+ *
+ * - `getClient()` — the connected socket (`WsClient`)
+ * - `getData()` — the inbound message payload (the envelope's `data`)
+ * - `getPattern()` — the subscribed event name that matched
+ */
+interface WsArgumentsHost {
+  getClient<T = unknown>(): T;
+  getData<T = unknown>(): T;
+  getPattern<T = string>(): T;
+}
+/** The transport a component is executing under. `'http'` for routes, `'ws'` for gateway messages. */
+type ContextType = 'http' | 'ws';
+interface ExecutionContext {
+  getType<T extends string = ContextType>(): T;
+  getClass(): Type;
+  getHandler(): string | symbol;
+  /** Returns the Hono `Context` directly. Throws on a WebSocket context. */
+  getContext<T = Context>(): T;
+  /** Shorthand for `switchToHttp().getRequest()` — returns the Web `Request`. Throws on a WebSocket context. */
+  getRequest(): Request;
+  /** Switch to the HTTP arguments host. Throws on a WebSocket context. */
+  switchToHttp(): HttpArgumentsHost;
+  /** Switch to the WebSocket arguments host. Throws on an HTTP context. */
+  switchToWs(): WsArgumentsHost;
+}
+interface CanActivate {
+  canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}
+interface CallHandler {
+  handle(): Promise<unknown>;
+}
+interface NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}
+interface ArgumentMetadata {
+  type: string;
+  metatype?: Type;
+  data?: string;
+}
+interface PipeTransform<T = unknown, R = unknown> {
+  transform(value: T, metadata: ArgumentMetadata): R | Promise<R>;
+}
+interface ExceptionFilter<T = unknown> {
+  catch(exception: T, context: ExecutionContext): unknown | Promise<unknown>;
+}
+interface NestMiddleware {
+  use(c: import('hono').Context, next: import('hono').Next): Promise<Response | void>;
+}
+//#endregion
+//#region src/registry/types.d.ts
+type ComponentType = 'middleware' | 'guard' | 'pipe' | 'interceptor' | 'filter';
+type MiddlewareType = Type<NestMiddleware> | NestMiddleware;
+type GuardType = Type<CanActivate> | CanActivate;
+type PipeType = Type<PipeTransform> | PipeTransform;
+type InterceptorType = Type<NestInterceptor> | NestInterceptor;
+type FilterType = Type<ExceptionFilter> | ExceptionFilter;
+interface ComponentTypeMap {
+  middleware: MiddlewareType;
+  guard: GuardType;
+  pipe: PipeType;
+  interceptor: InterceptorType;
+  filter: FilterType;
+}
+type ComponentInstance = MiddlewareType | GuardType | PipeType | InterceptorType | FilterType;
+interface RouteDefinition {
+  method: string;
+  path: string;
+  handlerName: string | symbol;
+  version?: number | number[];
+  /** Route name for URL generation / OpenAPI operationId (`@Get(path, { name })`). */
+  name?: string;
+}
+interface ParameterMetadata {
+  index: number;
+  type: string;
+  name?: string;
+  pipes?: PipeType[];
+  factory?: (data: unknown, ctx: Context) => unknown;
+  /**
+   * Explicit param type for programmatic routes. Methods synthesized at
+   * runtime (e.g. `@Crud()` verb handlers) have no `design:paramtypes`, so
+   * ValidationPipe and the OpenAPI walk read this instead when present.
+   */
+  metatype?: unknown;
+}
+interface HttpHandlerMeta {
+  httpCode?: number;
+  responseHeaders?: Array<[string, string]>;
+  redirect?: {
+    url: string;
+    statusCode: number;
+  };
+}
+type ModuleImport = Type | DynamicModule | ForwardRef;
+/**
+ * Async module options with **type-inferred `useFactory` parameters**.
+ *
+ * The `Inject` generic captures the literal `inject` tuple via `const` type
+ * parameter inference at the call site (TS 5.0+ — vela already requires it).
+ * `useFactory`'s parameter types are computed from that tuple via
+ * `InferTokens<Inject>`, so:
+ *
+ * ```ts
+ * SomeModule.forRootAsync({
+ *   inject: [D1Service, ConfigService],   // captured as readonly [typeof D1Service, typeof ConfigService]
+ *   useFactory: (d1, config) => { ... },  // d1: D1Service, config: ConfigService — inferred
+ * });
+ * ```
+ *
+ * Backwards compatible: when `inject` isn't a literal tuple (or is omitted),
+ * `Inject` falls back to `readonly Token<unknown>[]`, `InferTokens` resolves
+ * to `unknown[]`, and `useFactory` accepts variadic `unknown[]` — the prior
+ * loose-typing behavior. Existing callers don't break.
+ */
+interface AsyncModuleOptions<T = unknown, Inject extends readonly Token<unknown>[] = readonly Token<unknown>[]> {
+  imports?: ModuleImport[];
+  inject?: Inject;
+  useFactory: (...args: InferTokens<Inject>) => T | Promise<T>;
+}
+interface DynamicModule {
+  module: Type;
+  /**
+   * Author-supplied instance discriminator. Two DynamicModules with the same
+   * `module` class and the same `key` dedup; with different keys they coexist
+   * as separate module instances. Defaults to `"default"` when absent — which
+   * preserves single-instance dedup for the common case.
+   *
+   * For `forRoot(options)`, derive `key: stableHash(options)` so identical
+   * options dedup automatically. For `forRootAsync` (factories aren't
+   * structurally hashable), pass an explicit string.
+   */
+  key?: string;
+  imports?: ModuleImport[];
+  providers?: Array<Type | ProviderOptions>;
+  controllers?: Type[];
+  exports?: Array<Type | InjectionToken>;
+  global?: boolean;
+  /**
+   * Defer this module instance's providers/controllers to first use: nothing
+   * constructs at bootstrap; the first resolution of any of its tokens
+   * materializes the whole group and replays its lifecycle hooks (memoized).
+   * See MODULE_AUTHORING.md "Lazy modules" for the contract.
+   */
+  lazy?: boolean;
+}
+interface ModuleOptions {
+  providers?: Array<Type | ProviderOptions>;
+  controllers?: Type[];
+  imports?: ModuleImport[];
+  exports?: Array<Type | InjectionToken>;
+  isGlobal?: boolean;
+  /** Defer to first use (see {@link DynamicModule.lazy}). */
+  lazy?: boolean;
+}
+interface ModuleMetadata {
+  providers: Array<Type | ProviderOptions>;
+  controllers: Type[];
+  imports: ModuleImport[];
+  exports: Array<Type | InjectionToken>;
+  isGlobal: boolean;
+  lazy: boolean;
+}
+//#endregion
+//#region src/discovery/discoverable.decorator.d.ts
+/**
+ * A decorator whose annotated classes/methods are findable through
+ * `DiscoveryService` by the decorator itself (no string key at the call site).
+ */
+interface DiscoverableDecorator<T> {
+  (value: T): ClassDecorator & MethodDecorator;
+  /** The metadata key backing this decorator — stable across HMR re-evals. */
+  KEY: string;
+}
+interface CreateDiscoverableDecoratorOptions {
+  /**
+   * Append to a class-level list instead of overwriting a single slot —
+   * for stackable method decorators (`@Cron`-style: each application pushes
+   * `{ methodName, ...value }` onto the class's list, which
+   * `DiscoveryService.methodsWithMeta` flattens back to per-method entries).
+   */
+  append?: boolean;
+}
+/**
+ * Mint a discoverable decorator for a module's extension surface:
+ *
+ * ```ts
+ * export interface QueueConsumerMeta { queue: string }
+ * export const QueueConsumer = createDiscoverableDecorator<QueueConsumerMeta>('vela:queue:consumer');
+ *
+ * @QueueConsumer({ queue: 'emails' })
+ * @Injectable()
+ * class EmailConsumer { ... }
+ *
+ * // At bootstrap, anywhere:
+ * discovery.providersWithMeta(QueueConsumer)  // typed { meta: QueueConsumerMeta }
+ * ```
+ *
+ * Unlike `Reflector.createDecorator`, the key is required and caller-chosen:
+ * a random key would mint a fresh identity on every HMR re-eval and orphan
+ * previously-decorated classes. Namespace it (`'<pkg>:<area>:<thing>'`).
+ */
+declare function createDiscoverableDecorator<T>(key: string, options?: CreateDiscoverableDecoratorOptions): DiscoverableDecorator<T>;
+//#endregion
+//#region src/discovery/discovery.service.d.ts
+/** A container-registered class provider surfaced by discovery. */
+interface DiscoveredClass<T = unknown> {
+  token: Token;
+  metatype: Type<T>;
+  /** Module buckets holding this token (registration order; first = primary). */
+  moduleIds: string[];
+  scope: Scope;
+  /**
+   * Resolved instance. `undefined` only when the provider is request-scoped
+   * and `includeRequestScoped` was not set — request-scoped providers cannot
+   * be materialized at bootstrap without fabricating a phantom request.
+   */
+  instance: T | undefined;
+}
+interface DiscoveredMethodMeta<M = unknown> {
+  class: DiscoveredClass;
+  methodName: string | symbol;
+  meta: M;
+}
+interface DiscoveryFilter {
+  /** Restrict to providers declared by these module buckets. */
+  moduleId?: string | string[];
+  /**
+   * Resolve request-scoped providers too (constructs an instance outside any
+   * request — only for callers that know what they're doing). Default false:
+   * request-scoped hits are skipped with a diagnostics warning.
+   */
+  includeRequestScoped?: boolean;
+  /**
+   * Return providers of not-yet-materialized lazy modules as metadata-only
+   * entries (`instance: undefined`, mirroring the request-scoped convention)
+   * instead of resolving them — which would force the whole module group.
+   * Used by `EntrypointRegistry.build`; default false so every existing
+   * scanner keeps its transparent cascade-materialization semantics.
+   */
+  deferLazy?: boolean;
+}
+/**
+ * Decorator-driven provider discovery — the public replacement for the
+ * bootstrap scan every subsystem used to hand-roll (`container.getTokens()` +
+ * `MetadataRegistry.getCustomClassMeta` + `resolve` + diagnostics handling).
+ *
+ * Registered globally by `bootstrap()`, so any provider can inject it:
+ *
+ * ```ts
+ * @Injectable()
+ * class MyRegistry implements OnApplicationBootstrap {
+ *   constructor(private readonly discovery: DiscoveryService) {}
+ *   onApplicationBootstrap() {
+ *     for (const { instance, meta } of this.discovery.providersWithMeta<MyMeta>(MY_KEY)) {
+ *       this.register(instance, meta);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Discovery is kernel-level, not encapsulation-scoped: module visibility
+ * protects modules from *each other*, never from the framework's own
+ * dispatchers. Use `DiscoveryFilter.moduleId` for the rare narrowing case.
+ *
+ * The resolve-failure policy honors the container's diagnostics mode exactly
+ * like the legacy loops: `throw` rethrows, `log` warns and skips, `silent`
+ * skips — so a broken provider never silently changes discovery semantics.
+ */
+declare class DiscoveryService {
+  private readonly container;
+  constructor(container: Container);
+  /** Every class-token provider registered in the container. */
+  getProviders(filter?: DiscoveryFilter): DiscoveredClass[];
+  /**
+   * Providers whose class carries class-level metadata under `key` — both
+   * class decorators (single value) and method decorators that append
+   * class-level lists (`@Cron`, `@OnEvent`, `@SubscribeMessage`).
+   */
+  providersWithMeta<M>(key: string | DiscoverableDecorator<M>, filter?: DiscoveryFilter): Array<DiscoveredClass & {
+    meta: M;
+  }>;
+  /**
+   * Handler methods carrying metadata under `key`. Merges the two storage
+   * conventions:
+   *  - class-level appended lists whose items carry `methodName`
+   *    (`@Cron`/`@OnEvent`-style method decorators), and
+   *  - true handler-level metadata (`@SetMetadata`/`createDiscoverableDecorator`
+   *    applied to a method).
+   */
+  methodsWithMeta<M>(key: string | DiscoverableDecorator<M>, filter?: DiscoveryFilter): DiscoveredMethodMeta<M>[];
+  /**
+   * Index-first candidate walk with a legacy full-scan fallback: when the
+   * reverse index knows nothing about a key, an older copy of the registry
+   * module may have taken the writes (mixed dist/src or package versions in
+   * one process) — fall back to scanning container tokens the way the
+   * pre-DiscoveryService loops did.
+   */
+  private candidatesWithClassMeta;
+  private buildEntry;
+}
+//#endregion
+export { forwardRef as $, NestInterceptor as A, InferTokens as B, RouteDefinition as C, ExceptionFilter as D, CanActivate as E, Constructor as F, ModuleScope as G, InjectableOptions as H, ContainerOptions as I, ProviderOptions as J, ModuleVisibilityError as K, Diagnostics as L, PipeTransform as M, WsArgumentsHost as N, ExecutionContext as O, Container as P, describeToken as Q, ForwardRef as R, PipeType as S, CallHandler as T, InjectionToken as U, InjectMetadata as V, ModuleDescription as W, Token as X, ROOT_MODULE_ID as Y, Type as Z, MiddlewareType as _, CreateDiscoverableDecoratorOptions as a, ModuleOptions as b, AsyncModuleOptions as c, ComponentTypeMap as d, HttpMethod as et, DynamicModule as f, InterceptorType as g, HttpHandlerMeta as h, DiscoveryService as i, NestMiddleware as j, HttpArgumentsHost as k, ComponentInstance as l, GuardType as m, DiscoveredMethodMeta as n, ParamType as nt, DiscoverableDecorator as o, FilterType as p, MultipleProvidersFoundError as q, DiscoveryFilter as r, Scope as rt, createDiscoverableDecorator as s, DiscoveredClass as t, METADATA_KEYS as tt, ComponentType as u, ModuleImport as v, ArgumentMetadata as w, ParameterMetadata as x, ModuleMetadata as y, InferToken as z };
+//# sourceMappingURL=discovery.service-Cpf1QcZ5.d.ts.map