@navios/core 0.1.14 → 0.2.0

package/dist/_tsup-dts-rollup.d.mts

@@ -1,7 +1,25 @@
 import type { AnyZodObject } from 'zod';
 import type { BaseEndpointConfig } from '@navios/common';
 import type { BaseStreamConfig } from '@navios/common';
+import { BoundInjectionToken } from '@navios/di';
+import { ChannelEmitter } from '@navios/di';
+import { ClassType } from '@navios/di';
+import { ClassTypeWithInstance } from '@navios/di';
+import { CreateInjectorsOptions } from '@navios/di';
 import type { EndpointFunctionArgs } from '@navios/common';
+import { ErrorsEnum } from '@navios/di';
+import { EventEmitter } from '@navios/di';
+import { EventEmitterInterface } from '@navios/di';
+import { EventsArgs } from '@navios/di';
+import { EventsConfig } from '@navios/di';
+import { EventsNames } from '@navios/di';
+import { Factory } from '@navios/di';
+import { FactoryContext } from '@navios/di';
+import { FactoryInjectionToken } from '@navios/di';
+import { FactoryNotFound } 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';
@@ -12,19 +30,53 @@ 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/common';
 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 { Injectors } from '@navios/di';
+import { InjectorsBase } from '@navios/di';
 import type { InspectOptions } from 'util';
+import { InstanceDestroying } from '@navios/di';
+import { InstanceExpired } from '@navios/di';
+import { InstanceNotFound } from '@navios/di';
 import { LoggerInstance as LoggerInstance_2 } from '../logger/logger.service.mjs';
-import type { output } from 'zod';
+import { makeProxyServiceLocator } from '@navios/di';
+import { provideServiceLocator } from '@navios/di';
+import { ProxyServiceLocator } from '@navios/di';
 import { RawServerDefault } from 'fastify';
+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 { ServiceLocator } from '@navios/di';
+import { ServiceLocatorEventBus } from '@navios/di';
+import { ServiceLocatorInstanceDestroyListener } from '@navios/di';
+import { ServiceLocatorInstanceEffect } from '@navios/di';
+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 { ServiceLocatorInstanceHolderStatus } from '@navios/di';
+import { ServiceLocatorManager } from '@navios/di';
+import { syncInject } from '@navios/di';
+import { UnknownError } from '@navios/di';
+import { wrapSyncInit } from '@navios/di';
 import { z } from 'zod';
 import { ZodDiscriminatedUnion } from 'zod';
-import { ZodOptional } from 'zod';
 import type { ZodType } from 'zod';
 
 declare const addLeadingSlash: (path?: string) => string;
@@ -41,14 +93,14 @@ export { Application as Application_alias_2 }
 declare class AttributeFactory {
     static createAttribute(token: symbol): ClassAttribute;
     static createAttribute<T extends ZodType>(token: symbol, schema: T): ClassSchemaAttribute<T>;
-    static get(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): true | null;
-    static get<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): z.output<T> | null;
-    static getAll(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): Array<true> | null;
-    static getAll<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): Array<z.output<T>> | null;
-    static getLast(attribute: ClassAttribute, target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[]): true | null;
-    static getLast<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[]): z.output<T> | null;
-    static has(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): boolean;
-    static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): boolean;
+    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.output<T> | 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.output<T>> | null;
+    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.output<T> | null;
+    static has(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
+    static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
 }
 export { AttributeFactory }
 export { AttributeFactory as AttributeFactory_alias_1 }
@@ -60,14 +112,7 @@ export { BadRequestException }
 export { BadRequestException as BadRequestException_alias_1 }
 export { BadRequestException as BadRequestException_alias_2 }
 
-declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> extends InjectionToken<T, undefined> {
-    readonly token: InjectionToken<T, S>;
-    readonly value: z.input<S>;
-    constructor(token: InjectionToken<T, S>, value: z.input<S>);
-}
 export { BoundInjectionToken }
