@navios/core 0.1.15 → 0.2.0

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

@@ -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;
@@ -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;
@@ -414,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>>;
@@ -466,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';
 
@@ -560,44 +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> | 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 declare interface FactoryWithArgs<T, A extends AnyZodObject> {
-    create(ctx: any, args: z.output<A>): Promise<T> | T;
-}
+export { FactoryWithArgs }
 
 /**
  * @publicApi
@@ -630,23 +602,18 @@ 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>;
@@ -711,150 +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(): <T extends ClassType>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
-
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
-
-declare function Injectable<R, S extends AnyZodObject>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, S>;
-}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<R, S>;
-};
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, undefined>;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
 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);
@@ -1146,7 +994,7 @@ 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({ controllers, imports, guards }?: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => any;
 export { Module }
@@ -1299,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 }
@@ -1345,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 }
@@ -1382,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>;
@@ -1579,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);
@@ -1597,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 }