@navios/core 0.4.0 → 0.5.0

package/lib/_tsup-dts-rollup.d.ts

@@ -1,5 +1,8 @@
+import { AnyInjectableType } from '@navios/di';
+import { asyncInject } from '@navios/di';
 import type { BaseEndpointConfig } from '@navios/builder';
 import { BaseInjectionTokenSchemaType } from '@navios/di';
+import { BaseInstanceHolderManager } from '@navios/di';
 import type { BaseStreamConfig } from '@navios/builder';
 import { BoundInjectionToken } from '@navios/di';
 import { ChannelEmitter } from '@navios/di';
@@ -9,7 +12,12 @@ import { ClassTypeWithInstance } from '@navios/di';
 import { ClassTypeWithInstanceAndArgument } from '@navios/di';
 import { ClassTypeWithInstanceAndOptionalArgument } from '@navios/di';
 import { ClassTypeWithOptionalArgument } from '@navios/di';
-import { CreateInjectorsOptions } from '@navios/di';
+import { Container } from '@navios/di';
+import { createDeferred } from '@navios/di';
+import { createRequestContextHolder } from '@navios/di';
+import { defaultInjectors } from '@navios/di';
+import { DefaultRequestContextHolder } from '@navios/di';
+import { Deferred } from '@navios/di';
 import type { EndpointFunctionArgs } from '@navios/builder';
 import { ErrorsEnum } from '@navios/di';
 import { EventEmitter } from '@navios/di';
@@ -17,55 +25,45 @@ import { EventEmitterInterface } from '@navios/di';
 import { EventsArgs } from '@navios/di';
 import { EventsConfig } from '@navios/di';
 import { EventsNames } from '@navios/di';
+import { Factorable } from '@navios/di';
+import { FactorableWithArgs } from '@navios/di';
 import { Factory } from '@navios/di';
 import { FactoryContext } from '@navios/di';
 import { FactoryInjectionToken } from '@navios/di';
 import { FactoryNotFound } from '@navios/di';
+import { FactoryOptions } from '@navios/di';
 import { FactoryRecord } from '@navios/di';
 import { FactoryTokenNotResolved } from '@navios/di';
-import { FactoryWithArgs } from '@navios/di';
-import { FastifyBaseLogger } from 'fastify';
-import type { FastifyCorsOptions } from '@fastify/cors';
-import type { FastifyInstance } from 'fastify';
-import type { FastifyListenOptions } from 'fastify';
-import type { FastifyMultipartOptions } from '@fastify/multipart';
-import type { FastifyReply } from 'fastify';
-import type { FastifyRequest } from 'fastify';
-import { FastifySchema } from 'fastify';
-import type { FastifyServerOptions } from 'fastify';
-import { FastifyTypeProviderDefault } from 'fastify';
-import { getGlobalServiceLocator } from '@navios/di';
 import { getInjectableToken } from '@navios/di';
 import { getInjectors } from '@navios/di';
 import { globalRegistry } from '@navios/di';
-import type { HttpHeader } from 'fastify/types/utils.js';
 import type { HttpMethod } from '@navios/builder';
-import { IncomingMessage } from 'http';
 import { inject } from '@navios/di';
 import { Injectable } from '@navios/di';
 import { InjectableOptions } from '@navios/di';
 import { InjectableScope } from '@navios/di';
 import { InjectableTokenMeta } from '@navios/di';
 import { InjectableType } from '@navios/di';
-import { InjectionFactory } from '@navios/di';
 import { InjectionToken } from '@navios/di';
 import { InjectionTokenSchemaType } from '@navios/di';
+import { InjectionTokenType } from '@navios/di';
 import { Injectors } from '@navios/di';
-import { InjectorsBase } from '@navios/di';
+import { InjectState } from '@navios/di';
 import type { InspectOptions } from 'util';
 import { InstanceDestroying } from '@navios/di';
 import { InstanceExpired } from '@navios/di';
 import { InstanceNotFound } from '@navios/di';
-import { makeProxyServiceLocator } from '@navios/di';
+import { IsUnion } from '@navios/di';
+import { Join } from '@navios/di';
+import { OnServiceDestroy } from '@navios/di';
+import { OnServiceInit } from '@navios/di';
 import { OptionalInjectionTokenSchemaType } from '@navios/di';
-import { provideServiceLocator } from '@navios/di';
-import { ProxyServiceLocator } from '@navios/di';
-import { RawServerDefault } from 'fastify';
+import type { OutgoingHttpHeaders } from 'http';
+import { PopUnion } from '@navios/di';
+import { provideFactoryContext } from '@navios/di';
 import { Registry } from '@navios/di';
-import { ResolveFastifyRequestType } from 'fastify/types/type-provider.js';
-import { resolveService } from '@navios/di';
-import { RouteGenericInterface } from 'fastify';
-import { ServerResponse } from 'http';
+import { RequestContextHolder } from '@navios/di';
+import { ServiceInstantiator } from '@navios/di';
 import { ServiceLocator } from '@navios/di';
 import { ServiceLocatorEventBus } from '@navios/di';
 import { ServiceLocatorInstanceDestroyListener } from '@navios/di';