-export { BoundInjectionToken as BoundInjectionToken_alias_1 }
-export { BoundInjectionToken as BoundInjectionToken_alias_2 }
 
 declare interface CanActivate {
     canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean;
@@ -76,12 +121,7 @@ export { CanActivate }
 export { CanActivate as CanActivate_alias_1 }
 export { CanActivate as CanActivate_alias_2 }
 
-declare type ChannelEmitter<Events extends EventsConfig, Ns extends string, E extends EventsNames<Events>> = {
-    emit<Args extends EventsArgs<Events, E>>(ns: Ns, event: E, ...args: Args): Promise<any>;
-};
 export { ChannelEmitter }
-export { ChannelEmitter as ChannelEmitter_alias_1 }
-export { ChannelEmitter as ChannelEmitter_alias_2 }
 
 declare type ClassAttribute = (() => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
     token: symbol;
@@ -96,15 +136,9 @@ declare type ClassSchemaAttribute<T extends ZodType> = ((value: z.input<T>) => <
 export { ClassSchemaAttribute }
 export { ClassSchemaAttribute as ClassSchemaAttribute_alias_1 }
 
-declare type ClassType = new (...args: any[]) => any;
 export { ClassType }
-export { ClassType as ClassType_alias_1 }
-export { ClassType as ClassType_alias_2 }
 
-declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
 export { ClassTypeWithInstance }
-export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
-export { ClassTypeWithInstance as ClassTypeWithInstance_alias_2 }
 
 declare const clc: {
     bold: (text: string) => string;
@@ -132,7 +166,7 @@ export { ConfigProvider as ConfigProvider_alias_2 }
 
 declare class ConfigProviderFactory {
     logger: LoggerInstance_2;
-    create(ctx: any, args: z.infer<typeof ConfigProviderOptions>): Promise<ConfigServiceInstance<unknown>>;
+    create(ctx: any, args: z.infer<typeof ConfigProviderOptions>): Promise<ConfigService>;
 }
 export { ConfigProviderFactory }
 export { ConfigProviderFactory as ConfigProviderFactory_alias_1 }
@@ -377,7 +411,7 @@ export { ConsoleLoggerOptions }
 export { ConsoleLoggerOptions as ConsoleLoggerOptions_alias_1 }
 export { ConsoleLoggerOptions as ConsoleLoggerOptions_alias_2 }
 
-declare function Controller({ guards }?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+declare function Controller({ guards }?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => any;
 export { Controller }
 export { Controller as Controller_alias_1 }
 export { Controller as Controller_alias_2 }
@@ -385,20 +419,16 @@ export { Controller as Controller_alias_2 }
 declare class ControllerAdapterService {
     guardRunner: GuardRunnerService;
     private logger;
-    setupController(controller: ClassType, instance: FastifyInstance, moduleMetadata: ModuleMetadata): void;
-    providePreHandler(executionContext: ExecutionContext): ((request: FastifyRequest, reply: FastifyReply) => Promise<undefined>) | undefined;
-    private provideSchemaForConfig;
-    private provideHandler;
-    private provideHandlerForConfig;
-    private provideHandlerForStream;
-    private provideHandlerForMultipart;
+    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<EndpointMetadata>;
+    endpoints: Set<HandlerMetadata>;
     guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
     customAttributes: Map<string | symbol, any>;
 }
@@ -418,6 +448,8 @@ export { ControllerOptions }
 export { ControllerOptions as ControllerOptions_alias_1 }
 export { ControllerOptions as ControllerOptions_alias_2 }
 
+export { CreateInjectorsOptions }
+
 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 AnyZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z.input<ResponseSchema>>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends AnyZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z.input<ResponseSchema>>;
@@ -425,20 +457,19 @@ export { Endpoint }
 export { Endpoint as Endpoint_alias_1 }
 export { Endpoint as Endpoint_alias_2 }
 
-declare interface EndpointMetadata {
-    classMethod: string;
-    url: string;
-    successStatusCode: number;
-    type: EndpointType;
-    headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>;
-    httpMethod: HttpMethod;
-    config: BaseEndpointConfig | BaseStreamConfig | null;
-    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
-    customAttributes: Map<string | symbol, any>;
+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>;
 }
-export { EndpointMetadata }
-export { EndpointMetadata as EndpointMetadata_alias_1 }
-export { EndpointMetadata as EndpointMetadata_alias_2 }
+export { EndpointAdapterService }
+export { EndpointAdapterService as EndpointAdapterService_alias_1 }
+export { EndpointAdapterService as EndpointAdapterService_alias_2 }
+
+declare const EndpointAdapterToken: InjectionToken<EndpointAdapterService, undefined>;
+export { EndpointAdapterToken }
+export { EndpointAdapterToken as EndpointAdapterToken_alias_1 }
+export { EndpointAdapterToken as EndpointAdapterToken_alias_2 }
 
 declare const EndpointMetadataKey: unique symbol;
 export { EndpointMetadataKey }
@@ -459,17 +490,6 @@ export { EndpointResult }
 export { EndpointResult as EndpointResult_alias_1 }
 export { EndpointResult as EndpointResult_alias_2 }
 
-declare enum EndpointType {
-    Unknown = "unknown",
-    Endpoint = "endpoint",
-    Stream = "stream",
-    Multipart = "multipart",
-    Handler = "handler"
-}
-export { EndpointType }
-export { EndpointType as EndpointType_alias_1 }
-export { EndpointType as EndpointType_alias_2 }
-
 declare function envInt(key: keyof NodeJS.ProcessEnv, defaultValue: number): number;
 export { envInt }
 export { envInt as envInt_alias_1 }
@@ -482,56 +502,17 @@ export { envString as envString_alias_1 }
 export { envString as envString_alias_2 }
 export { envString as envString_alias_3 }
 
-declare enum ErrorsEnum {
-    InstanceExpired = "InstanceExpired",
-    InstanceNotFound = "InstanceNotFound",
-    InstanceDestroying = "InstanceDestroying",
-    UnknownError = "UnknownError",
-    FactoryNotFound = "FactoryNotFound",
-    FactoryTokenNotResolved = "FactoryTokenNotResolved"
-}
 export { ErrorsEnum }
-export { ErrorsEnum as ErrorsEnum_alias_1 }
-export { ErrorsEnum as ErrorsEnum_alias_2 }
-export { ErrorsEnum as ErrorsEnum_alias_3 }
-
-declare class EventEmitter<Events extends EventsConfig = {}> implements EventEmitterInterface<Events> {
-    private listeners;
-    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
-    off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): void;
-    once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
-    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): Promise<any>;
-    addChannel<E extends EventsNames<Events>, Ns extends string, Emitter extends ChannelEmitter<Events, Ns, E>>(ns: Ns, event: E, target: Emitter): () => void;
-}
+
 export { EventEmitter }
-export { EventEmitter as EventEmitter_alias_1 }
-export { EventEmitter as EventEmitter_alias_2 }
 
-declare interface EventEmitterInterface<Events extends EventsConfig> {
-    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
-    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): void;
-    addChannel<E extends EventsNames<Events>, Ns extends string, Emmiter extends ChannelEmitter<Events, Ns, E>>(ns: Ns, event: E, target: Emmiter): () => void;
-}
 export { EventEmitterInterface }
-export { EventEmitterInterface as EventEmitterInterface_alias_1 }
-export { EventEmitterInterface as EventEmitterInterface_alias_2 }
 
-declare type EventsArgs<Events extends EventsConfig, Name extends EventsNames<Events>> = Events[Name] extends any[] ? Events[Name] : [];
 export { EventsArgs }
-export { EventsArgs as EventsArgs_alias_1 }
-export { EventsArgs as EventsArgs_alias_2 }
 
-declare type EventsConfig = {
-    [event: string]: any[];
-};
 export { EventsConfig }
-export { EventsConfig as EventsConfig_alias_1 }
-export { EventsConfig as EventsConfig_alias_2 }
 
-declare type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>;
 export { EventsNames }
-export { EventsNames as EventsNames_alias_1 }
-export { EventsNames as EventsNames_alias_2 }
 
 declare type ExcludedKeys = 'computedTimeRates' | 'aiModelsRates' | 'aiModel';
 
@@ -543,10 +524,10 @@ declare class ExecutionContext {
     private readonly handler;
     private request;
     private reply;
-    constructor(module: ModuleMetadata, controller: ControllerMetadata, handler: EndpointMetadata);
+    constructor(module: ModuleMetadata, controller: ControllerMetadata, handler: HandlerMetadata);
     getModule(): ModuleMetadata;
     getController(): ControllerMetadata;
-    getHandler(): EndpointMetadata;
+    getHandler(): HandlerMetadata;
     getRequest(): FastifyRequest;
     getReply(): FastifyReply;
     provideRequest(request: FastifyRequest): void;
@@ -576,40 +557,19 @@ export { extractModuleMetadata }
 export { extractModuleMetadata as extractModuleMetadata_alias_1 }
 export { extractModuleMetadata as extractModuleMetadata_alias_2 }
 
-export declare interface Factory<T> {
-    create(ctx: any): Promise<T>;
-}
+export { Factory }
+
+export { FactoryContext }
 
-declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> extends InjectionToken<T, S> {
-    readonly token: InjectionToken<T, S>;
-    readonly factory: () => Promise<z.input<S>>;
-    value?: z.input<S>;
-    resolved: boolean;
-    constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
-    resolve(): Promise<z.input<S>>;
-}
 export { FactoryInjectionToken }
-export { FactoryInjectionToken as FactoryInjectionToken_alias_1 }
-export { FactoryInjectionToken as FactoryInjectionToken_alias_2 }
 
-declare class FactoryNotFound extends Error {
-    name: string;
-    code: ErrorsEnum;
-    constructor(name: string);
-}
 export { FactoryNotFound }
-export { FactoryNotFound as FactoryNotFound_alias_1 }
-export { FactoryNotFound as FactoryNotFound_alias_2 }
-export { FactoryNotFound as FactoryNotFound_alias_3 }
 
-declare class FactoryTokenNotResolved extends Error {
-    code: ErrorsEnum;
-    constructor(name: string | symbol | ClassType);
-}
+export { FactoryRecord }
+
 export { FactoryTokenNotResolved }
-export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
-export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
-export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_3 }
+
+export { FactoryWithArgs }
 
 /**
  * @publicApi
@@ -627,7 +587,7 @@ export { ForbiddenException }
 export { ForbiddenException as ForbiddenException_alias_1 }
 export { ForbiddenException as ForbiddenException_alias_2 }
 
-declare function getAllEndpointMetadata(context: ClassMethodDecoratorContext | ClassDecoratorContext): Set<EndpointMetadata>;
+declare function getAllEndpointMetadata(context: ClassMethodDecoratorContext | ClassDecoratorContext): Set<HandlerMetadata<any>>;
 export { getAllEndpointMetadata }
 export { getAllEndpointMetadata as getAllEndpointMetadata_alias_1 }
 export { getAllEndpointMetadata as getAllEndpointMetadata_alias_2 }
@@ -637,28 +597,23 @@ export { getControllerMetadata }
 export { getControllerMetadata as getControllerMetadata_alias_1 }
 export { getControllerMetadata as getControllerMetadata_alias_2 }
 
-declare function getEndpointMetadata(target: Function, context: ClassMethodDecoratorContext): EndpointMetadata;
+declare function getEndpointMetadata<Config = any>(target: Function, context: ClassMethodDecoratorContext): HandlerMetadata<Config>;
 export { getEndpointMetadata }
 export { getEndpointMetadata as getEndpointMetadata_alias_1 }
 export { getEndpointMetadata as getEndpointMetadata_alias_2 }
 
-declare function getInjectableToken<R>(target: ClassType): R extends {
-    create(...args: any[]): infer V;
-} ? InjectionToken<V> : InjectionToken<R>;
+export { getGlobalServiceLocator }
+
 export { getInjectableToken }
-export { getInjectableToken as getInjectableToken_alias_1 }
-export { getInjectableToken as getInjectableToken_alias_2 }
-export { getInjectableToken as getInjectableToken_alias_3 }
+
+export { getInjectors }
 
 declare function getModuleMetadata(target: ClassType, context: ClassDecoratorContext): ModuleMetadata;
 export { getModuleMetadata }
 export { getModuleMetadata as getModuleMetadata_alias_1 }
 export { getModuleMetadata as getModuleMetadata_alias_2 }
 
-declare function getServiceLocator(): ServiceLocator;
-export { getServiceLocator }
-export { getServiceLocator as getServiceLocator_alias_1 }
-export { getServiceLocator as getServiceLocator_alias_2 }
+export { globalRegistry }
 
 declare class GuardRunnerService {
     runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: ExecutionContext): Promise<boolean>;
@@ -668,6 +623,31 @@ 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;
+    headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>;
+    httpMethod: HttpMethod;
+    config: Config;
+    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    customAttributes: Map<string | symbol, any>;
+}
+export { HandlerMetadata }
+export { HandlerMetadata as HandlerMetadata_alias_1 }
+export { HandlerMetadata as HandlerMetadata_alias_2 }
+
 declare function hasControllerMetadata(target: ClassType): boolean;
 export { hasControllerMetadata }
 export { hasControllerMetadata as hasControllerMetadata_alias_1 }
@@ -698,118 +678,31 @@ export { HttpException }
 export { HttpException as HttpException_alias_1 }
 export { HttpException as HttpException_alias_2 }
 
-declare function inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
-
-declare function inject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-
-declare function inject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
-
-declare function inject<T>(token: InjectionToken<T, undefined>): Promise<T>;
 export { inject }
-export { inject as inject_alias_1 }
-export { inject as inject_alias_2 }
 
-declare function Injectable({ scope, type, token, }?: InjectableOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 export { Injectable }
-export { Injectable as Injectable_alias_1 }
-export { Injectable as Injectable_alias_2 }
-export { Injectable as Injectable_alias_3 }
-
-declare interface InjectableMetadata<Instance = any, Schema = any> {
-    type: InjectableType;
-    scope: InjectableScope;
-    token: InjectionToken<Instance, Schema>;
-}
-export { InjectableMetadata }
-export { InjectableMetadata as InjectableMetadata_alias_1 }
-export { InjectableMetadata as InjectableMetadata_alias_2 }
-
-declare interface InjectableOptions {
-    scope?: InjectableScope;
-    type?: InjectableType;
-    token?: InjectionToken<any, any>;
-}
+
 export { InjectableOptions }
-export { InjectableOptions as InjectableOptions_alias_1 }
-export { InjectableOptions as InjectableOptions_alias_2 }
-export { InjectableOptions as InjectableOptions_alias_3 }
 
-declare enum InjectableScope {
-    /**
-     * Singleton scope: The instance is created once and shared across the application.
-     */
-    Singleton = "Singleton",
-    /**
-     * Instance scope: A new instance is created for each injection.
-     */
-    Instance = "Instance"
-}
 export { InjectableScope }
-export { InjectableScope as InjectableScope_alias_1 }
-export { InjectableScope as InjectableScope_alias_2 }
-export { InjectableScope as InjectableScope_alias_3 }
 
-declare const InjectableTokenMeta: unique symbol;
 export { InjectableTokenMeta }
-export { InjectableTokenMeta as InjectableTokenMeta_alias_1 }
-export { InjectableTokenMeta as InjectableTokenMeta_alias_2 }
-export { InjectableTokenMeta as InjectableTokenMeta_alias_3 }
 
-declare enum InjectableType {
-    Class = "Class",
-    Factory = "Factory"
-}
 export { InjectableType }
-export { InjectableType as InjectableType_alias_1 }
-export { InjectableType as InjectableType_alias_2 }
-export { InjectableType as InjectableType_alias_3 }
-
-declare class InjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown> {
-    readonly name: string | symbol | ClassType;
-    readonly schema: AnyZodObject | undefined;
-    id: `${string}-${string}-${string}-${string}-${string}`;
-    constructor(name: string | symbol | ClassType, schema: AnyZodObject | undefined);
-    static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
-    static create<T extends ClassType, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
-    static create<T>(name: string | symbol): InjectionToken<T, undefined>;
-    static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
-    static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
-    static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
-    static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
-}
+
+export { InjectionFactory }
+
 export { InjectionToken }
-export { InjectionToken as InjectionToken_alias_1 }
-export { InjectionToken as InjectionToken_alias_2 }
 
-declare class InstanceDestroying extends Error {
-    name: string;
-    code: ErrorsEnum;
-    constructor(name: string);
-}
+export { Injectors }
+
+export { InjectorsBase }
+
 export { InstanceDestroying }
-export { InstanceDestroying as InstanceDestroying_alias_1 }
-export { InstanceDestroying as InstanceDestroying_alias_2 }
-export { InstanceDestroying as InstanceDestroying_alias_3 }
-
-declare class InstanceExpired extends Error {
-    name: string;
-    code: ErrorsEnum;
-    constructor(name: string);
-}
+
 export { InstanceExpired }
-export { InstanceExpired as InstanceExpired_alias_1 }
-export { InstanceExpired as InstanceExpired_alias_2 }
-export { InstanceExpired as InstanceExpired_alias_3 }
-
-declare class InstanceNotFound extends Error {
-    name: string;
-    code: ErrorsEnum;
-    constructor(name: string);
-}
+
 export { InstanceNotFound }
-export { InstanceNotFound as InstanceNotFound_alias_1 }
-export { InstanceNotFound as InstanceNotFound_alias_2 }
-export { InstanceNotFound as InstanceNotFound_alias_3 }
 
 declare class InternalServerErrorException extends HttpException {
     constructor(message: string | object, error?: Error);
@@ -1101,9 +994,9 @@ export { LogLevel }
 export { LogLevel as LogLevel_alias_1 }
 export { LogLevel as LogLevel_alias_2 }
 
-export declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: ServiceLocatorAbstractFactoryContext): ServiceLocator;
+export { makeProxyServiceLocator }
 
-declare function Module(metadata: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+declare function Module({ controllers, imports, guards }?: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => any;
 export { Module }
 export { Module as Module_alias_1 }
 export { Module as Module_alias_2 }
@@ -1154,6 +1047,21 @@ 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>;
+}
+export { MultipartAdapterService }
+export { MultipartAdapterService as MultipartAdapterService_alias_1 }
+export { MultipartAdapterService as MultipartAdapterService_alias_2 }
+
+declare const MultipartAdapterToken: InjectionToken<MultipartAdapterService, undefined>;
+export { MultipartAdapterToken }
+export { MultipartAdapterToken as MultipartAdapterToken_alias_1 }
+export { MultipartAdapterToken as MultipartAdapterToken_alias_2 }
+
 declare type MultipartParams<EndpointDeclaration extends {
     config: BaseEndpointConfig<any, any, any, any, any>;
 }, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends AnyZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, QuerySchema, undefined> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, undefined, undefined>;
@@ -1239,15 +1147,6 @@ export { NotFoundException }
 export { NotFoundException as NotFoundException_alias_1 }
 export { NotFoundException as NotFoundException_alias_2 }
 
-/**
- * Useful for tests or when you want to override a service
- * with a different implementation.
- */
-declare function override<T>(token: InjectionToken<T>, target: ClassType): () => void;
-export { override }
-export { override as override_alias_1 }
-export { override as override_alias_2 }
-
 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 }
@@ -1285,32 +1184,22 @@ export { PinoWrapper }
 export { PinoWrapper as PinoWrapper_alias_1 }
 export { PinoWrapper as PinoWrapper_alias_2 }
 
-declare let promiseCollector: null | ((promise: Promise<any>) => void);
-
-declare function provideConfig<ConfigMap extends Record<string, unknown>>(options: z.input<typeof ConfigProviderOptions>): InjectionToken<ConfigServiceInstance<ConfigMap>, undefined>;
+declare function provideConfig<ConfigMap extends Record<string, unknown>>(options: z.input<typeof ConfigProviderOptions>): BoundInjectionToken<ConfigService<Record<string, unknown>>, z.ZodObject<{
+load: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+load: (...args: unknown[]) => unknown;
+}, {
+load: (...args: unknown[]) => unknown;
+}>>;
 export { provideConfig }
 export { provideConfig as provideConfig_alias_1 }
 export { provideConfig as provideConfig_alias_2 }
 
-declare function provideServiceLocator(locator: ServiceLocator): ServiceLocator;
 export { provideServiceLocator }
-export { provideServiceLocator as provideServiceLocator_alias_1 }
-export { provideServiceLocator as provideServiceLocator_alias_2 }
-
-export declare class ProxyServiceLocator implements ServiceLocator {
-    private readonly serviceLocator;
-    private readonly ctx;
-    constructor(serviceLocator: ServiceLocator, ctx: ServiceLocatorAbstractFactoryContext);
-    get abstractFactories(): Map<InjectionToken<any, any>, (ctx: ServiceLocatorAbstractFactoryContext, args: any) => Promise<any>>;
-    getEventBus(): ServiceLocatorEventBus;
-    registerAbstractFactory<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, factory: (ctx: ServiceLocatorAbstractFactoryContext, values: Schema extends AnyZodObject ? output<Schema> : undefined) => Promise<Instance>): void;
-    getInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getOrThrowInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
-    getSyncInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
-    invalidate(service: string, round?: number): Promise<any>;
-    ready(): Promise<null>;
-    makeInstanceName(token: InjectionToken<any, any>, args: any): string;
-}
+
+export { ProxyServiceLocator }
+
+export { Registry }
 
 declare const Reply: InjectionToken<FastifyReply<RouteGenericInterface, RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, unknown, FastifySchema, FastifyTypeProviderDefault, unknown>, undefined>;
 export { Reply }
@@ -1322,167 +1211,29 @@ export { Request_2 as Request }
 export { Request_2 as Request_alias_1 }
 export { Request_2 as Request_alias_2 }
 
-declare function resolveService<T extends ClassType>(ctx: ServiceLocatorAbstractFactoryContext, target: T, args?: any[]): Promise<InstanceType<T>>;
 export { resolveService }
-export { resolveService as resolveService_alias_1 }
-export { resolveService as resolveService_alias_2 }
-
-declare class ServiceLocator {
-    private readonly logger;
-    private abstractFactories;
-    private instanceFactories;
-    private readonly eventBus;
-    private readonly manager;
-    constructor(logger?: Console | null);
-    getEventBus(): ServiceLocatorEventBus;
-    registerInstance<Instance>(token: InjectionToken<Instance, undefined>, instance: Instance): void;
-    removeInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<any>;
-    registerAbstractFactory<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, factory: (ctx: ServiceLocatorAbstractFactoryContext, values: Schema extends AnyZodObject ? z.output<Schema> : undefined) => Promise<Instance>, type?: InjectableScope): void;
-    private resolveTokenArgs;
-    getInstanceIdentifier<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): string;
-    getInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getOrThrowInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
-    private notifyListeners;
-    private createInstance;
-    private createInstanceFromAbstractFactory;
-    private createContextForAbstractFactory;
-    getSyncInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
-    invalidate(service: string, round?: number): Promise<any>;
-    ready(): Promise<null>;
-    makeInstanceName(token: InjectionToken<any, any>, args: any): string;
-}
+
 export { ServiceLocator }
