@navios/core 0.7.0 → 0.8.0

package/lib/{index-BFwNx9WQ.d.cts → index-BDNl7j1G.d.cts}

@@ -1,10 +1,9 @@
 import * as _navios_di0 from "@navios/di";
-import { AnyInjectableType, ClassType, ClassTypeWithInstance, Container, FactoryContext, FactoryInjectionToken, InjectionToken, ScopedContainer } from "@navios/di";
+import { AnyInjectableType, ClassType, ClassTypeWithInstance, Container, FactoryContext, FactoryInjectionToken, InjectionToken, Registry, ScopedContainer } from "@navios/di";
 import z, { ZodDiscriminatedUnion, ZodObject, ZodType, z as z$1 } from "zod/v4";
 import { BaseEndpointConfig, BaseStreamConfig, EndpointFunctionArgs, HttpMethod, Util_FlatObject } from "@navios/builder";
 import { InspectOptions } from "util";
 import { OutgoingHttpHeaders } from "http";
-import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/config/utils/helpers.d.mts
 declare function envInt(key: keyof NodeJS.ProcessEnv, defaultValue: number): number;
@@ -220,6 +219,11 @@ interface ControllerOptions {
    * Guards are executed in reverse order (last guard first).
    */
   guards?: ClassType[] | Set<ClassType>;
+  /**
+   * Registry to use for the controller.
+   * Registry is used to store the controller and its endpoints.
+   */
+  registry?: Registry;
 }
 /**
  * Decorator that marks a class as a Navios controller.
@@ -242,7 +246,8 @@ interface ControllerOptions {
  * ```
  */
 declare function Controller({
-  guards
+  guards,
+  registry
 }?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 //#endregion
 //#region src/decorators/endpoint.decorator.d.mts
@@ -328,9 +333,12 @@ type EndpointResult<EndpointDeclaration extends {
  * }
  * ```
  */
+declare function Endpoint<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, ResponseSchema extends ZodType = ZodType, RequestSchema = ZodType, Params = (QuerySchema extends ZodType ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>)>(endpoint: {
+  config: BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema>;
+}): (target: (params: Params) => Promise<z$1.input<ResponseSchema>> | z$1.input<ResponseSchema>, context: ClassMethodDecoratorContext) => void;
 declare function Endpoint<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, ResponseSchema extends ZodType = ZodType, RequestSchema = ZodType>(endpoint: {
   config: BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema>;
-}): (target: (params: QuerySchema extends ZodType ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>) => Promise<z$1.input<ResponseSchema>>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodType ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>) => Promise<z$1.input<ResponseSchema>>;
+}): (target: () => Promise<z$1.input<ResponseSchema>> | z$1.input<ResponseSchema>, context: ClassMethodDecoratorContext) => void;
 //#endregion
 //#region src/metadata/handler.metadata.d.mts
 declare const EndpointMetadataKey: unique symbol;
@@ -858,22 +866,86 @@ interface AbstractHttpListenOptions {
 }
 //#endregion
 //#region src/interfaces/abstract-http-adapter.interface.d.mts
+/**
+ * Abstract interface for HTTP adapters.
+ *
+ * Adapters implement this interface to provide runtime-specific HTTP server
+ * functionality (Fastify, Bun, etc.).
+ *
+ * @typeParam ServerInstance - The underlying server type (e.g., FastifyInstance)
+ * @typeParam CorsOptions - CORS configuration options type
+ * @typeParam Options - Server setup options type
+ * @typeParam MultipartOptions - Multipart form handling options type
+ */
 interface AbstractHttpAdapterInterface<ServerInstance, CorsOptions = AbstractHttpCorsOptions, Options$1 = {}, MultipartOptions = {}> {
+  /**
+   * Sets up the HTTP server with the provided options.
+   */
   setupHttpServer(options: Options$1): Promise<void>;
+  /**
+   * Called after all modules are loaded to register routes.
+   */
   onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;
+  /**
+   * Signals that the server is ready to accept requests.
+   */
   ready(): Promise<void>;
+  /**
+   * Returns the underlying HTTP server instance.
+   */
   getServer(): ServerInstance;
+  /**
+   * Sets a global prefix for all routes.
+   */
   setGlobalPrefix(prefix: string): void;
+  /**
+   * Gets the current global prefix.
+   * Returns empty string if no prefix is set.
+   */
+  getGlobalPrefix(): string;
+  /**
+   * Enables CORS with the specified options.
+   */
   enableCors(options: CorsOptions): void;
+  /**
+   * Enables multipart form data handling.
+   */
   enableMultipart(options: MultipartOptions): void;
+  /**
+   * Starts the server and listens for incoming requests.
+   */
   listen(options: AbstractHttpListenOptions): Promise<string>;
+  /**
+   * Disposes of the server and cleans up resources.
+   */
   dispose(): Promise<void>;
 }
 //#endregion
 //#region src/interfaces/abstract-http-handler-adapter.interface.d.mts
+/**
+ * Static handler result - handler can be called without a scoped container.
+ * Used when the controller and all its dependencies are singletons.
+ */
+type StaticHandler<TRequest = any, TReply = any> = {
+  isStatic: true;
+  handler: (request: TRequest, reply: TReply) => Promise<any>;
+};
+/**
+ * Dynamic handler result - handler requires a scoped container for resolution.
+ * Used when the controller or its dependencies need per-request resolution.
+ */
+type DynamicHandler<TRequest = any, TReply = any> = {
+  isStatic: false;
+  handler: (scoped: ScopedContainer, request: TRequest, reply: TReply) => Promise<any>;
+};
+/**
+ * Handler result returned by provideHandler.
+ * Can be either static (pre-resolved) or dynamic (needs scoped container).
+ */
+type HandlerResult<TRequest = any, TReply = any> = StaticHandler<TRequest, TReply> | DynamicHandler<TRequest, TReply>;
 interface AbstractHttpHandlerAdapterInterface {
   prepareArguments?: (handlerMetadata: HandlerMetadata<any>) => ((target: Record<string, any>, request: any) => Promise<void> | void)[];
-  provideHandler: (controller: ClassType, handlerMetadata: HandlerMetadata<any>) => (context: ScopedContainer, request: any, reply: any) => Promise<any>;
+  provideHandler: (controller: ClassType, handlerMetadata: HandlerMetadata<any>) => Promise<HandlerResult>;
 }
 //#endregion
 //#region src/interfaces/can-activate.d.mts
@@ -950,6 +1022,160 @@ interface NaviosModule {
   onModuleInit?: () => Promise<void> | void;
 }
 //#endregion
+//#region src/services/module-loader.service.d.mts
+/**
+ * Extension definition for dynamically adding to the module tree.
+ * Used by plugins to inject controllers or entire modules.
+ */
+interface ModuleExtension {
+  /**
+   * Module class to add. If provided, the module and all its
+   * controllers/imports will be processed.
+   */
+  module?: ClassTypeWithInstance<NaviosModule>;
+  /**
+   * Controllers to add directly without a wrapper module.
+   * Will be registered under a synthetic module named after the plugin.
+   */
+  controllers?: ClassType[];
+  /**
+   * Name for the synthetic module when using controllers directly.
+   * Required if `controllers` is provided without `module`.
+   */
+  moduleName?: string;
+}
+declare class ModuleLoaderService {
+  private logger;
+  protected container: Container;
+  private modulesMetadata;
+  private loadedModules;
+  private initialized;
+  loadModules(appModule: ClassTypeWithInstance<NaviosModule>): Promise<void>;
+  /**
+   * Extends the module tree with additional modules or controllers.
+   *
+   * This method is designed to be called by plugins during registration,
+   * which happens after initial module loading but before route registration.
+   *
+   * @param extensions - Array of module extensions to add
+   * @throws Error if not initialized (loadModules must be called first)
+   *
+   * @example
+   * ```typescript
+   * // In plugin registration
+   * const moduleLoader = await context.container.get(ModuleLoaderService)
+   * await moduleLoader.extendModules([{
+   *   controllers: [OpenApiJsonController, OpenApiYamlController],
+   *   moduleName: 'OpenApiBunModule',
+   * }])
+   * ```
+   */
+  extendModules(extensions: ModuleExtension[]): Promise<void>;
+  /**
+   * Registers controllers under a synthetic module.
+   * Used when plugins want to add controllers without a full module class.
+   */
+  private registerControllers;
+  private traverseModules;
+  private mergeMetadata;
+  getAllModules(): Map<string, ModuleMetadata>;
+  dispose(): void;
+}
+//#endregion
+//#region src/interfaces/plugin.interface.d.mts
+/**
+ * Context provided to plugins during registration.
+ *
+ * This context gives plugins access to the application's modules,
+ * server instance, DI container, and configuration.
+ */
+interface PluginContext {
+  /**
+   * All loaded modules with their metadata.
+   * Keys are module class names, values are their metadata.
+   */
+  modules: Map<string, ModuleMetadata>;
+  /**
+   * The underlying HTTP server instance.
+   * Type depends on the adapter used (Fastify, Bun, etc.)
+   */
+  server: any;
+  /**
+   * The dependency injection container.
+   */
+  container: Container;
+  /**
+   * Global route prefix (e.g., '/api/v1').
+   * Empty string if no prefix is set.
+   */
+  globalPrefix: string;
+  /**
+   * Module loader service for extending the module tree.
+   * Use `moduleLoader.extendModules()` to add controllers dynamically.
+   */
+  moduleLoader: ModuleLoaderService;
+}
+/**
+ * Base interface for Navios plugins.
+ *
+ * Plugins are registered using `app.usePlugin()` and are initialized
+ * after all modules are loaded but before the server starts listening.
+ *
+ * @typeParam TOptions - The type of options the plugin accepts
+ *
+ * @example
+ * ```typescript
+ * const myPlugin: NaviosPlugin<{ enabled: boolean }> = {
+ *   name: 'my-plugin',
+ *   register: async (context, options) => {
+ *     if (options.enabled) {
+ *       // Register routes, services, etc.
+ *     }
+ *   },
+ * }
+ * ```
+ */
+interface NaviosPlugin<TOptions = unknown> {
+  /**
+   * Plugin name for identification and logging.
+   */
+  name: string;
+  /**
+   * Called after modules are loaded but before the server starts listening.
+   *
+   * @param context - The plugin context with access to modules and server
+   * @param options - Plugin-specific configuration options
+   */
+  register(context: PluginContext, options: TOptions): Promise<void> | void;
+}
+/**
+ * Plugin definition combining a plugin with its options.
+ *
+ * This is the type returned by plugin factory functions like `defineOpenApiPlugin()`.
+ *
+ * @typeParam TOptions - The type of options the plugin accepts
+ *
+ * @example
+ * ```typescript
+ * function defineMyPlugin(options: MyPluginOptions): PluginDefinition<MyPluginOptions> {
+ *   return {
+ *     plugin: myPlugin,
+ *     options,
+ *   }
+ * }
+ * ```
+ */
+interface PluginDefinition<TOptions = unknown> {
+  /**
+   * The plugin instance.
+   */
+  plugin: NaviosPlugin<TOptions>;
+  /**
+   * Options to pass to the plugin's register function.
+   */
+  options: TOptions;
+}
+//#endregion
 //#region src/decorators/header.decorator.d.mts
 /**
  * Decorator that sets a custom HTTP response header for an endpoint.
@@ -1089,9 +1315,12 @@ type MultipartResult<EndpointDeclaration extends {
  * }
  * ```
  */
+declare function Multipart<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, ResponseSchema extends ZodType = ZodType, RequestSchema = ZodType, Params = (QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>)>(endpoint: {
+  config: BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema>;
+}): (target: (params: Params) => Promise<z$1.input<ResponseSchema>> | z$1.input<ResponseSchema>, context: ClassMethodDecoratorContext) => void;
 declare function Multipart<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, ResponseSchema extends ZodType = ZodType, RequestSchema = ZodType>(endpoint: {
   config: BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema>;
-}): (target: (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z$1.input<ResponseSchema>>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z$1.input<ResponseSchema>>;
+}): (target: () => Promise<z$1.input<ResponseSchema>> | z$1.input<ResponseSchema>, context: ClassMethodDecoratorContext) => void;
 //#endregion
 //#region src/decorators/stream.decorator.d.mts
 /**
@@ -1130,9 +1359,15 @@ type StreamParams<EndpointDeclaration extends {
  * }
  * ```
  */
+declare function Stream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType, Params = (QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>)>(endpoint: {
+  config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+}): (target: (params: Params, reply: any) => any, context: ClassMethodDecoratorContext) => void;
+declare function Stream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType, Params = (QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>)>(endpoint: {
+  config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+}): (target: (params: Params) => any, context: ClassMethodDecoratorContext) => void;
 declare function Stream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType>(endpoint: {
   config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
-}): (target: (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>, reply: any) => Promise<void>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>, reply: any) => Promise<void>;
+}): (target: () => any, context: ClassMethodDecoratorContext) => void;
 //#endregion
 //#region src/decorators/use-guards.decorator.d.mts
 /**
@@ -1372,51 +1607,153 @@ declare class ConflictException extends HttpException {
   constructor(message: string | object, error?: Error);
 }
 //#endregion
+//#region src/services/instance-resolver.service.d.mts
+/**
+ * Result of instance resolution attempt.
+ * Contains either a cached singleton instance or a resolver function
+ * that can be used to get a fresh instance per request.
+ */
+interface InstanceResolution<T = any> {
+  /**
+   * Whether the instance was successfully cached as a singleton.
+   * If true, `instance` contains the cached instance.
+   * If false, the class has request-scoped dependencies and
+   * must be resolved per-request using `resolve()`.
+   */
+  cached: boolean;
+  /**
+   * The cached instance (only available if `cached` is true).
+   */
+  instance: T | null;
+  /**
+   * Resolves the instance from a scoped container.
+   * Use this when `cached` is false to get a fresh instance per request.
+   */
+  resolve: (scoped: ScopedContainer) => Promise<T>;
+}
+/**
+ * Result of resolving multiple instances.
+ * Contains either all cached singleton instances or a resolver function.
+ */
+interface MultiInstanceResolution<T = any> {
+  /**
+   * Whether ALL instances were successfully cached as singletons.
+   * If true, `instances` contains all cached instances.
+   * If false, at least one class has request-scoped dependencies.
+   */
+  cached: boolean;
+  /**
+   * The cached instances (only available if `cached` is true).
+   * Order matches the input array order.
+   */
+  instances: T[] | null;
+  /**
+   * The original class types for dynamic resolution.
+   */
+  classTypes: ClassType[];
+  /**
+   * Resolves all instances from a scoped container.
+   * Use this when `cached` is false to get fresh instances per request.
+   */
+  resolve: (scoped: ScopedContainer) => Promise<T[]>;
+}
+/**
+ * Service responsible for resolving class instances with automatic scope detection.
+ *
+ * This service attempts to resolve classes as singletons from the root container.
+ * If resolution fails (because the class has request-scoped dependencies),
+ * it automatically updates the class's scope to Request and provides a
+ * resolver function for per-request instantiation.
+ *
+ * This enables optimal performance:
+ * - Classes without request-scoped deps stay as singletons (faster)
+ * - Classes with request-scoped deps are automatically promoted to request scope
+ *
+ * @example
+ * ```ts
+ * const resolution = await instanceResolver.resolve(UserController)
+ *
+ * if (resolution.cached) {
+ *   // Use cached singleton
+ *   return resolution.instance.handleRequest(req)
+ * } else {
+ *   // Resolve per request
+ *   const controller = await resolution.resolve(scopedContainer)
+ *   return controller.handleRequest(req)
+ * }
+ * ```
+ */
+declare class InstanceResolverService {
+  private container;
+  /**
+   * Attempts to resolve a class instance, automatically detecting if it needs
+   * request scope based on its dependencies.
+   *
+   * @param classType - The class to resolve
+   * @returns A resolution result containing either a cached instance or resolver function
+   */
+  resolve<T>(classType: ClassType): Promise<InstanceResolution<T>>;
+  /**
+   * Attempts to resolve multiple class instances, automatically detecting if any need
+   * request scope based on their dependencies.
+   *
+   * Returns `cached: true` only if ALL classes can be resolved as singletons.
+   * If any class has request-scoped dependencies, returns `cached: false`.
+   *
+   * @param classTypes - The classes to resolve
+   * @returns A resolution result containing either all cached instances or resolver function
+   */
+  resolveMany<T>(classTypes: ClassType[]): Promise<MultiInstanceResolution<T>>;
+}
+/**
+ * @deprecated Use InstanceResolverService instead
+ */
+declare const ControllerResolverService: typeof InstanceResolverService;
+/**
+ * @deprecated Use InstanceResolution instead
+ */
+type ControllerResolution<T = any> = InstanceResolution<T>;
+//#endregion
 //#region src/services/guard-runner.service.d.mts
 declare class GuardRunnerService {
   private readonly logger;
+  /**
+   * Runs guards that need to be resolved from a scoped container.
+   * Use this when guards have request-scoped dependencies.
+   */
   runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: AbstractExecutionContext, context: ScopedContainer): Promise<boolean>;