@@ -74,10 +72,12 @@ import { ServiceLocatorInstanceHolder } from '@navios/di';
 import { ServiceLocatorInstanceHolderCreated } from '@navios/di';
 import { ServiceLocatorInstanceHolderCreating } from '@navios/di';
 import { ServiceLocatorInstanceHolderDestroying } from '@navios/di';
-import { ServiceLocatorInstanceHolderKind } from '@navios/di';
+import { ServiceLocatorInstanceHolderError } from '@navios/di';
 import { ServiceLocatorInstanceHolderStatus } from '@navios/di';
 import { ServiceLocatorManager } from '@navios/di';
-import { syncInject } from '@navios/di';
+import { UnionToArray } from '@navios/di';
+import { UnionToIntersection } from '@navios/di';
+import { UnionToOvlds } from '@navios/di';
 import { UnknownError } from '@navios/di';
 import type { Util_FlatObject } from '@navios/builder';
 import { wrapSyncInit } from '@navios/di';
@@ -86,16 +86,115 @@ import { ZodDiscriminatedUnion } from 'zod/v4';
 import type { ZodObject } from 'zod/v4';
 import type { ZodType } from 'zod/v4';
 
+declare interface AbstractExecutionContext {
+    getModule(): ModuleMetadata;
+    getController(): ControllerMetadata;
+    getHandler(): HandlerMetadata;
+    getRequest(): any;
+    getReply(): any;
+}
+export { AbstractExecutionContext }
+export { AbstractExecutionContext as AbstractExecutionContext_alias_1 }
+export { AbstractExecutionContext as AbstractExecutionContext_alias_2 }
+
+declare interface AbstractHttpAdapterInterface<ServerInstance, CorsOptions = AbstractHttpCorsOptions, Options = {}, MultipartOptions = {}> {
+    setupHttpServer(options: Options): Promise<void>;
+    onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;
+    ready(): Promise<void>;
+    getServer(): ServerInstance;
+    setGlobalPrefix(prefix: string): void;
+    enableCors(options: CorsOptions): void;
+    enableMultipart(options: MultipartOptions): void;
+    listen(options: AbstractHttpListenOptions): Promise<string>;
+    dispose(): Promise<void>;
+}
+export { AbstractHttpAdapterInterface }
+export { AbstractHttpAdapterInterface as AbstractHttpAdapterInterface_alias_1 }
+export { AbstractHttpAdapterInterface as AbstractHttpAdapterInterface_alias_2 }
+
+declare interface AbstractHttpCorsOptions {
+    /**
+     * Configures the Access-Control-Allow-Origin CORS header.
+     */
+    origin?: ValueOrArray<OriginType>;
+    /**
+     * Configures the Access-Control-Allow-Credentials CORS header.
+     * Set to true to pass the header, otherwise it is omitted.
+     */
+    credentials?: boolean;
+    /**
+     * Configures the Access-Control-Expose-Headers CORS header.
+     * Expects a comma-delimited string (ex: 'Content-Range,X-Content-Range')
+     * or an array (ex: ['Content-Range', 'X-Content-Range']).
+     * If not specified, no custom headers are exposed.
+     */
+    exposedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Headers CORS header.
+     * Expects a comma-delimited string (ex: 'Content-Type,Authorization')
+     * or an array (ex: ['Content-Type', 'Authorization']). If not
+     * specified, defaults to reflecting the headers specified in the
+     * request's Access-Control-Request-Headers header.
+     */
+    allowedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Methods CORS header.
+     * Expects a comma-delimited string (ex: 'GET,PUT,POST') or an array (ex: ['GET', 'PUT', 'POST']).
+     */
+    methods?: string | string[];
+    /**
+     * Configures the Access-Control-Max-Age CORS header.
+     * Set to an integer to pass the header, otherwise it is omitted.
+     */
+    maxAge?: number;
+    /**
+     * Configures the Cache-Control header for CORS preflight responses.
+     * Set to an integer to pass the header as `Cache-Control: max-age=${cacheControl}`,
+     * or set to a string to pass the header as `Cache-Control: ${cacheControl}` (fully define
+     * the header value), otherwise the header is omitted.
+     */
+    cacheControl?: number | string;
+    /**
+     * Sets the Fastify log level specifically for the internal OPTIONS route
+     * used to handle CORS preflight requests. For example, setting this to `'silent'`
+     * will prevent these requests from being logged.
+     * Useful for reducing noise in application logs.
+     * Default: inherits Fastify's global log level.
+     */
+    logLevel?: LogLevel;
+}
+export { AbstractHttpCorsOptions }
+export { AbstractHttpCorsOptions as AbstractHttpCorsOptions_alias_1 }
+export { AbstractHttpCorsOptions as AbstractHttpCorsOptions_alias_2 }
+
+declare interface AbstractHttpHandlerAdapterInterface {
+    prepareArguments?: (handlerMetadata: HandlerMetadata<any>) => ((target: Record<string, any>, request: any) => Promise<void> | void)[];
+    provideHandler: (controller: ClassType, handlerMetadata: HandlerMetadata<any>) => (context: RequestContextHolder, request: any, reply: any) => Promise<any>;
+}
+export { AbstractHttpHandlerAdapterInterface }
+export { AbstractHttpHandlerAdapterInterface as AbstractHttpHandlerAdapterInterface_alias_1 }
+export { AbstractHttpHandlerAdapterInterface as AbstractHttpHandlerAdapterInterface_alias_2 }
+
+declare interface AbstractHttpListenOptions {
+    port: number;
+    host?: string;
+}
+export { AbstractHttpListenOptions }
+export { AbstractHttpListenOptions as AbstractHttpListenOptions_alias_1 }
+export { AbstractHttpListenOptions as AbstractHttpListenOptions_alias_2 }
+
 declare const addLeadingSlash: (path?: string) => string;
 export { addLeadingSlash }
 export { addLeadingSlash as addLeadingSlash_alias_1 }
 export { addLeadingSlash as addLeadingSlash_alias_2 }
 export { addLeadingSlash as addLeadingSlash_alias_3 }
 