-export { ServiceLocator as ServiceLocator_alias_1 }
-export { ServiceLocator as ServiceLocator_alias_2 }
-
-declare interface ServiceLocatorAbstractFactoryContext {
-    inject: typeof inject;
-    addDependency: ((token: InjectionToken<any, undefined>) => void) | (<S extends AnyZodObject>(token: InjectionToken<any, S>, args: z.input<S>) => void);
-    on: ServiceLocatorEventBus['on'];
-    getDependencies: () => string[];
-    invalidate: () => void;
-    addEffect: (listener: () => void) => void;
-    getDestroyListeners: () => (() => void)[];
-    setTtl: (ttl: number) => void;
-    getTtl: () => number;
-}
-export { ServiceLocatorAbstractFactoryContext }
-export { ServiceLocatorAbstractFactoryContext as ServiceLocatorAbstractFactoryContext_alias_1 }
-export { ServiceLocatorAbstractFactoryContext as ServiceLocatorAbstractFactoryContext_alias_2 }
-
-declare class ServiceLocatorEventBus {
-    private readonly logger;
-    private listeners;
-    constructor(logger?: Console | null);
-    on<Event extends string | `pre:${string}` | `post:${string}`>(ns: string, event: Event, listener: (event: Event) => void): () => void;
-    emit(key: string, event: string): Promise<PromiseSettledResult<any>[] | undefined>;
-}
+
 export { ServiceLocatorEventBus }
