@navios/core 1.0.0-alpha.2 → 1.0.0-alpha.3

package/lib/{index-BJjk2X1S.d.mts → index-BISYCYEG.d.mts}

@@ -979,8 +979,79 @@ type DynamicHandler<TRequest = any, TReply = any> = {
  * 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)[];
+/**
+ * Function type for argument getters that extract data from requests.
+ * Each getter populates a target object with data from the request.
+ */
+type ArgumentGetterFn<TRequest = any> = (target: Record<string, any>, request: TRequest) => void | Promise<void>;
+/**
+ * Function type for formatting arguments from a request.
+ * Built from argument getters, optimized for sync/async handling.
+ */
+type FormatArgumentsFn$1<TRequest = any> = (request: TRequest) => Record<string, any> | Promise<Record<string, any>>;
+/**
+ * Interface for HTTP handler adapter services.
+ *
+ * Adapters handle different types of HTTP requests (REST, streaming, multipart)
+ * and are responsible for:
+ * - Parsing and validating request data
+ * - Creating handler functions
+ * - Formatting responses
+ * - Providing schema information (for frameworks like Fastify)
+ */
+interface AbstractHttpHandlerAdapterInterface<TRequest = any> {
+  /**
+   * Prepares argument getters for parsing request data.
+   *
+   * Creates functions that extract and validate data from the request,
+   * populating a target object with validated arguments.
+   *
+   * @param handlerMetadata - The handler metadata with schemas and configuration.
+   * @returns An array of getter functions that populate request arguments.
+   */
+  prepareArguments?: (handlerMetadata: HandlerMetadata<any>) => ArgumentGetterFn<TRequest>[];
+  /**
+   * Builds a formatArguments function from argument getters.
+   *
+   * Automatically detects sync vs async getters and optimizes accordingly:
+   * - If all getters are sync: returns sync function (no Promise overhead)
+   * - If any getter is async: returns async function with Promise.all
+   * - If no getters: returns frozen empty object (zero allocation)
+   *
+   * This method is useful for composition-based adapters that need to
+   * build formatArguments without duplicating the optimization logic.
+   *
+   * @param getters - Array of argument getter functions
+   * @returns Function to format arguments from request
+   */
+  buildFormatArguments?: (getters: ArgumentGetterFn<TRequest>[]) => FormatArgumentsFn$1<TRequest>;
+  /**
+   * Checks if the handler has any validation schemas defined.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration.
+   * @returns `true` if the handler has any schemas (request, query, response).
+   */
+  hasSchema?: (handlerMetadata: HandlerMetadata<any>) => boolean;
+  /**
+   * Provides schema information for the framework's validation system.
+   *
+   * For frameworks like Fastify, this returns route schema objects.
+   * For frameworks like Bun, this typically returns an empty object.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration.
+   * @returns Schema information for framework registration.
+   */
+  provideSchema?: (handlerMetadata: HandlerMetadata<any>) => Record<string, any>;
+  /**
+   * Creates a request handler function for the endpoint.
+   *
+   * This is the core method that generates the actual handler function
+   * that will be called when a request matches the endpoint.
+   *
+   * @param controller - The controller class containing the handler method.
+   * @param handlerMetadata - The handler metadata with configuration and schemas.
+   * @returns A handler result that is either static or dynamic.
+   */
   provideHandler: (controller: ClassType, handlerMetadata: HandlerMetadata<any>) => Promise<HandlerResult>;
 }
 //#endregion
@@ -2104,180 +2175,6 @@ declare const ValidationErrorResponderToken: InjectionToken<ErrorResponder, unde
  */
 declare const ForbiddenResponderToken: InjectionToken<ErrorResponder, undefined, false>;
 //#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 errorProducer;