+  /**
+   * Runs pre-resolved guard instances.
+   * Use this when all guards are singletons and have been pre-resolved at startup.
+   */
+  runGuardsStatic(guardInstances: CanActivate[], executionContext: AbstractExecutionContext): Promise<boolean>;
+  /**
+   * Shared guard execution logic.
+   * Iterates through guard instances and calls canActivate on each.
+   */
+  private executeGuards;
   makeContext(moduleMetadata: ModuleMetadata, controllerMetadata: ControllerMetadata, endpoint: HandlerMetadata): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
 }
 //#endregion
-//#region src/services/module-loader.service.d.mts
-declare class ModuleLoaderService {
-  private logger;
-  protected container: Container;
-  private modulesMetadata;
-  private loadedModules;
-  private initialized;
-  loadModules(appModule: ClassTypeWithInstance<NaviosModule>): Promise<void>;
-  private traverseModules;
-  private mergeMetadata;
-  getAllModules(): Map<string, ModuleMetadata>;
-  dispose(): void;
-}
-//#endregion
 //#region src/stores/request-id.store.d.mts
 /**
- * AsyncLocalStorage store for the current request ID.
- *
- * This allows logging and other services to access the current request ID
- * without explicitly passing it through the call stack.
- *
- * @example
- * ```typescript
- * import { requestIdStore, runWithRequestId, getRequestId } from '@navios/core'
+ * Generates a simple incremental request ID.
+ * Much faster than crypto.randomUUID() and sufficient for request tracking.
  *
- * // Run code with a request ID in context
- * runWithRequestId('req-123', () => {
- *   // Inside this callback, getRequestId() returns 'req-123'
- *   logger.log('Processing request') // Will include request ID if logger is configured
- * })
+ * @returns A unique request ID string (e.g., "req-1", "req-2", ...)
+ */
+declare function generateRequestId(): string;
+/**
+ * Enables or disables request ID propagation.
+ * Called by NaviosFactory based on the enableRequestId option.
  *
- * // Get current request ID (returns undefined if not in a request context)
- * const currentId = getRequestId()
- * ```
+ * @param enabled - Whether to enable request ID propagation
  */
