@navios/core 0.7.1 → 0.8.0

package/lib/{index-pHp-dIGt.d.cts → index-BoP0cWT6.d.mts}

@@ -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;
@@ -914,9 +922,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
@@ -1286,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
 /**
@@ -1327,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
 /**
@@ -1569,37 +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/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,354 +1780,138 @@ 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
+ * Complete options for creating a Navios application.
+ * Extends NaviosApplicationContextOptions with adapter configuration.
  */
-type ClassSchemaAttribute<T extends ZodType> = ((value: z$1.input<T>) => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
-  token: symbol;
-  schema: ZodType;
-};
+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[];
+  /**
+   * 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.
+   * Initializes the application.
    *
-   * Returns `null` if the attribute is not present.
-   * For simple attributes (without values), returns `true` if present.
+   * This method:
+   * - 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
    *
-   * @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.
-   *
-   * This method:
-   * - 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()`.
+   * Must be called before `listen()`.
    *
    * @throws Error if app module is not set
    *
@@ -2087,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.
@@ -2152,5 +2321,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 { 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-BoP0cWT6.d.mts.map