-export { ServiceLocatorEventBus as ServiceLocatorEventBus_alias_1 }
-export { ServiceLocatorEventBus as ServiceLocatorEventBus_alias_2 }
 
-declare type ServiceLocatorInstanceDestroyListener = () => void | Promise<void>;
 export { ServiceLocatorInstanceDestroyListener }
-export { ServiceLocatorInstanceDestroyListener as ServiceLocatorInstanceDestroyListener_alias_1 }
-export { ServiceLocatorInstanceDestroyListener as ServiceLocatorInstanceDestroyListener_alias_2 }
 
-declare type ServiceLocatorInstanceEffect = () => void;
 export { ServiceLocatorInstanceEffect }
-export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_1 }
-export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_2 }
 
-declare type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance>;
 export { ServiceLocatorInstanceHolder }
-export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_1 }
-export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_2 }
-
-declare interface ServiceLocatorInstanceHolderCreated<Instance> {
-    status: ServiceLocatorInstanceHolderStatus.Created;
-    name: string;
-    instance: Instance;
-    creationPromise: null;
-    destroyPromise: null;
-    kind: ServiceLocatorInstanceHolderKind;
-    effects: ServiceLocatorInstanceEffect[];
-    deps: string[];
-    destroyListeners: ServiceLocatorInstanceDestroyListener[];
-    createdAt: number;
-    ttl: number;
-}
+
 export { ServiceLocatorInstanceHolderCreated }