-  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
-/**
- * Generates a simple incremental request ID.
- * Much faster than crypto.randomUUID() and sufficient for request tracking.
- *
- * @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.
- *
- * @param enabled - Whether to enable request ID propagation
- */
-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
- * @returns The return value of the function
- */
-declare function runWithRequestId<R>(requestId: string, fn: () => R): R;
-/**
- * Gets the current request ID from the async local storage context.
- *
- * @returns The current request ID, or undefined if not in a request context
- */
-declare function getRequestId(): string | undefined;
-//#endregion
-//#region src/tokens/endpoint-adapter.token.d.mts
-declare const EndpointAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
-//#endregion
-//#region src/tokens/execution-context.token.d.mts
-declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
-declare const ExecutionContext: InjectionToken<AbstractExecutionContext, undefined, false>;
-//#endregion
-//#region src/tokens/http-adapter.token.d.mts
-declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<any, any, any, any>, undefined, false>;
-//#endregion
-//#region src/tokens/multipart-adapter.token.d.mts
-declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
-//#endregion
 //#region src/navios.environment.d.mts
 interface NaviosEnvironmentOptions {
   httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>;
@@ -2522,6 +2419,364 @@ declare class NaviosApplication {
   close(): Promise<void>;
 }
 //#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/abstract-handler-adapter.service.d.mts
+/**
+ * Function type for argument getters that extract data from requests.
+ * Re-exported from interface for convenience in adapter implementations.
+ */
+type ArgumentGetter<TRequest> = ArgumentGetterFn<TRequest>;
+/**
+ * Internal alias for FormatArgumentsFn from interface.
+ * Not re-exported to avoid duplicate exports - use FormatArgumentsFn from interfaces instead.
+ */
+type FormatArgumentsFn<TRequest> = FormatArgumentsFn$1<TRequest>;
+/**
+ * Static handler - can be called without a scoped container.
+ */
+type AbstractStaticHandler<TRequest, TReply = void> = {
+  isStatic: true;
+  handler: (request: TRequest, reply: TReply) => Promise<any>;
+};
+/**
+ * Dynamic handler - requires a scoped container for resolution.
+ */
+type AbstractDynamicHandler<TRequest, TReply = void> = {
+  isStatic: false;
+  handler: (scoped: ScopedContainer, request: TRequest, reply: TReply) => Promise<any>;
+};
+/**
+ * Handler result - either static or dynamic.
+ */
+type AbstractHandlerResult<TRequest, TReply = void> = AbstractStaticHandler<TRequest, TReply> | AbstractDynamicHandler<TRequest, TReply>;
+/**
+ * Context passed to handler creation methods.
+ */
+interface HandlerContext<TConfig extends BaseEndpointOptions = BaseEndpointOptions> {
+  methodName: string;
+  statusCode: number;
+  headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>;
+  handlerMetadata: HandlerMetadata<TConfig>;
+  hasArguments: boolean;
+}
+/**
+ * Abstract base class for HTTP handler adapter services.
+ *
+ * Provides shared logic for:
+ * - Controller resolution (singleton vs request-scoped)
+ * - Argument formatting (sync/async detection)
+ * - Handler generation with static/dynamic branching
+ * - Standardized error handling
+ *
+ * Adapters implement abstract methods for framework-specific behavior:
+ * - Request parsing (query, body, URL params)
+ * - Response creation
+ * - Schema provision
+ *
+ * Supports all adapter types:
+ * - Endpoint adapters: JSON request/response with validation
+ * - Stream adapters: Streaming responses with extra context
+ * - Multipart adapters: Form data parsing (extends endpoint)
+ *
+ * @typeParam TRequest - Framework request type (BunRequest, FastifyRequest)
+ * @typeParam TReply - Framework reply type (void for Bun, FastifyReply)
+ * @typeParam TConfig - Endpoint configuration type
+ */
+declare abstract class AbstractHandlerAdapterService<TRequest, TReply = void, TConfig extends BaseEndpointOptions = BaseEndpointOptions> {
+  protected instanceResolver: InstanceResolverService;
+  protected options: NaviosApplicationOptions;
+  /**
+   * Creates argument getter functions for extracting data from requests.
+   *
+   * Each getter populates a target object with data from the request
+   * (query params, body, URL params, etc.).
+   *
+   * Implementation varies by adapter type:
+   * - Endpoint: JSON body parsing with schema validation
+   * - Stream: Same as endpoint (body + query + url params)
+   * - Multipart: FormData/multipart stream parsing
+   *
+   * @param handlerMetadata - Handler metadata with schemas and configuration
+   * @returns Array of getter functions
+   */
+  protected abstract createArgumentGetters(handlerMetadata: HandlerMetadata<TConfig>): ArgumentGetter<TRequest>[];
+  /**
+   * Creates a static handler for singleton controllers.
+   *
+   * Implementation varies by adapter type:
+   * - Endpoint: Invoke method(args), serialize response as JSON
+   * - Stream: Invoke method(args, streamContext), return Response/use reply
+   *
+   * @param boundMethod - Pre-bound controller method
+   * @param formatArguments - Function to format request arguments
+   * @param context - Handler context with metadata
+   * @returns Static handler result
+   */
+  protected abstract createStaticHandler(boundMethod: (...args: any[]) => Promise<any>, formatArguments: FormatArgumentsFn<TRequest>, context: HandlerContext<TConfig>): AbstractStaticHandler<TRequest, TReply>;
+  /**
+   * Creates a dynamic handler for request-scoped controllers.
+   *
+   * Implementation varies by adapter type:
+   * - Endpoint: Resolve controller per-request, invoke method(args)
+   * - Stream: Resolve controller per-request, invoke method(args, streamContext)
+   *
+   * @param resolution - Instance resolution with resolve function
+   * @param formatArguments - Function to format request arguments
+   * @param context - Handler context with metadata
+   * @returns Dynamic handler result
+   */
+  protected abstract createDynamicHandler(resolution: InstanceResolution, formatArguments: FormatArgumentsFn<TRequest>, context: HandlerContext<TConfig>): AbstractDynamicHandler<TRequest, TReply>;
+  /**
+   * Prepares argument getters for parsing request data.
+   *
+   * Public alias for createArgumentGetters to satisfy interface contracts.
+   * Subclasses should override createArgumentGetters instead.
+   *
+   * @param handlerMetadata - Handler metadata with schemas and configuration
+   * @returns Array of getter functions
+   */
+  prepareArguments(handlerMetadata: HandlerMetadata<TConfig>): ArgumentGetter<TRequest>[];
+  /**
+   * Checks if the handler has any validation schemas defined.
+   *
+   * Override in subclasses to add additional schema checks
+   * (e.g., response schema validation for endpoint adapters).
+   *
+   * @param handlerMetadata - Handler metadata with configuration
+   * @returns true if handler has schemas
+   */
+  hasSchema(handlerMetadata: HandlerMetadata<TConfig>): boolean;
+  /**
+   * Provides schema information for the framework's validation system.
+   *
+   * Override in subclasses for frameworks that support schema registration
+   * (e.g., Fastify). Default returns empty object (suitable for Bun).
+   *
+   * @param handlerMetadata - Handler metadata with configuration
+   * @returns Schema object for framework registration
+   */
+  provideSchema(_handlerMetadata: HandlerMetadata<TConfig>): Record<string, any>;
+  /**
+   * Creates a request handler function for the endpoint.
+   *
+   * This method orchestrates the entire handler creation:
+   * 1. Prepares argument getters for request parsing
+   * 2. Builds optimized formatArguments function (sync/async)
+   * 3. Resolves the controller (singleton vs request-scoped)
+   * 4. Creates appropriate handler (static or dynamic)
+   *
+   * @param controller - Controller class containing the handler method
+   * @param handlerMetadata - Handler metadata with configuration
+   * @returns Handler result (static or dynamic)
+   */
+  provideHandler(controller: ClassType, handlerMetadata: HandlerMetadata<TConfig>): Promise<AbstractHandlerResult<TRequest, TReply>>;
+  /**
+   * Builds a formatArguments function from argument getters.
+   *
+   * Automatically detects sync vs async getters and optimizes accordingly:
+   * - If all getters are sync: returns sync function (no Promise overhead)
+   * - If any getter is async: returns async function with Promise.all
+   * - If no getters: returns frozen empty object (zero allocation)
+   *
+   * This method is public to allow composition-based adapters (like XML adapter)
+   * to reuse the optimized formatArguments logic without inheritance.
+   *
+   * @param getters - Array of argument getter functions
+   * @returns Function to format arguments from request
+   */
+  buildFormatArguments(getters: ArgumentGetter<TRequest>[]): FormatArgumentsFn<TRequest>;
+  /**
+   * Checks if the URL pattern contains URL parameters.
+   *
+   * @param config - Endpoint configuration
+   * @returns true if URL contains '$' parameter markers
+   */
+  protected hasUrlParams(config: TConfig): boolean;
+  /**
+   * Wraps handler execution with standardized error handling.
+   *
+   * Re-throws HttpExceptions as-is for framework error handlers.
+   * Other errors are re-thrown for global error handling.
+   *
+   * @param fn - Handler function to wrap
+   * @returns Wrapped function with error handling
+   */
+  protected wrapWithErrorHandling<T extends (...args: any[]) => Promise<any>>(fn: T): T;
+}
+//#endregion
+//#region src/services/guard-runner.service.d.mts
+declare class GuardRunnerService {
+  private readonly errorProducer;
+  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
+/**
+ * Generates a simple incremental request ID.
+ * Much faster than crypto.randomUUID() and sufficient for request tracking.
+ *
+ * @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.
+ *
+ * @param enabled - Whether to enable request ID propagation
+ */
+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
+ * @returns The return value of the function
+ */
+declare function runWithRequestId<R>(requestId: string, fn: () => R): R;
+/**
+ * Gets the current request ID from the async local storage context.
+ *
+ * @returns The current request ID, or undefined if not in a request context
+ */
+declare function getRequestId(): string | undefined;
+//#endregion
+//#region src/tokens/endpoint-adapter.token.d.mts
+declare const EndpointAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
+//#endregion
+//#region src/tokens/execution-context.token.d.mts
+declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+declare const ExecutionContext: InjectionToken<AbstractExecutionContext, undefined, false>;
+//#endregion
+//#region src/tokens/http-adapter.token.d.mts
+declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<any, any, any, any>, undefined, false>;
+//#endregion
+//#region src/tokens/multipart-adapter.token.d.mts
+declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
+//#endregion
 //#region src/tokens/navios-options.token.d.mts
 declare const NaviosOptionsToken: InjectionToken<NaviosApplicationOptions, undefined, false>;
 //#endregion
@@ -2532,10 +2787,10 @@ declare const Reply: InjectionToken<any, undefined, false>;
 declare const Request: InjectionToken<any, undefined, false>;
 //#endregion
 //#region src/tokens/stream-adapter.token.d.mts
-declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
 //#endregion
 //#region src/tokens/xml-stream-adapter.token.d.mts
-declare const XmlStreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+declare const XmlStreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
 //#endregion
 //#region src/attribute.factory.d.mts
 /**
@@ -2818,5 +3073,5 @@ declare class NaviosFactory {
   private static registerLoggerConfiguration;
 }
 //#endregion
-export { HttpException as $, yellow as $t, ControllerResolverService as A, ConfigServiceToken as An, LoggerInstance as At, InternalServerErrorResponderService as B, isObject as Bt, EndpointAdapterToken as C, ControllerOptions as Cn, AbstractHttpAdapterInterface as Ct, setRequestIdEnabled as D, ConfigService as Dn, LoggerOptions as Dt, runWithRequestId as E, provideConfig as En, Logger as Et, InternalServerErrorResponderToken as F, PathValue as Fn, isConstructor as Ft, ProblemDetails as G, normalizePath as Gt, ErrorResponseProducerService as H, isString as Ht, NotFoundResponderToken as I, envInt as In, isEmpty as It, UnauthorizedException as J, isLogLevel as Jt, FrameworkError as K, stripEndSlash as Kt, ValidationErrorResponderToken as L, envString as Ln, isFunction as Lt, InstanceResolverService as M, Path as Mn, ConsoleLoggerOptions as Mt, MultiInstanceResolution as N, PathImpl as Nn, LoggerService as Nt, GuardRunnerService as O, ConfigServiceOptions as On, LoggerOutput as Ot, ForbiddenResponderToken as P, PathImpl2 as Pn, addLeadingSlash as Pt, BadRequestException as Q, clc as Qt, ValidationErrorResponderService as R, isNil as Rt, ExecutionContextInjectionToken as S, Controller as Sn, StaticHandler as St, getRequestId as T, EnvConfigProvider as Tn, AbstractHttpCorsOptions as Tt, ErrorResponder as U, isSymbol as Ut, ForbiddenResponderService as V, isPlainObject as Vt, ErrorResponse as W, isUndefined as Wt, InternalServerErrorException as X, LOG_LEVELS as Xt, NotFoundException as Y, filterLogLevels as Yt, ForbiddenException as Z, LogLevel as Zt, NaviosApplication as _, getAllEndpointMetadata as _n, OmitIndexSignature as _t, RequestFactory as a, ModuleMetadata as an, MultipartResult as at, HttpAdapterToken as b, EndpointParams as bn, DynamicHandler as bt, EndpointAdapterFactory as c, getModuleMetadata as cn, HttpCode as ct, ClassSchemaAttribute as d, ControllerMetadataKey as dn, PluginContext as dt, AbstractExecutionContext as en, UseGuards as et, XmlStreamAdapterToken as f, extractControllerMetadata as fn, PluginDefinition as ft, NaviosOptionsToken as g, HandlerMetadata as gn, HttpHeader as gt, Reply as h, EndpointMetadataKey as hn, NaviosModule as ht, ReplyFactory as i, hasManagedMetadata as in, MultipartParams as it, InstanceResolution as j, ConfigServiceInterface as jn, ConsoleLogger as jt, ControllerResolution as k, ConfigServiceOptionsSchema as kn, loggerOptionsSchema as kt, AttributeFactory as l, hasModuleMetadata as ln, Header as lt, Request as m, hasControllerMetadata as mn, ModuleLoaderService as mt, XmlStreamAdapterFactory as n, NaviosManagedMetadataKey as nn, StreamParams as nt, MultipartAdapterFactory as o, ModuleMetadataKey as on, Module as ot, StreamAdapterToken as p, getControllerMetadata as pn, ModuleExtension as pt, ConflictException as q, isLogLevelEnabled as qt, StreamAdapterFactory as r, getManagedMetadata as rn, Multipart as rt, HttpAdapterFactory as s, extractModuleMetadata as sn, ModuleOptions as st, NaviosFactory as t, ManagedMetadata as tn, Stream as tt, ClassAttribute as u, ControllerMetadata as un, NaviosPlugin as ut, NaviosApplicationOptions as v, getEndpointMetadata as vn, CanActivate as vt, generateRequestId as w, ConfigProviderOptions as wn, AbstractHttpListenOptions as wt, ExecutionContext as x, EndpointResult as xn, HandlerResult as xt, MultipartAdapterToken as y, Endpoint as yn, AbstractHttpHandlerAdapterInterface as yt, NotFoundResponderService as z, isNumber as zt };
-//# sourceMappingURL=index-BJjk2X1S.d.mts.map
+export { ConflictException as $, normalizePath as $t, AbstractStaticHandler as A, Controller as An, StaticHandler as At, ForbiddenResponderToken as B, Path as Bn, ConsoleLoggerOptions as Bt, getRequestId as C, EndpointMetadataKey as Cn, OmitIndexSignature as Ct, AbstractDynamicHandler as D, Endpoint as Dn, DynamicHandler as Dt, GuardRunnerService as E, getEndpointMetadata as En, ArgumentGetterFn as Et, InstanceResolution as F, ConfigService as Fn, LoggerOptions as Ft, NotFoundResponderService as G, envString as Gn, isFunction as Gt, NotFoundResponderToken as H, PathImpl2 as Hn, addLeadingSlash as Ht, InstanceResolverService as I, ConfigServiceOptions as In, LoggerOutput as It, ErrorResponseProducerService as J, isObject as Jt, InternalServerErrorResponderService as K, isNil as Kt, MultiInstanceResolution as L, ConfigServiceOptionsSchema as Ln, loggerOptionsSchema as Lt, HandlerContext as M, ConfigProviderOptions as Mn, AbstractHttpListenOptions as Mt, ControllerResolution as N, EnvConfigProvider as Nn, AbstractHttpCorsOptions as Nt, AbstractHandlerAdapterService as O, EndpointParams as On, FormatArgumentsFn$1 as Ot, ControllerResolverService as P, provideConfig as Pn, Logger as Pt, FrameworkError as Q, isUndefined as Qt, NaviosApplication as R, ConfigServiceToken as Rn, LoggerInstance as Rt, generateRequestId as S, hasControllerMetadata as Sn, HttpHeader as St, setRequestIdEnabled as T, getAllEndpointMetadata as Tn, AbstractHttpHandlerAdapterInterface as Tt, ValidationErrorResponderToken as U, PathValue as Un, isConstructor as Ut, InternalServerErrorResponderToken as V, PathImpl as Vn, LoggerService as Vt, ValidationErrorResponderService as W, envInt as Wn, isEmpty as Wt, ErrorResponse as X, isString as Xt, ErrorResponder as Y, isPlainObject as Yt, ProblemDetails as Z, isSymbol as Zt, MultipartAdapterToken as _, hasModuleMetadata as _n, PluginContext as _t, RequestFactory as a, LogLevel as an, HttpException as at, ExecutionContextInjectionToken as b, extractControllerMetadata as bn, ModuleLoaderService as bt, EndpointAdapterFactory as c, AbstractExecutionContext as cn, StreamParams as ct, ClassSchemaAttribute as d, getManagedMetadata as dn, MultipartResult as dt, stripEndSlash as en, UnauthorizedException as et, XmlStreamAdapterToken as f, hasManagedMetadata as fn, Module as ft, NaviosOptionsToken as g, getModuleMetadata as gn, NaviosPlugin as gt, Reply as h, extractModuleMetadata as hn, Header as ht, ReplyFactory as i, LOG_LEVELS as in, BadRequestException as it, ArgumentGetter as j, ControllerOptions as jn, AbstractHttpAdapterInterface as jt, AbstractHandlerResult as k, EndpointResult as kn, HandlerResult as kt, AttributeFactory as l, ManagedMetadata as ln, Multipart as lt, Request as m, ModuleMetadataKey as mn, HttpCode as mt, XmlStreamAdapterFactory as n, isLogLevel as nn, InternalServerErrorException as nt, MultipartAdapterFactory as o, clc as on, UseGuards as ot, StreamAdapterToken as p, ModuleMetadata as pn, ModuleOptions as pt, ForbiddenResponderService as q, isNumber as qt, StreamAdapterFactory as r, filterLogLevels as rn, ForbiddenException as rt, HttpAdapterFactory as s, yellow as sn, Stream as st, NaviosFactory as t, isLogLevelEnabled as tn, NotFoundException as tt, ClassAttribute as u, NaviosManagedMetadataKey as un, MultipartParams as ut, HttpAdapterToken as v, ControllerMetadata as vn, PluginDefinition as vt, runWithRequestId as w, HandlerMetadata as wn, CanActivate as wt, EndpointAdapterToken as x, getControllerMetadata as xn, NaviosModule as xt, ExecutionContext as y, ControllerMetadataKey as yn, ModuleExtension as yt, NaviosApplicationOptions as z, ConfigServiceInterface as zn, ConsoleLogger as zt };
+//# sourceMappingURL=index-BISYCYEG.d.mts.map