-declare const requestIdStore: AsyncLocalStorage<string>;
+declare function setRequestIdEnabled(enabled: boolean): void;
 /**
  * Runs a function with a request ID in the async local storage context.
+ * If request ID propagation is disabled, the function is called directly
+ * without AsyncLocalStorage overhead.
  *
  * @param requestId - The request ID to set for this context
  * @param fn - The function to run within this context
@@ -1443,262 +1780,34 @@ declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<any,
 //#region src/tokens/multipart-adapter.token.d.mts
 declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
 //#endregion
-//#region src/tokens/reply.token.d.mts
-declare const Reply: InjectionToken<any, undefined, false>;
-//#endregion
-//#region src/tokens/request.token.d.mts
-declare const Request: InjectionToken<any, undefined, false>;
-//#endregion
-//#region src/tokens/stream-adapter.token.d.mts
-declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
-//#endregion
-//#region src/tokens/xml-stream-adapter.token.d.mts
-declare const XmlStreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//#region src/navios.environment.d.mts
+interface NaviosEnvironmentOptions {
+  httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>;
+}
 //#endregion
-//#region src/attribute.factory.d.mts
+//#region src/navios.application.d.mts
 /**
- * Type for a class attribute decorator without a value.
- *
- * Attributes are custom metadata decorators that can be applied to modules,
- * controllers, and endpoints.
+ * Options for configuring the Navios application context.
+ * These options control dependency injection and logging behavior.
  */
