@navios/core 0.7.1 → 0.9.0

package/lib/{index-pHp-dIGt.d.cts → index-Db1d3cwD.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, InjectableScope, 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,21 @@ 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;
+  /**
+   * Priority to use for the controller.
+   * Priority is used to sort the controller in the registry.
+   */
+  priority?: number;
+  /**
+   * Scope to use for the controller.
+   * Scope is used to determine the scope of the controller.
+   */
+  scope?: InjectableScope;
 }
 /**
  * Decorator that marks a class as a Navios controller.
@@ -242,7 +256,10 @@ interface ControllerOptions {
  * ```
  */
 declare function Controller({
-  guards
+  guards,
+  registry,
+  priority,
+  scope
 }?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 //#endregion
 //#region src/decorators/endpoint.decorator.d.mts
@@ -328,9 +345,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;
@@ -914,9 +934,30 @@ interface AbstractHttpAdapterInterface<ServerInstance, CorsOptions = AbstractHtt
 }
 //#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
@@ -1212,6 +1253,16 @@ interface ModuleOptions {
    * Guards are executed in reverse order (last guard first).
    */
   guards?: ClassType[] | Set<ClassType>;
+  /**
+   * Priority to use for the module.
+   * Priority is used to sort the module in the registry.
+   */
+  priority?: number;
+  /**
+   * Registry to use for the module.
+   * Registry is used to store the module and its controllers.
+   */
+  registry?: Registry;
 }
 /**
  * Decorator that marks a class as a Navios module.
@@ -1235,7 +1286,9 @@ interface ModuleOptions {
 declare function Module({
   controllers,
   imports,
-  guards
+  guards,
+  priority,
+  registry
 }?: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 //#endregion
 //#region src/decorators/multipart.decorator.d.mts
@@ -1286,9 +1339,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
 /**
@@ -1327,9 +1383,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
 /**
@@ -1569,37 +1631,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/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
@@ -1626,345 +1804,128 @@ 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
-/**
- * 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;
-};
+//#region src/navios.application.d.mts
 /**
- * Type for a class attribute decorator with a validated value.
- *
- * @typeParam T - The Zod schema type for validation
+ * Options for configuring the Navios application context.
+ * These options control the application configuration.
  */
-type ClassSchemaAttribute<T extends ZodType> = ((value: z$1.input<T>) => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
-  token: symbol;
-  schema: ZodType;
-};
+interface NaviosApplicationOptions {
+  /**
+   * 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 registry to use. Useful for testing.
+   * If not provided, a new Registry will be created.
+   */
+  registry?: Registry;
+  /**
+   * Specifies a custom container to use. Useful for testing.
+   * If not provided, a new Container will be created.
+   */
+  container?: Container;
+  /**
+   * HTTP adapter environment(s) to use for the application.
+   * Can be a single adapter or an array of adapters.
+   *
+   * @example
+   * ```typescript
+   * adapter: defineFastifyEnvironment()
+   * // or
+   * adapter: [defineFastifyEnvironment(), defineBunEnvironment()]
+   * ```
+   */
+  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;
+}
 /**
- * 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 { }
+ * Main application class for Navios.
  *
- * // Check if attribute exists
- * if (AttributeFactory.has(Public, controllerMetadata)) {
- *   // Skip authentication
- * }
- * ```
+ * This class represents a Navios application instance and provides methods
+ * for initializing, configuring, and managing the HTTP server.
  *
  * @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() { }
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: defineFastifyEnvironment(),
+ * })
  *
- * // Get the value
- * const limit = AttributeFactory.get(RateLimit, endpointMetadata)
- * // limit is typed as { requests: number, window: number } | null
+ * app.setGlobalPrefix('/api')
+ * app.enableCors({ origin: ['http://localhost:3000'] })
+ * await app.init()
+ * await app.listen({ port: 3000, host: '0.0.0.0' })
  * ```
  */