-declare const Application: InjectionToken<FastifyInstance<RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, FastifyBaseLogger, FastifyTypeProviderDefault>, undefined, false>;
-export { Application }
-export { Application as Application_alias_1 }
-export { Application as Application_alias_2 }
+export { AnyInjectableType }
+
+declare interface ArrayOfValueOrArray<T> extends Array<ValueOrArray<T>> {
+}
+
+export { asyncInject }
 
 declare class AttributeFactory {
     static createAttribute(token: symbol): ClassAttribute;
@@ -121,10 +220,12 @@ export { BadRequestException as BadRequestException_alias_2 }
 
 export { BaseInjectionTokenSchemaType }
 
+export { BaseInstanceHolderManager }
+
 export { BoundInjectionToken }
 
 declare interface CanActivate {
-    canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean;
+    canActivate(executionContext: AbstractExecutionContext): Promise<boolean> | boolean;
 }
 export { CanActivate }
 export { CanActivate as CanActivate_alias_1 }
@@ -234,10 +335,6 @@ declare class ConsoleLogger implements LoggerService {
      * The context of the logger (can be set manually or automatically inferred).
      */
     protected context?: string;
-    /**
-     * Request ID (if enabled).
-     */
-    protected requestId: string | null;
     /**
      * The original context of the logger (set in the constructor).
      */
@@ -249,11 +346,11 @@ declare class ConsoleLogger implements LoggerService {
     /**
      * The last timestamp at which the log message was printed.
      */
-    protected static lastTimestampAt?: number;
-    constructor();
-    constructor(context: string);
-    constructor(options: ConsoleLoggerOptions);
-    constructor(context: string, options: ConsoleLoggerOptions);
+    protected lastTimestampAt?: number;
+    setup(): void;
+    setup(context: string): void;
+    setup(options: ConsoleLoggerOptions): void;
+    setup(context: string, options: ConsoleLoggerOptions): void;
     /**
      * Write a 'log' level log, if the configured level allows for it.
      * Prints to `stdout` with newline.
@@ -307,17 +404,18 @@ declare class ConsoleLogger implements LoggerService {
     resetContext(): void;
     isLevelEnabled(level: LogLevel): boolean;
     protected getTimestamp(): string;
-    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, writeStreamType?: 'stdout' | 'stderr', errorStack?: unknown): void;
+    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, requestId?: string, writeStreamType?: 'stdout' | 'stderr', errorStack?: unknown): void;
     protected printAsJson(message: unknown, options: {
         context: string;
         logLevel: LogLevel;
         writeStreamType?: 'stdout' | 'stderr';
         errorStack?: unknown;
+        requestId?: string;
     }): void;
     protected formatPid(pid: number): string;
     protected formatContext(context: string): string;
-    protected formatMessage(logLevel: LogLevel, message: unknown, pidMessage: string, formattedLogLevel: string, contextMessage: string, timestampDiff: string): string;
-    protected getRequestId(): string;
+    protected formatMessage(logLevel: LogLevel, message: unknown, pidMessage: string, formattedLogLevel: string, contextMessage: string, timestampDiff: string, requestId?: string): string;
+    protected getRequestId(requestId?: string): string;
     protected stringifyMessage(message: unknown, logLevel: LogLevel): string;
     protected colorize(message: string, logLevel: LogLevel): string;
     protected printStackTrace(stack: string): void;
@@ -420,22 +518,13 @@ export { ConsoleLoggerOptions }
 export { ConsoleLoggerOptions as ConsoleLoggerOptions_alias_1 }
 export { ConsoleLoggerOptions as ConsoleLoggerOptions_alias_2 }
 
+export { Container }
+
 declare function Controller({ guards }?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 export { Controller }
 export { Controller as Controller_alias_1 }
 export { Controller as Controller_alias_2 }
 
-declare class ControllerAdapterService {
-    guardRunner: GuardRunnerService;
-    private logger;
-    setupController(controller: ClassType, instance: FastifyInstance, moduleMetadata: ModuleMetadata): Promise<void>;
-    providePreHandler(executionContext: ExecutionContext): ((request: FastifyRequest, reply: FastifyReply) => Promise<void>) | undefined;
-    private wrapHandler;
-}
-export { ControllerAdapterService }
-export { ControllerAdapterService as ControllerAdapterService_alias_1 }
-export { ControllerAdapterService as ControllerAdapterService_alias_2 }
-
 declare interface ControllerMetadata {
     endpoints: Set<HandlerMetadata>;
     guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
@@ -457,7 +546,15 @@ export { ControllerOptions }
 export { ControllerOptions as ControllerOptions_alias_1 }
 export { ControllerOptions as ControllerOptions_alias_2 }
 
-export { CreateInjectorsOptions }
+export { createDeferred }
+
+export { createRequestContextHolder }
+
+export { defaultInjectors }
+
+export { DefaultRequestContextHolder }
+
+export { Deferred }
 
 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>;
@@ -466,16 +563,15 @@ export { Endpoint }
 export { Endpoint as Endpoint_alias_1 }
 export { Endpoint as Endpoint_alias_2 }
 
-declare class EndpointAdapterService extends StreamAdapterService {
-    hasSchema(handlerMetadata: HandlerMetadata<BaseEndpointConfig>): boolean;
-    provideSchema(handlerMetadata: HandlerMetadata<BaseEndpointConfig>): Record<string, any>;
-    provideHandler(controller: ClassType, executionContext: ExecutionContext, handlerMetadata: HandlerMetadata<BaseEndpointConfig>): (request: FastifyRequest, reply: FastifyReply) => Promise<any>;
+declare class EndpointAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
 }
-export { EndpointAdapterService }
-export { EndpointAdapterService as EndpointAdapterService_alias_1 }
-export { EndpointAdapterService as EndpointAdapterService_alias_2 }
+export { EndpointAdapterFactory }
+export { EndpointAdapterFactory as EndpointAdapterFactory_alias_1 }
+export { EndpointAdapterFactory as EndpointAdapterFactory_alias_2 }
 
-declare const EndpointAdapterToken: InjectionToken<EndpointAdapterService, undefined, false>;
+declare const EndpointAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
 export { EndpointAdapterToken }
 export { EndpointAdapterToken as EndpointAdapterToken_alias_1 }
 export { EndpointAdapterToken as EndpointAdapterToken_alias_2 }
@@ -532,21 +628,7 @@ declare type ExcludedKeys = 'computedTimeRates' | 'aiModelsRates' | 'aiModel';
 
 declare type ExcludedParts = 'services' | 'mailer' | 'aws' | 'computedTimeRates' | 'aiModelsRates';
 
-declare class ExecutionContext {
-    private readonly module;
-    private readonly controller;
-    private readonly handler;
-    private request;
-    private reply;
-    constructor(module: ModuleMetadata, controller: ControllerMetadata, handler: HandlerMetadata);
-    getModule(): ModuleMetadata;
-    getController(): ControllerMetadata;
-    getHandler(): HandlerMetadata;
-    getRequest(): FastifyRequest;
-    getReply(): FastifyReply;
-    provideRequest(request: FastifyRequest): void;
-    provideReply(reply: FastifyReply): void;
-}
+declare const ExecutionContext: InjectionToken<AbstractExecutionContext, undefined, false>;
 export { ExecutionContext }
 export { ExecutionContext as ExecutionContext_alias_1 }
 export { ExecutionContext as ExecutionContext_alias_2 }
@@ -556,11 +638,6 @@ export { ExecutionContextInjectionToken }
 export { ExecutionContextInjectionToken as ExecutionContextInjectionToken_alias_1 }
 export { ExecutionContextInjectionToken as ExecutionContextInjectionToken_alias_2 }
 
-declare const ExecutionContextToken: InjectionToken<ExecutionContext, undefined, false>;
-export { ExecutionContextToken }
-export { ExecutionContextToken as ExecutionContextToken_alias_1 }
-export { ExecutionContextToken as ExecutionContextToken_alias_2 }
-
 declare function extractControllerMetadata(target: ClassType): ControllerMetadata;
 export { extractControllerMetadata }
 export { extractControllerMetadata as extractControllerMetadata_alias_1 }
@@ -571,6 +648,10 @@ export { extractModuleMetadata }
 export { extractModuleMetadata as extractModuleMetadata_alias_1 }
 export { extractModuleMetadata as extractModuleMetadata_alias_2 }
 
+export { Factorable }
+
+export { FactorableWithArgs }
+
 export { Factory }
 
 export { FactoryContext }
@@ -579,12 +660,12 @@ export { FactoryInjectionToken }
 
 export { FactoryNotFound }
 
+export { FactoryOptions }
+
 export { FactoryRecord }
 
 export { FactoryTokenNotResolved }
 
-export { FactoryWithArgs }
-
 /**
  * @publicApi
  */
@@ -616,8 +697,6 @@ export { getEndpointMetadata }
 export { getEndpointMetadata as getEndpointMetadata_alias_1 }
 export { getEndpointMetadata as getEndpointMetadata_alias_2 }
 
-export { getGlobalServiceLocator }
-
 export { getInjectableToken }
 
 export { getInjectors }
@@ -630,28 +709,19 @@ export { getModuleMetadata as getModuleMetadata_alias_2 }
 export { globalRegistry }
 
 declare class GuardRunnerService {
-    runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: ExecutionContext): Promise<boolean>;
-    makeContext(executionContext: ExecutionContext): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    protected container: Container;
+    runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: AbstractExecutionContext): Promise<boolean>;
+    makeContext(moduleMetadata: ModuleMetadata, controllerMetadata: ControllerMetadata, endpoint: HandlerMetadata): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
 }
 export { GuardRunnerService }
 export { GuardRunnerService as GuardRunnerService_alias_1 }
 export { GuardRunnerService as GuardRunnerService_alias_2 }
 
-declare interface HandlerAdapterInterface {
-    provideSchema?: (handlerMetadata: HandlerMetadata<any>) => Record<string, any>;
-    hasSchema?: (handlerMetadata: HandlerMetadata<any>) => boolean;
-    prepareArguments?: (handlerMetadata: HandlerMetadata<any>) => ((target: Record<string, any>, request: FastifyRequest) => Promise<void> | void)[];
-    provideHandler: (controller: ClassType, executionContext: ExecutionContext, handlerMetadata: HandlerMetadata<any>) => (request: FastifyRequest, reply: FastifyReply) => Promise<any>;
-}
-export { HandlerAdapterInterface }
-export { HandlerAdapterInterface as HandlerAdapterInterface_alias_1 }
-export { HandlerAdapterInterface as HandlerAdapterInterface_alias_2 }
-
 declare interface HandlerMetadata<Config = null> {
     classMethod: string;
     url: string;
     successStatusCode: number;
-    adapterToken: InjectionToken<HandlerAdapterInterface, undefined> | ClassTypeWithInstance<HandlerAdapterInterface> | null;
+    adapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined> | ClassTypeWithInstance<AbstractHttpHandlerAdapterInterface> | null;
     headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>;
     httpMethod: HttpMethod;
     config: Config;
@@ -677,6 +747,19 @@ export { Header }
 export { Header as Header_alias_1 }
 export { Header as Header_alias_2 }
 
+declare class HttpAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+export { HttpAdapterFactory }
+export { HttpAdapterFactory as HttpAdapterFactory_alias_1 }
+export { HttpAdapterFactory as HttpAdapterFactory_alias_2 }
+
+declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<any, any, any, any>, undefined, false>;
+export { HttpAdapterToken }
+export { HttpAdapterToken as HttpAdapterToken_alias_1 }
+export { HttpAdapterToken as HttpAdapterToken_alias_2 }
+
 declare function HttpCode(code: number): <T extends Function>(target: T, context: ClassMethodDecoratorContext) => T;
 export { HttpCode }
 export { HttpCode as HttpCode_alias_1 }
@@ -692,6 +775,15 @@ export { HttpException }
 export { HttpException as HttpException_alias_1 }
 export { HttpException as HttpException_alias_2 }
 
+/**
+ * HTTP header strings
+ * Use this type only for input values, not for output values.
+ */
+declare type HttpHeader = keyof OmitIndexSignature<OutgoingHttpHeaders> | (string & Record<never, never>);
+export { HttpHeader }
+export { HttpHeader as HttpHeader_alias_1 }
+export { HttpHeader as HttpHeader_alias_2 }
+
 export { inject }
 
 export { Injectable }
@@ -704,15 +796,15 @@ export { InjectableTokenMeta }
 
 export { InjectableType }
 
-export { InjectionFactory }
-
 export { InjectionToken }
 
 export { InjectionTokenSchemaType }
 
+export { InjectionTokenType }
+
 export { Injectors }
 
-export { InjectorsBase }
+export { InjectState }
 
 export { InstanceDestroying }
 
@@ -813,6 +905,10 @@ export { isUndefined as isUndefined_alias_1 }
 export { isUndefined as isUndefined_alias_2 }
 export { isUndefined as isUndefined_alias_3 }
 
+export { IsUnion }
+
+export { Join }
+
 declare const LOG_LEVELS: ["verbose", "debug", "log", "warn", "error", "fatal"];
 export { LOG_LEVELS }
 export { LOG_LEVELS as LOG_LEVELS_alias_1 }
@@ -820,40 +916,15 @@ export { LOG_LEVELS as LOG_LEVELS_alias_2 }
 
 declare const Logger: InjectionToken<LoggerInstance, z.ZodOptional<z.ZodObject<{
     context: z.ZodOptional<z.ZodString>;
-    options: z.ZodOptional<z.ZodObject<{
-        timestamp: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
 }, z.core.$strip>>, false>;
 export { Logger }
 export { Logger as Logger_alias_1 }
 export { Logger as Logger_alias_2 }
 
-declare class LoggerFactory {
-    create(ctx: any, args: z.infer<typeof LoggerOptions>): LoggerInstance;
-}
-export { LoggerFactory }
-export { LoggerFactory as LoggerFactory_alias_1 }
-export { LoggerFactory as LoggerFactory_alias_2 }
-
-declare const LoggerInjectionToken = "LoggerInjectionToken";
-export { LoggerInjectionToken }
-export { LoggerInjectionToken as LoggerInjectionToken_alias_1 }
-export { LoggerInjectionToken as LoggerInjectionToken_alias_2 }
-
 declare class LoggerInstance implements LoggerService {
-    protected context?: string | undefined;
-    protected options: {
-        timestamp?: boolean;
-    };
-    protected static staticInstanceRef?: LoggerService;
-    protected static logLevels?: LogLevel[];
-    protected localInstanceRef?: LoggerService;
-    constructor();
-    constructor(context: string);
-    constructor(context: string, options?: {
-        timestamp?: boolean;
-    });
-    get localInstance(): LoggerService;
+    protected localInstance: LoggerService;
+    protected context?: string;
+    constructor(config?: LoggerOptions);
     /**
      * Write an 'error' level log.
      */
@@ -884,58 +955,28 @@ declare class LoggerInstance implements LoggerService {
      */
     fatal(message: any, context?: string): void;
     fatal(message: any, ...optionalParams: [...any, string?]): void;
-    /**
-     * Write an 'error' level log.
-     */
-    static error(message: any, stackOrContext?: string): void;
-    static error(message: any, context?: string): void;
-    static error(message: any, stack?: string, context?: string): void;
-    static error(message: any, ...optionalParams: [...any, string?, string?]): void;
-    /**
-     * Write a 'log' level log.
-     */
-    static log(message: any, context?: string): void;
-    static log(message: any, ...optionalParams: [...any, string?]): void;
-    /**
-     * Write a 'warn' level log.
-     */
-    static warn(message: any, context?: string): void;
-    static warn(message: any, ...optionalParams: [...any, string?]): void;
-    /**
-     * Write a 'debug' level log, if the configured level allows for it.
-     * Prints to `stdout` with newline.
-     */
-    static debug(message: any, context?: string): void;
-    static debug(message: any, ...optionalParams: [...any, string?]): void;
-    /**
-     * Write a 'verbose' level log.
-     */
-    static verbose(message: any, context?: string): void;
-    static verbose(message: any, ...optionalParams: [...any, string?]): void;
-    /**
-     * Write a 'fatal' level log.
-     */
-    static fatal(message: any, context?: string): void;
-    static fatal(message: any, ...optionalParams: [...any, string?]): void;
-    static getTimestamp(): string;
-    static overrideLogger(logger: LoggerService | LogLevel[] | boolean): any;
-    static isLevelEnabled(level: LogLevel): boolean;
-    private registerLocalInstanceRef;
 }
 export { LoggerInstance }
 export { LoggerInstance as LoggerInstance_alias_1 }
 export { LoggerInstance as LoggerInstance_alias_2 }
 
-declare const LoggerOptions: z.ZodOptional<z.ZodObject<{
-    context: z.ZodOptional<z.ZodString>;
-    options: z.ZodOptional<z.ZodObject<{
-        timestamp: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>;
+declare type LoggerOptions = z.infer<typeof loggerOptionsSchema>;
 export { LoggerOptions }
 export { LoggerOptions as LoggerOptions_alias_1 }
 export { LoggerOptions as LoggerOptions_alias_2 }
 
+declare const loggerOptionsSchema: z.ZodOptional<z.ZodObject<{
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export { loggerOptionsSchema }
+export { loggerOptionsSchema as loggerOptionsSchema_alias_1 }
+export { loggerOptionsSchema as loggerOptionsSchema_alias_2 }
+
+declare const LoggerOutput: InjectionToken<LoggerService, undefined, false>;
+export { LoggerOutput }
+export { LoggerOutput as LoggerOutput_alias_1 }
+export { LoggerOutput as LoggerOutput_alias_2 }
+
 /**
  * @publicApi
  */
@@ -982,8 +1023,6 @@ export { LogLevel }
 export { LogLevel as LogLevel_alias_1 }
 export { LogLevel as LogLevel_alias_2 }
 
-export { makeProxyServiceLocator }
-
 declare function Module({ controllers, imports, guards }?: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 export { Module }
 export { Module as Module_alias_1 }
@@ -991,6 +1030,7 @@ export { Module as Module_alias_2 }
 
 declare class ModuleLoaderService {
     private logger;
+    protected container: Container;
     private modulesMetadata;
     private loadedModules;
     private initialized;
@@ -1035,17 +1075,15 @@ export { Multipart }
 export { Multipart as Multipart_alias_1 }
 export { Multipart as Multipart_alias_2 }
 
-declare class MultipartAdapterService extends EndpointAdapterService {
-    prepareArguments(handlerMetadata: HandlerMetadata<BaseEndpointConfig>): ((target: Record<string, any>, request: FastifyRequest) => void)[];
-    private populateRequest;
-    private analyzeSchema;
-    provideSchema(handlerMetadata: HandlerMetadata<BaseEndpointConfig>): Record<string, any>;
+declare class MultipartAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
 }
-export { MultipartAdapterService }
-export { MultipartAdapterService as MultipartAdapterService_alias_1 }
-export { MultipartAdapterService as MultipartAdapterService_alias_2 }
+export { MultipartAdapterFactory }
+export { MultipartAdapterFactory as MultipartAdapterFactory_alias_1 }
+export { MultipartAdapterFactory as MultipartAdapterFactory_alias_2 }
 
-declare const MultipartAdapterToken: InjectionToken<MultipartAdapterService, undefined, false>;
+declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
 export { MultipartAdapterToken }
 export { MultipartAdapterToken as MultipartAdapterToken_alias_1 }
 export { MultipartAdapterToken as MultipartAdapterToken_alias_2 }
@@ -1065,27 +1103,23 @@ export { MultipartResult as MultipartResult_alias_1 }
 export { MultipartResult as MultipartResult_alias_2 }
 
 declare class NaviosApplication {
+    private environment;
     private moduleLoader;
-    private controllerAdapter;
+    private httpApplication;
     private logger;
-    private server;
-    private corsOptions;
-    private multipartOptions;
-    private globalPrefix;
+    protected container: Container;
     private appModule;
     private options;
     isInitialized: boolean;
-    setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): void;
+    setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<void>;
+    getContainer(): Container;
     init(): Promise<void>;
-    private getFastifyInstance;
-    private configureFastifyInstance;
-    configureMultipart(server: FastifyInstance, options: FastifyMultipartOptions | true): Promise<void>;
     private initModules;
-    enableCors(options: FastifyCorsOptions): void;
-    enableMultipart(options: FastifyMultipartOptions): void;
+    enableCors(options: any): void;
+    enableMultipart(options: any): void;
     setGlobalPrefix(prefix: string): void;
-    getServer(): FastifyInstance;
-    listen(options: FastifyListenOptions): Promise<void>;
+    getServer(): any;
+    listen(options: AbstractHttpListenOptions): Promise<void>;
     dispose(): Promise<void>;
     close(): Promise<void>;
 }
@@ -1101,13 +1135,26 @@ declare interface NaviosApplicationContextOptions {
 export { NaviosApplicationContextOptions }
 export { NaviosApplicationContextOptions as NaviosApplicationContextOptions_alias_1 }
 
-declare interface NaviosApplicationOptions extends Omit<FastifyServerOptions, 'logger'>, NaviosApplicationContextOptions {
+declare interface NaviosApplicationOptions extends NaviosApplicationContextOptions {
+    adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[];
 }
 export { NaviosApplicationOptions }
 export { NaviosApplicationOptions as NaviosApplicationOptions_alias_1 }
 
+export declare class NaviosEnvironment {
+    private httpTokens;
+    setupHttpEnvironment(tokens: Map<InjectionToken<any, undefined>, AnyInjectableType>): void;
+    getHttpToken(token: InjectionToken<any, undefined>): AnyInjectableType | undefined;
+    hasHttpSetup(): boolean;
+}
+
+export declare interface NaviosEnvironmentOptions {
+    httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>;
+}
+
 declare class NaviosFactory {
     static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication>;
+    private static registerEnvironment;
     private static registerLoggerConfiguration;
 }
 export { NaviosFactory }
@@ -1135,8 +1182,21 @@ export { NotFoundException }
 export { NotFoundException as NotFoundException_alias_1 }
 export { NotFoundException as NotFoundException_alias_2 }
 
+declare type OmitIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+export { OmitIndexSignature }
+export { OmitIndexSignature as OmitIndexSignature_alias_1 }
+export { OmitIndexSignature as OmitIndexSignature_alias_2 }
+
+export { OnServiceDestroy }
+
+export { OnServiceInit }
+
 export { OptionalInjectionTokenSchemaType }
 
+declare type OriginType = string | boolean | RegExp;
+
 declare type Path<T> = keyof T extends string ? PathImpl2<T> extends infer P ? P extends string | keyof T ? P : keyof T : keyof T : never;
 export { Path }
 export { Path as Path_alias_1 }
@@ -1157,45 +1217,46 @@ export { PathValue }
 export { PathValue as PathValue_alias_1 }
 export { PathValue as PathValue_alias_2 }
 
-declare class PinoWrapper {
-    protected readonly logger: LoggerService;
-    constructor(logger: LoggerService);
-    fatal(message: any, ...optionalParams: any[]): void;
-    error(message: any, ...optionalParams: any[]): void;
-    warn(message: any, ...optionalParams: any[]): void;
-    info(): void;
-    debug(message: any, ...optionalParams: any[]): void;
-    trace(message: any, ...optionalParams: any[]): void;
-    silent(): void;
-    child(options: any): PinoWrapper;
-    get level(): any;
-}
-export { PinoWrapper }
-export { PinoWrapper as PinoWrapper_alias_1 }
-export { PinoWrapper as PinoWrapper_alias_2 }
+export { PopUnion }
 
 declare function provideConfig<ConfigMap extends ConfigServiceOptions>(options: z.input<typeof ConfigProviderOptions>): FactoryInjectionToken<ConfigService<ConfigMap>, typeof ConfigServiceOptionsSchema>;
 export { provideConfig }
 export { provideConfig as provideConfig_alias_1 }
 export { provideConfig as provideConfig_alias_2 }
 
-export { provideServiceLocator }
-
-export { ProxyServiceLocator }
+export { provideFactoryContext }
 
 export { Registry }
 
-declare const Reply: InjectionToken<FastifyReply<RouteGenericInterface, RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, unknown, FastifySchema, FastifyTypeProviderDefault, unknown>, undefined, false>;
+declare const Reply: InjectionToken<any, undefined, false>;
 export { Reply }
 export { Reply as Reply_alias_1 }
 export { Reply as Reply_alias_2 }
 
-declare const Request_2: InjectionToken<FastifyRequest<RouteGenericInterface, RawServerDefault, IncomingMessage, FastifySchema, FastifyTypeProviderDefault, unknown, FastifyBaseLogger, ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>>, undefined, false>;
+declare class ReplyFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+export { ReplyFactory }
+export { ReplyFactory as ReplyFactory_alias_1 }
+export { ReplyFactory as ReplyFactory_alias_2 }
+
+declare const Request_2: InjectionToken<any, undefined, false>;
 export { Request_2 as Request }
 export { Request_2 as Request_alias_1 }
 export { Request_2 as Request_alias_2 }
 
-export { resolveService }
+export { RequestContextHolder }
+
+declare class RequestFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+export { RequestFactory }
+export { RequestFactory as RequestFactory_alias_1 }
+export { RequestFactory as RequestFactory_alias_2 }
+
+export { ServiceInstantiator }
 
 export { ServiceLocator }
 
@@ -1213,7 +1274,7 @@ export { ServiceLocatorInstanceHolderCreating }
 
 export { ServiceLocatorInstanceHolderDestroying }
 
-export { ServiceLocatorInstanceHolderKind }
+export { ServiceLocatorInstanceHolderError }
 
 export { ServiceLocatorInstanceHolderStatus }
 
@@ -1221,22 +1282,20 @@ export { ServiceLocatorManager }
 
 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: FastifyReply) => 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: FastifyReply) => Promise<void>;
+}): (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>;
 export { Stream }
 export { Stream as Stream_alias_1 }
 export { Stream as Stream_alias_2 }
 
-declare class StreamAdapterService implements HandlerAdapterInterface {
-    hasSchema(handlerMetadata: HandlerMetadata<BaseStreamConfig>): boolean;
-    prepareArguments(handlerMetadata: HandlerMetadata<BaseStreamConfig>): ((target: Record<string, any>, request: FastifyRequest) => void | Promise<void>)[];
-    provideHandler(controller: ClassType, executionContext: ExecutionContext, handlerMetadata: HandlerMetadata<BaseStreamConfig>): (request: FastifyRequest, reply: FastifyReply) => Promise<any>;
-    provideSchema(handlerMetadata: HandlerMetadata<BaseStreamConfig>): Record<string, any>;
+declare class StreamAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
 }
-export { StreamAdapterService }
-export { StreamAdapterService as StreamAdapterService_alias_1 }
-export { StreamAdapterService as StreamAdapterService_alias_2 }
+export { StreamAdapterFactory }
+export { StreamAdapterFactory as StreamAdapterFactory_alias_1 }
+export { StreamAdapterFactory as StreamAdapterFactory_alias_2 }
 
-declare const StreamAdapterToken: InjectionToken<StreamAdapterService, undefined, false>;
+declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
 export { StreamAdapterToken }
 export { StreamAdapterToken as StreamAdapterToken_alias_1 }
 export { StreamAdapterToken as StreamAdapterToken_alias_2 }
@@ -1254,8 +1313,6 @@ export { stripEndSlash as stripEndSlash_alias_1 }
 export { stripEndSlash as stripEndSlash_alias_2 }
 export { stripEndSlash as stripEndSlash_alias_3 }
 
-export { syncInject }
-
 declare class UnauthorizedException extends HttpException {
     constructor(message: string | object, error?: Error);
 }
@@ -1263,6 +1320,12 @@ export { UnauthorizedException }
 export { UnauthorizedException as UnauthorizedException_alias_1 }
 export { UnauthorizedException as UnauthorizedException_alias_2 }
 
+export { UnionToArray }
+
+export { UnionToIntersection }
+
+export { UnionToOvlds }
+
 export { UnknownError }
 
 declare function UseGuards(...guards: (ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>)[]): <T extends Function>(target: T, context: ClassMethodDecoratorContext | ClassDecoratorContext) => T;
@@ -1270,6 +1333,8 @@ export { UseGuards }
 export { UseGuards as UseGuards_alias_1 }
 export { UseGuards as UseGuards_alias_2 }
 
+declare type ValueOrArray<T> = T | ArrayOfValueOrArray<T>;
+
 export { wrapSyncInit }
 
 declare const yellow: (text: string) => string;