-type ClassAttribute = (() => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
-  token: symbol;
-};
+interface NaviosApplicationContextOptions {
+  /**
+   * Specifies the logger to use. Pass `false` to turn off logging.
+   *
+   * - `LoggerService` instance: Use a custom logger implementation
+   * - `LogLevel[]`: Enable specific log levels (e.g., ['error', 'warn', 'log'])
+   * - `false`: Disable logging completely
+   */
+  logger?: LoggerService | LogLevel[] | false;
+  /**
+   * Specifies a custom container to use. Useful for testing.
+   * If not provided, a new Container will be created.
+   */
+  container?: Container;
+}
 /**
- * Type for a class attribute decorator with a validated value.
- *
- * @typeParam T - The Zod schema type for validation
- */
-type ClassSchemaAttribute<T extends ZodType> = ((value: z$1.input<T>) => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
-  token: symbol;
-  schema: ZodType;
-};
-/**
- * Factory for creating custom attribute decorators.
- *
- * Attributes allow you to add custom metadata to modules, controllers, and endpoints.
- * This is useful for cross-cutting concerns like rate limiting, caching, API versioning, etc.
- *
- * @example
- * ```typescript
- * // Create a simple boolean attribute
- * const Public = AttributeFactory.createAttribute(Symbol.for('Public'))
- *
- * // Use it as a decorator
- * @Controller()
- * @Public()
- * export class PublicController { }
- *
- * // Check if attribute exists
- * if (AttributeFactory.has(Public, controllerMetadata)) {
- *   // Skip authentication
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Create an attribute with a validated value
- * const RateLimit = AttributeFactory.createAttribute(
- *   Symbol.for('RateLimit'),
- *   z.object({ requests: z.number(), window: z.number() })
- * )
- *
- * // Use it with a value
- * @Endpoint(apiEndpoint)
- * @RateLimit({ requests: 100, window: 60000 })
- * async handler() { }
- *
- * // Get the value
- * const limit = AttributeFactory.get(RateLimit, endpointMetadata)
- * // limit is typed as { requests: number, window: number } | null
- * ```
- */
-declare class AttributeFactory {
-  /**
-   * Creates a simple attribute decorator without a value.
-   *
-   * @param token - A unique symbol to identify this attribute
-   * @returns A decorator function that can be applied to classes or methods
-   *
-   * @example
-   * ```typescript
-   * const Public = AttributeFactory.createAttribute(Symbol.for('Public'))
-   *
-   * @Public()
-   * @Controller()
-   * export class PublicController { }
-   * ```
-   */
-  static createAttribute(token: symbol): ClassAttribute;
-  /**
-   * Creates an attribute decorator with a validated value.
-   *
-   * @param token - A unique symbol to identify this attribute
-   * @param schema - A Zod schema to validate the attribute value
-   * @returns A decorator function that accepts a value and can be applied to classes or methods
-   *
-   * @example
-   * ```typescript
-   * const RateLimit = AttributeFactory.createAttribute(
-   *   Symbol.for('RateLimit'),
-   *   z.object({ requests: z.number(), window: z.number() })
-   * )
-   *
-   * @RateLimit({ requests: 100, window: 60000 })
-   * @Endpoint(apiEndpoint)
-   * async handler() { }
-   * ```
-   */
-  static createAttribute<T extends ZodType>(token: symbol, schema: T): ClassSchemaAttribute<T>;
-  /**
-   * Gets the value of an attribute from metadata.
-   *
-   * Returns `null` if the attribute is not present.
-   * For simple attributes (without values), returns `true` if present.
-   *
-   * @param attribute - The attribute decorator
-   * @param target - The metadata object (module, controller, or handler)
-   * @returns The attribute value, `true` for simple attributes, or `null` if not found
-   *
-   * @example
-   * ```typescript
-   * const isPublic = AttributeFactory.get(Public, controllerMetadata)
-   * // isPublic is true | null
-   *
-   * const rateLimit = AttributeFactory.get(RateLimit, endpointMetadata)
-   * // rateLimit is { requests: number, window: number } | null
-   * ```
-   */
-  static get(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): true | null;
-  static get<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): z$1.output<T> | null;
-  /**
-   * Gets all values of an attribute from metadata (useful when an attribute can appear multiple times).
-   *
-   * Returns `null` if the attribute is not present.
-   *
-   * @param attribute - The attribute decorator
-   * @param target - The metadata object (module, controller, or handler)
-   * @returns An array of attribute values, or `null` if not found
-   *
-   * @example
-   * ```typescript
-   * const tags = AttributeFactory.getAll(Tag, endpointMetadata)
-   * // tags is string[] | null
-   * ```
-   */
-  static getAll(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): Array<true> | null;
-  static getAll<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): Array<z$1.output<T>> | null;
-  /**
-   * Gets the last value of an attribute from an array of metadata objects.
-   *
-   * Searches from the end of the array backwards, useful for finding the most
-   * specific attribute value (e.g., endpoint-level overrides module-level).
-   *
-   * @param attribute - The attribute decorator
-   * @param target - An array of metadata objects (typically [module, controller, handler])
-   * @returns The last attribute value found, or `null` if not found
-   *
-   * @example
-   * ```typescript
-   * // Check attribute hierarchy: endpoint -> controller -> module
-   * const rateLimit = AttributeFactory.getLast(RateLimit, [
-   *   moduleMetadata,
-   *   controllerMetadata,
-   *   endpointMetadata
-   * ])
-   * ```
-   */
-  static getLast(attribute: ClassAttribute, target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[]): true | null;
-  static getLast<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[]): z$1.output<T> | null;
-  /**
-   * Checks if an attribute is present on the metadata object.
-   *
-   * @param attribute - The attribute decorator
-   * @param target - The metadata object (module, controller, or handler)
-   * @returns `true` if the attribute is present, `false` otherwise
-   *
-   * @example
-   * ```typescript
-   * if (AttributeFactory.has(Public, controllerMetadata)) {
-   *   // Skip authentication
-   * }
-   * ```
-   */
-  static has(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
-  static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
-}
-//#endregion
-//#region src/factories/endpoint-adapter.factory.d.mts
-declare class EndpointAdapterFactory {
-  private readonly environment;
-  create(ctx: FactoryContext): Promise<any>;
-}
-//#endregion
-//#region src/factories/http-adapter.factory.d.mts
-declare class HttpAdapterFactory {
-  private readonly environment;
-  create(ctx: FactoryContext): Promise<any>;
-}
-//#endregion
-//#region src/factories/multipart-adapter.factory.d.mts
-declare class MultipartAdapterFactory {
-  private readonly environment;
-  create(ctx: FactoryContext): Promise<any>;
-}
-//#endregion
-//#region src/factories/request.factory.d.mts
-declare class RequestFactory {
-  private readonly environment;
-  create(ctx: FactoryContext): Promise<any>;
-}
-//#endregion
-//#region src/factories/reply.factory.d.mts
-declare class ReplyFactory {
-  private readonly environment;
-  create(ctx: FactoryContext): Promise<any>;
-}
-//#endregion
-//#region src/factories/stream-adapter.factory.d.mts
-declare class StreamAdapterFactory {
-  private readonly environment;
-  create(ctx: FactoryContext): Promise<any>;
-}
-//#endregion
-//#region src/factories/xml-stream-adapter.factory.d.mts
-declare class XmlStreamAdapterFactory {
-  private readonly environment;
-  create(ctx: FactoryContext): Promise<any>;
-}
-//#endregion
-//#region src/navios.environment.d.mts
-interface NaviosEnvironmentOptions {
-  httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>;
-}
-//#endregion
-//#region src/navios.application.d.mts
-/**
- * Options for configuring the Navios application context.
- * These options control dependency injection and logging behavior.
- */
-interface NaviosApplicationContextOptions {
-  /**
-   * Specifies the logger to use. Pass `false` to turn off logging.
-   *
-   * - `LoggerService` instance: Use a custom logger implementation
-   * - `LogLevel[]`: Enable specific log levels (e.g., ['error', 'warn', 'log'])
-   * - `false`: Disable logging completely
-   */
-  logger?: LoggerService | LogLevel[] | false;
-  /**
-   * Specifies a custom container to use. Useful for testing.
-   * If not provided, a new Container will be created.
-   */
-  container?: Container;
-}
-/**
- * Complete options for creating a Navios application.
- * Extends NaviosApplicationContextOptions with adapter configuration.
+ * Complete options for creating a Navios application.
+ * Extends NaviosApplicationContextOptions with adapter configuration.
  */
 interface NaviosApplicationOptions extends NaviosApplicationContextOptions {
   /**
@@ -1713,6 +1822,18 @@ interface NaviosApplicationOptions extends NaviosApplicationContextOptions {
    * ```
    */
   adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[];
+  /**
+   * Whether to validate response schemas.
+   * When `false`, response schema validation is skipped for better performance.
+   * @default true
+   */
+  validateResponses?: boolean;
+  /**
+   * Whether to enable request ID propagation via AsyncLocalStorage.
+   * When `true`, request IDs are available via `getRequestId()` throughout the request.
+   * @default false
+   */
+  enableRequestId?: boolean;
 }
 /**
  * Main application class for Navios.
@@ -1740,6 +1861,7 @@ declare class NaviosApplication {
   protected container: Container;
   private appModule;
   private options;
+  private plugins;
   /**
    * Indicates whether the application has been initialized.
    * Set to `true` after `init()` completes successfully.
@@ -1760,6 +1882,25 @@ declare class NaviosApplication {
    * @returns The Container instance
    */
   getContainer(): Container;