-export { ServiceLocatorInstanceHolderCreated as ServiceLocatorInstanceHolderCreated_alias_1 }
-export { ServiceLocatorInstanceHolderCreated as ServiceLocatorInstanceHolderCreated_alias_2 }
-
-declare interface ServiceLocatorInstanceHolderCreating<Instance> {
-    status: ServiceLocatorInstanceHolderStatus.Creating;
-    name: string;
-    instance: null;
-    creationPromise: Promise<[undefined, Instance]> | null;
-    destroyPromise: null;
-    kind: ServiceLocatorInstanceHolderKind;
-    effects: ServiceLocatorInstanceEffect[];
-    deps: string[];
-    destroyListeners: ServiceLocatorInstanceDestroyListener[];
-    createdAt: number;
-    ttl: number;
-}
+
 export { ServiceLocatorInstanceHolderCreating }
-export { ServiceLocatorInstanceHolderCreating as ServiceLocatorInstanceHolderCreating_alias_1 }
-export { ServiceLocatorInstanceHolderCreating as ServiceLocatorInstanceHolderCreating_alias_2 }
-
-declare interface ServiceLocatorInstanceHolderDestroying<Instance> {
-    status: ServiceLocatorInstanceHolderStatus.Destroying;
-    name: string;
-    instance: Instance | null;
-    creationPromise: null;
-    destroyPromise: Promise<void>;
-    kind: ServiceLocatorInstanceHolderKind;
-    effects: ServiceLocatorInstanceEffect[];
-    deps: string[];
-    destroyListeners: ServiceLocatorInstanceDestroyListener[];
-    createdAt: number;
-    ttl: number;
-}
+
 export { ServiceLocatorInstanceHolderDestroying }