-declare class AttributeFactory {
+declare class NaviosApplication {
+  private environment;
+  private moduleLoader;
+  private httpApplication;
+  private logger;
+  protected container: Container;
+  private appModule;
+  private options;
+  private plugins;
   /**
-   * 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
+   * Indicates whether the application has been initialized.
+   * Set to `true` after `init()` completes successfully.
+   */
+  isInitialized: boolean;
+  /**
+   * Sets up the application with the provided module and options.
+   * This is called automatically by NaviosFactory.create().
    *
-   * @example
-   * ```typescript
-   * const Public = AttributeFactory.createAttribute(Symbol.for('Public'))
+   * @param appModule - The root application module
+   * @param options - Application configuration options
+   * @internal
+   */
+  setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<void>;
+  /**
+   * Gets the dependency injection container used by this application.
    *
-   * @Public()
-   * @Controller()
-   * export class PublicController { }
-   * ```
+   * @returns The Container instance
    */
-  static createAttribute(token: symbol): ClassAttribute;
+  getContainer(): Container;
   /**
-   * Creates an attribute decorator with a validated value.
+   * Registers a plugin to be initialized after modules are loaded.
    *
-   * @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
+   * 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
-   * const RateLimit = AttributeFactory.createAttribute(
-   *   Symbol.for('RateLimit'),
-   *   z.object({ requests: z.number(), window: z.number() })
-   * )
+   * import { defineOpenApiPlugin } from '@navios/openapi-fastify'
    *
-   * @RateLimit({ requests: 100, window: 60000 })
-   * @Endpoint(apiEndpoint)
-   * async handler() { }
+   * app.usePlugin(defineOpenApiPlugin({
+   *   info: { title: 'My API', version: '1.0.0' },
+   * }))
    * ```
    */
-  static createAttribute<T extends ZodType>(token: symbol, schema: T): ClassSchemaAttribute<T>;
+  usePlugin<TOptions>(definition: PluginDefinition<TOptions>): this;
   /**
-   * 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.
- */
-interface NaviosApplicationOptions extends NaviosApplicationContextOptions {
-  /**
-   * HTTP adapter environment(s) to use for the application.
-   * Can be a single adapter or an array of adapters.
-   *
-   * @example
-   * ```typescript
-   * adapter: defineFastifyEnvironment()
-   * // or
-   * adapter: [defineFastifyEnvironment(), defineBunEnvironment()]
-   * ```
-   */
-  adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[];
-}
-/**
- * Main application class for Navios.
- *
- * This class represents a Navios application instance and provides methods
- * for initializing, configuring, and managing the HTTP server.
- *
- * @example
- * ```typescript
- * const app = await NaviosFactory.create(AppModule, {
- *   adapter: defineFastifyEnvironment(),
- * })
- *
- * app.setGlobalPrefix('/api')
- * app.enableCors({ origin: ['http://localhost:3000'] })
- * await app.init()
- * await app.listen({ port: 3000, host: '0.0.0.0' })
- * ```
- */
-declare class NaviosApplication {
-  private environment;
-  private moduleLoader;
-  private httpApplication;
-  private logger;
-  protected container: Container;
-  private appModule;
-  private options;
-  private plugins;
-  /**
-   * Indicates whether the application has been initialized.
-   * Set to `true` after `init()` completes successfully.
-   */
-  isInitialized: boolean;
-  /**
-   * Sets up the application with the provided module and options.
-   * This is called automatically by NaviosFactory.create().
-   *
-   * @param appModule - The root application module
-   * @param options - Application configuration options
-   * @internal
-   */
-  setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<void>;
-  /**
-   * Gets the dependency injection container used by this application.
-   *
-   * @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.
+   * Initializes the application.
    *
    * This method:
    * - Loads all modules and their dependencies
@@ -2087,6 +2048,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.
@@ -2152,5 +2344,5 @@ declare class NaviosFactory {
   private static registerLoggerConfiguration;
 }
 //#endregion
-export { CanActivate as $, EnvConfigProvider as $t, NotFoundException as A, clc as At, MultipartResult as B, extractControllerMetadata as Bt, EndpointAdapterToken as C, normalizePath as Ct, GuardRunnerService as D, filterLogLevels as Dt, runWithRequestId as E, isLogLevel as Et, UseGuards as F, extractModuleMetadata as Ft, NaviosPlugin as G, getAllEndpointMetadata as Gt, ModuleOptions as H, hasControllerMetadata as Ht, Stream as I, getModuleMetadata as It, ModuleExtension as J, EndpointParams as Jt, PluginContext as K, getEndpointMetadata as Kt, StreamParams as L, hasModuleMetadata as Lt, ForbiddenException as M, AbstractExecutionContext as Mt, BadRequestException as N, ModuleMetadata as Nt, ConflictException as O, LOG_LEVELS as Ot, HttpException as P, ModuleMetadataKey as Pt, OmitIndexSignature as Q, ConfigProviderOptions as Qt, Multipart as R, ControllerMetadata as Rt, ExecutionContextInjectionToken as S, isUndefined as St, requestIdStore as T, isLogLevelEnabled as Tt, HttpCode as U, EndpointMetadataKey as Ut, Module as V, getControllerMetadata as Vt, Header as W, HandlerMetadata as Wt, NaviosModule as X, Controller as Xt, ModuleLoaderService as Y, EndpointResult as Yt, HttpHeader as Z, ControllerOptions as Zt, Request as _, isNumber as _t, XmlStreamAdapterFactory as a, ConfigServiceInterface as an, LoggerOptions as at, HttpAdapterToken as b, isString as bt, RequestFactory as c, PathImpl2 as cn, LoggerInstance as ct, EndpointAdapterFactory as d, envString as dn, LoggerService as dt, provideConfig as en, AbstractHttpHandlerAdapterInterface as et, AttributeFactory as f, addLeadingSlash as ft, StreamAdapterToken as g, isNil as gt, XmlStreamAdapterToken as h, isFunction as ht, NaviosApplicationOptions as i, ConfigServiceToken as in, Logger as it, InternalServerErrorException as j, yellow as jt, UnauthorizedException as k, LogLevel as kt, MultipartAdapterFactory as l, PathValue as ln, ConsoleLogger as lt, ClassSchemaAttribute as m, isEmpty as mt, NaviosApplication as n, ConfigServiceOptions as nn, AbstractHttpListenOptions as nt, StreamAdapterFactory as o, Path as on, LoggerOutput as ot, ClassAttribute as p, isConstructor as pt, PluginDefinition as q, Endpoint as qt, NaviosApplicationContextOptions as r, ConfigServiceOptionsSchema as rn, AbstractHttpCorsOptions as rt, ReplyFactory as s, PathImpl as sn, loggerOptionsSchema as st, NaviosFactory as t, ConfigService as tn, AbstractHttpAdapterInterface as tt, HttpAdapterFactory as u, envInt as un, ConsoleLoggerOptions as ut, Reply as v, isObject as vt, getRequestId as w, stripEndSlash as wt, ExecutionContext as x, isSymbol as xt, MultipartAdapterToken as y, isPlainObject as yt, MultipartParams as z, ControllerMetadataKey as zt };
-//# sourceMappingURL=index-pHp-dIGt.d.cts.map
+export { PluginDefinition as $, HandlerMetadata as $t, ControllerResolverService as A, isSymbol as At, HttpException as B, yellow as Bt, EndpointAdapterToken as C, isEmpty as Ct, setRequestIdEnabled as D, isObject as Dt, runWithRequestId as E, isNumber as Et, UnauthorizedException as F, isLogLevel as Ft, MultipartParams as G, getModuleMetadata as Gt, Stream as H, ModuleMetadata as Ht, NotFoundException as I, filterLogLevels as It, ModuleOptions as J, ControllerMetadataKey as Jt, MultipartResult as K, hasModuleMetadata as Kt, InternalServerErrorException as L, LOG_LEVELS as Lt, InstanceResolverService as M, normalizePath as Mt, MultiInstanceResolution as N, stripEndSlash as Nt, GuardRunnerService as O, isPlainObject as Ot, ConflictException as P, isLogLevelEnabled as Pt, PluginContext as Q, EndpointMetadataKey as Qt, ForbiddenException as R, LogLevel as Rt, ExecutionContextInjectionToken as S, isConstructor as St, getRequestId as T, isNil as Tt, StreamParams as U, ModuleMetadataKey as Ut, UseGuards as V, AbstractExecutionContext as Vt, Multipart as W, extractModuleMetadata as Wt, Header as X, getControllerMetadata as Xt, HttpCode as Y, extractControllerMetadata as Yt, NaviosPlugin as Z, hasControllerMetadata as Zt, NaviosApplication as _, PathImpl2 as _n, LoggerInstance as _t, RequestFactory as a, Controller as an, CanActivate as at, HttpAdapterToken as b, envString as bn, LoggerService as bt, EndpointAdapterFactory as c, EnvConfigProvider as cn, HandlerResult as ct, ClassSchemaAttribute as d, ConfigServiceOptions as dn, AbstractHttpListenOptions as dt, getAllEndpointMetadata as en, ModuleExtension as et, XmlStreamAdapterToken as f, ConfigServiceOptionsSchema as fn, AbstractHttpCorsOptions as ft, NaviosOptionsToken as g, PathImpl as gn, loggerOptionsSchema as gt, Reply as h, Path as hn, LoggerOutput as ht, ReplyFactory as i, EndpointResult as in, OmitIndexSignature as it, InstanceResolution as j, isUndefined as jt, ControllerResolution as k, isString as kt, AttributeFactory as l, provideConfig as ln, StaticHandler as lt, Request as m, ConfigServiceInterface as mn, LoggerOptions as mt, XmlStreamAdapterFactory as n, Endpoint as nn, NaviosModule as nt, MultipartAdapterFactory as o, ControllerOptions as on, AbstractHttpHandlerAdapterInterface as ot, StreamAdapterToken as p, ConfigServiceToken as pn, Logger as pt, Module as q, ControllerMetadata as qt, StreamAdapterFactory as r, EndpointParams as rn, HttpHeader as rt, HttpAdapterFactory as s, ConfigProviderOptions as sn, DynamicHandler as st, NaviosFactory as t, getEndpointMetadata as tn, ModuleLoaderService as tt, ClassAttribute as u, ConfigService as un, AbstractHttpAdapterInterface as ut, NaviosApplicationOptions as v, PathValue as vn, ConsoleLogger as vt, generateRequestId as w, isFunction as wt, ExecutionContext as x, addLeadingSlash as xt, MultipartAdapterToken as y, envInt as yn, ConsoleLoggerOptions as yt, BadRequestException as z, clc as zt };
+//# sourceMappingURL=index-Db1d3cwD.d.cts.map