+  /**
+   * Registers a plugin to be initialized after modules are loaded.
+   *
+   * Plugins are initialized in the order they are registered,
+   * after all modules are loaded but before the server starts listening.
+   *
+   * @param definition - Plugin definition with options
+   * @returns this for method chaining
+   *
+   * @example
+   * ```typescript
+   * import { defineOpenApiPlugin } from '@navios/openapi-fastify'
+   *
+   * app.usePlugin(defineOpenApiPlugin({
+   *   info: { title: 'My API', version: '1.0.0' },
+   * }))
+   * ```
+   */
+  usePlugin<TOptions>(definition: PluginDefinition<TOptions>): this;
   /**
    * Initializes the application.
    *
@@ -1767,6 +1908,7 @@ declare class NaviosApplication {
    * - Loads all modules and their dependencies
    * - Sets up the HTTP server if an adapter is configured
    * - Calls onModuleInit hooks on all modules
+   * - Initializes registered plugins
    * - Marks the application as initialized
    *
    * Must be called before `listen()`.
@@ -1784,6 +1926,7 @@ declare class NaviosApplication {
    */
   init(): Promise<void>;
   private initModules;
+  private initPlugins;
   /**
    * Enables CORS (Cross-Origin Resource Sharing) for the application.
    *
@@ -1882,6 +2025,237 @@ declare class NaviosApplication {
   close(): Promise<void>;
 }
 //#endregion
+//#region src/tokens/navios-options.token.d.mts
+declare const NaviosOptionsToken: InjectionToken<NaviosApplicationOptions, undefined, false>;
+//#endregion
+//#region src/tokens/reply.token.d.mts
+declare const Reply: InjectionToken<any, undefined, false>;
+//#endregion
+//#region src/tokens/request.token.d.mts
+declare const Request: InjectionToken<any, undefined, false>;
+//#endregion
+//#region src/tokens/stream-adapter.token.d.mts
+declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//#endregion
+//#region src/tokens/xml-stream-adapter.token.d.mts
+declare const XmlStreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//#endregion
+//#region src/attribute.factory.d.mts
+/**
+ * Type for a class attribute decorator without a value.
+ *
+ * Attributes are custom metadata decorators that can be applied to modules,
+ * controllers, and endpoints.
+ */
+type ClassAttribute = (() => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+  token: symbol;
+};
+/**
+ * Type for a class attribute decorator with a validated value.
+ *
+ * @typeParam T - The Zod schema type for validation
+ */
+type ClassSchemaAttribute<T extends ZodType> = ((value: z$1.input<T>) => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+  token: symbol;
+  schema: ZodType;
+};
+/**
+ * Factory for creating custom attribute decorators.
+ *
+ * Attributes allow you to add custom metadata to modules, controllers, and endpoints.
+ * This is useful for cross-cutting concerns like rate limiting, caching, API versioning, etc.
+ *
+ * @example
+ * ```typescript
+ * // Create a simple boolean attribute
+ * const Public = AttributeFactory.createAttribute(Symbol.for('Public'))
+ *
+ * // Use it as a decorator
+ * @Controller()
+ * @Public()
+ * export class PublicController { }
+ *
+ * // Check if attribute exists
+ * if (AttributeFactory.has(Public, controllerMetadata)) {
+ *   // Skip authentication
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create an attribute with a validated value
+ * const RateLimit = AttributeFactory.createAttribute(
+ *   Symbol.for('RateLimit'),
+ *   z.object({ requests: z.number(), window: z.number() })
+ * )
+ *
+ * // Use it with a value
+ * @Endpoint(apiEndpoint)
+ * @RateLimit({ requests: 100, window: 60000 })
+ * async handler() { }
+ *
+ * // Get the value
+ * const limit = AttributeFactory.get(RateLimit, endpointMetadata)
+ * // limit is typed as { requests: number, window: number } | null
+ * ```
+ */
+declare class AttributeFactory {
+  /**
+   * Creates a simple attribute decorator without a value.
+   *
+   * @param token - A unique symbol to identify this attribute
+   * @returns A decorator function that can be applied to classes or methods
+   *
+   * @example
+   * ```typescript
+   * const Public = AttributeFactory.createAttribute(Symbol.for('Public'))
+   *
+   * @Public()
+   * @Controller()
+   * export class PublicController { }
+   * ```
+   */
+  static createAttribute(token: symbol): ClassAttribute;
+  /**
+   * Creates an attribute decorator with a validated value.
+   *
+   * @param token - A unique symbol to identify this attribute
+   * @param schema - A Zod schema to validate the attribute value
+   * @returns A decorator function that accepts a value and can be applied to classes or methods
+   *
+   * @example
+   * ```typescript
+   * const RateLimit = AttributeFactory.createAttribute(
+   *   Symbol.for('RateLimit'),
+   *   z.object({ requests: z.number(), window: z.number() })
+   * )
+   *
+   * @RateLimit({ requests: 100, window: 60000 })
+   * @Endpoint(apiEndpoint)
+   * async handler() { }
+   * ```
+   */
+  static createAttribute<T extends ZodType>(token: symbol, schema: T): ClassSchemaAttribute<T>;
+  /**
+   * Gets the value of an attribute from metadata.
+   *
+   * Returns `null` if the attribute is not present.
+   * For simple attributes (without values), returns `true` if present.
+   *
+   * @param attribute - The attribute decorator
+   * @param target - The metadata object (module, controller, or handler)
+   * @returns The attribute value, `true` for simple attributes, or `null` if not found
+   *
+   * @example
+   * ```typescript
+   * const isPublic = AttributeFactory.get(Public, controllerMetadata)
+   * // isPublic is true | null
+   *
+   * const rateLimit = AttributeFactory.get(RateLimit, endpointMetadata)
+   * // rateLimit is { requests: number, window: number } | null
+   * ```
+   */
+  static get(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): true | null;
+  static get<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): z$1.output<T> | null;
+  /**
+   * Gets all values of an attribute from metadata (useful when an attribute can appear multiple times).
+   *
+   * Returns `null` if the attribute is not present.
+   *
+   * @param attribute - The attribute decorator
+   * @param target - The metadata object (module, controller, or handler)
+   * @returns An array of attribute values, or `null` if not found
+   *
+   * @example
+   * ```typescript
+   * const tags = AttributeFactory.getAll(Tag, endpointMetadata)
+   * // tags is string[] | null
+   * ```
+   */
+  static getAll(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): Array<true> | null;
+  static getAll<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): Array<z$1.output<T>> | null;
+  /**
+   * Gets the last value of an attribute from an array of metadata objects.
+   *
+   * Searches from the end of the array backwards, useful for finding the most
+   * specific attribute value (e.g., endpoint-level overrides module-level).
+   *
+   * @param attribute - The attribute decorator
+   * @param target - An array of metadata objects (typically [module, controller, handler])
+   * @returns The last attribute value found, or `null` if not found
+   *
+   * @example
+   * ```typescript
+   * // Check attribute hierarchy: endpoint -> controller -> module
+   * const rateLimit = AttributeFactory.getLast(RateLimit, [
+   *   moduleMetadata,
+   *   controllerMetadata,
+   *   endpointMetadata
+   * ])
+   * ```
+   */
+  static getLast(attribute: ClassAttribute, target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[]): true | null;
+  static getLast<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[]): z$1.output<T> | null;
+  /**
+   * Checks if an attribute is present on the metadata object.
+   *
+   * @param attribute - The attribute decorator
+   * @param target - The metadata object (module, controller, or handler)
+   * @returns `true` if the attribute is present, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * if (AttributeFactory.has(Public, controllerMetadata)) {
+   *   // Skip authentication
+   * }
+   * ```
+   */
+  static has(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
+  static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
+}
+//#endregion
+//#region src/factories/endpoint-adapter.factory.d.mts
+declare class EndpointAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/http-adapter.factory.d.mts
+declare class HttpAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/multipart-adapter.factory.d.mts
+declare class MultipartAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/request.factory.d.mts
+declare class RequestFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/reply.factory.d.mts
+declare class ReplyFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/stream-adapter.factory.d.mts
+declare class StreamAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/xml-stream-adapter.factory.d.mts
+declare class XmlStreamAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
 //#region src/navios.factory.d.mts
 /**
  * Factory class for creating and configuring Navios applications.
@@ -1947,5 +2321,5 @@ declare class NaviosFactory {
   private static registerLoggerConfiguration;
 }
 //#endregion
-export { AbstractHttpCorsOptions as $, ConfigServiceOptionsSchema as $t, UnauthorizedException as A, ModuleMetadataKey as At, MultipartParams as B, HandlerMetadata as Bt, EndpointAdapterToken as C, filterLogLevels as Ct, ModuleLoaderService as D, yellow as Dt, runWithRequestId as E, clc as Et, HttpException as F, ControllerMetadataKey as Ft, Header as G, EndpointResult as Gt, Module as H, getEndpointMetadata as Ht, UseGuards as I, extractControllerMetadata as It, OmitIndexSignature as J, ConfigProviderOptions as Jt, NaviosModule as K, Controller as Kt, Stream as L, getControllerMetadata as Lt, InternalServerErrorException as M, getModuleMetadata as Mt, ForbiddenException as N, hasModuleMetadata as Nt, GuardRunnerService as O, AbstractExecutionContext as Ot, BadRequestException as P, ControllerMetadata as Pt, AbstractHttpListenOptions as Q, ConfigServiceOptions as Qt, StreamParams as R, hasControllerMetadata as Rt, ExecutionContextInjectionToken as S, isLogLevel as St, requestIdStore as T, LogLevel as Tt, ModuleOptions as U, Endpoint as Ut, MultipartResult as V, getAllEndpointMetadata as Vt, HttpCode as W, EndpointParams as Wt, AbstractHttpHandlerAdapterInterface as X, provideConfig as Xt, CanActivate as Y, EnvConfigProvider as Yt, AbstractHttpAdapterInterface as Z, ConfigService as Zt, Request as _, isSymbol as _t, XmlStreamAdapterFactory as a, PathValue as an, ConsoleLogger as at, HttpAdapterToken as b, stripEndSlash as bt, RequestFactory as c, addLeadingSlash as ct, EndpointAdapterFactory as d, isFunction as dt, ConfigServiceToken as en, Logger as et, AttributeFactory as f, isNil as ft, StreamAdapterToken as g, isString as gt, XmlStreamAdapterToken as h, isPlainObject as ht, NaviosApplicationOptions as i, PathImpl2 as in, LoggerInstance as it, NotFoundException as j, extractModuleMetadata as jt, ConflictException as k, ModuleMetadata as kt, MultipartAdapterFactory as l, isConstructor as lt, ClassSchemaAttribute as m, isObject as mt, NaviosApplication as n, Path as nn, LoggerOutput as nt, StreamAdapterFactory as o, envInt as on, ConsoleLoggerOptions as ot, ClassAttribute as p, isNumber as pt, HttpHeader as q, ControllerOptions as qt, NaviosApplicationContextOptions as r, PathImpl as rn, loggerOptionsSchema as rt, ReplyFactory as s, envString as sn, LoggerService as st, NaviosFactory as t, ConfigServiceInterface as tn, LoggerOptions as tt, HttpAdapterFactory as u, isEmpty as ut, Reply as v, isUndefined as vt, getRequestId as w, LOG_LEVELS as wt, ExecutionContext as x, isLogLevelEnabled as xt, MultipartAdapterToken as y, normalizePath as yt, Multipart as z, EndpointMetadataKey as zt };
-//# sourceMappingURL=index-BFwNx9WQ.d.cts.map
+export { PluginContext as $, EndpointMetadataKey as $t, ControllerResolution as A, isString as At, BadRequestException as B, clc as Bt, ExecutionContextInjectionToken as C, isConstructor as Ct, runWithRequestId as D, isNumber as Dt, getRequestId as E, isNil as Et, ConflictException as F, isLogLevelEnabled as Ft, Multipart as G, extractModuleMetadata as Gt, UseGuards as H, AbstractExecutionContext as Ht, UnauthorizedException as I, isLogLevel as It, Module as J, ControllerMetadata as Jt, MultipartParams as K, getModuleMetadata as Kt, NotFoundException as L, filterLogLevels as Lt, InstanceResolution as M, isUndefined as Mt, InstanceResolverService as N, normalizePath as Nt, setRequestIdEnabled as O, isObject as Ot, MultiInstanceResolution as P, stripEndSlash as Pt, NaviosPlugin as Q, hasControllerMetadata as Qt, InternalServerErrorException as R, LOG_LEVELS as Rt, ExecutionContext as S, addLeadingSlash as St, generateRequestId as T, isFunction as Tt, Stream as U, ModuleMetadata as Ut, HttpException as V, yellow as Vt, StreamParams as W, ModuleMetadataKey as Wt, HttpCode as X, extractControllerMetadata as Xt, ModuleOptions as Y, ControllerMetadataKey as Yt, Header as Z, getControllerMetadata as Zt, NaviosApplication as _, PathImpl as _n, loggerOptionsSchema as _t, RequestFactory as a, EndpointResult as an, OmitIndexSignature as at, MultipartAdapterToken as b, envInt as bn, ConsoleLoggerOptions as bt, EndpointAdapterFactory as c, ConfigProviderOptions as cn, DynamicHandler as ct, ClassSchemaAttribute as d, ConfigService as dn, AbstractHttpAdapterInterface as dt, HandlerMetadata as en, PluginDefinition as et, XmlStreamAdapterToken as f, ConfigServiceOptions as fn, AbstractHttpListenOptions as ft, NaviosOptionsToken as g, Path as gn, LoggerOutput as gt, Reply as h, ConfigServiceInterface as hn, LoggerOptions as ht, ReplyFactory as i, EndpointParams as in, HttpHeader as it, ControllerResolverService as j, isSymbol as jt, GuardRunnerService as k, isPlainObject as kt, AttributeFactory as l, EnvConfigProvider as ln, HandlerResult as lt, Request as m, ConfigServiceToken as mn, Logger as mt, XmlStreamAdapterFactory as n, getEndpointMetadata as nn, ModuleLoaderService as nt, MultipartAdapterFactory as o, Controller as on, CanActivate as ot, StreamAdapterToken as p, ConfigServiceOptionsSchema as pn, AbstractHttpCorsOptions as pt, MultipartResult as q, hasModuleMetadata as qt, StreamAdapterFactory as r, Endpoint as rn, NaviosModule as rt, HttpAdapterFactory as s, ControllerOptions as sn, AbstractHttpHandlerAdapterInterface as st, NaviosFactory as t, getAllEndpointMetadata as tn, ModuleExtension as tt, ClassAttribute as u, provideConfig as un, StaticHandler as ut, NaviosApplicationContextOptions as v, PathImpl2 as vn, LoggerInstance as vt, EndpointAdapterToken as w, isEmpty as wt, HttpAdapterToken as x, envString as xn, LoggerService as xt, NaviosApplicationOptions as y, PathValue as yn, ConsoleLogger as yt, ForbiddenException as z, LogLevel as zt };
+//# sourceMappingURL=index-BDNl7j1G.d.cts.map