-export { ServiceLocatorInstanceHolderDestroying as ServiceLocatorInstanceHolderDestroying_alias_1 }
-export { ServiceLocatorInstanceHolderDestroying as ServiceLocatorInstanceHolderDestroying_alias_2 }
 
-declare enum ServiceLocatorInstanceHolderKind {
-    Instance = "instance",
-    Factory = "factory",
-    AbstractFactory = "abstractFactory"
-}
 export { ServiceLocatorInstanceHolderKind }
-export { ServiceLocatorInstanceHolderKind as ServiceLocatorInstanceHolderKind_alias_1 }
-export { ServiceLocatorInstanceHolderKind as ServiceLocatorInstanceHolderKind_alias_2 }
 
-declare enum ServiceLocatorInstanceHolderStatus {
-    Created = "created",
-    Creating = "creating",
-    Destroying = "destroying"
-}
 export { ServiceLocatorInstanceHolderStatus }
-export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_1 }
-export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_2 }
-
-declare class ServiceLocatorManager {
-    private readonly logger;
-    private readonly instancesHolders;
-    constructor(logger?: Console | null);
-    get(name: string): [InstanceExpired | InstanceDestroying, ServiceLocatorInstanceHolder] | [InstanceNotFound] | [undefined, ServiceLocatorInstanceHolder];
-    set(name: string, holder: ServiceLocatorInstanceHolder): void;
-    has(name: string): [InstanceExpired | InstanceDestroying] | [undefined, boolean];
-    delete(name: string): boolean;
-    filter(predicate: (value: ServiceLocatorInstanceHolder<any>, key: string) => boolean): Map<string, ServiceLocatorInstanceHolder>;
-}
-export { ServiceLocatorManager }
-export { ServiceLocatorManager as ServiceLocatorManager_alias_1 }
-export { ServiceLocatorManager as ServiceLocatorManager_alias_2 }
 
-declare function setPromiseCollector(collector: null | ((promise: Promise<any>) => void)): typeof promiseCollector;
-export { setPromiseCollector }
-export { setPromiseCollector as setPromiseCollector_alias_1 }
-export { setPromiseCollector as setPromiseCollector_alias_2 }
+export { ServiceLocatorManager }
 
 declare function Stream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType>(endpoint: {
     config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
@@ -1491,6 +1242,21 @@ 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>;
+}
+export { StreamAdapterService }
+export { StreamAdapterService as StreamAdapterService_alias_1 }
+export { StreamAdapterService as StreamAdapterService_alias_2 }
+
+declare const StreamAdapterToken: InjectionToken<StreamAdapterService, undefined>;
+export { StreamAdapterToken }
+export { StreamAdapterToken as StreamAdapterToken_alias_1 }
+export { StreamAdapterToken as StreamAdapterToken_alias_2 }
+
 declare type StreamParams<EndpointDeclaration extends {
     config: BaseStreamConfig<any, any, any, any>;
 }, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends AnyZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, QuerySchema, undefined> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, undefined, undefined>;
@@ -1504,16 +1270,7 @@ export { stripEndSlash as stripEndSlash_alias_1 }
 export { stripEndSlash as stripEndSlash_alias_2 }
 export { stripEndSlash as stripEndSlash_alias_3 }
 
-declare function syncInject<T extends ClassType>(token: T): InstanceType<T>;
-
-declare function syncInject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): T;
-
-declare function syncInject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args: z.input<S>): T;
-
-declare function syncInject<T>(token: InjectionToken<T, undefined>): T;
 export { syncInject }
-export { syncInject as syncInject_alias_1 }
-export { syncInject as syncInject_alias_2 }
 
 declare class UnauthorizedException extends HttpException {
     constructor(message: string | object, error?: Error);
@@ -1522,21 +1279,15 @@ export { UnauthorizedException }
 export { UnauthorizedException as UnauthorizedException_alias_1 }
 export { UnauthorizedException as UnauthorizedException_alias_2 }
 
-declare class UnknownError extends Error {
-    code: ErrorsEnum;
-    parent?: Error;
-    constructor(message: string | Error);
-}
 export { UnknownError }
-export { UnknownError as UnknownError_alias_1 }
-export { UnknownError as UnknownError_alias_2 }
-export { UnknownError as UnknownError_alias_3 }
 
 declare function UseGuards(...guards: (ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>)[]): <T extends Function>(target: T, context: ClassMethodDecoratorContext | ClassDecoratorContext) => T;
 export { UseGuards }
 export { UseGuards as UseGuards_alias_1 }
 export { UseGuards as UseGuards_alias_2 }
 
+export { wrapSyncInit }
+
 declare const yellow: (text: string) => string;
 export { yellow }
 export { yellow as yellow_alias_1 }