@navios/di 0.1.2 → 0.1.4

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

@@ -0,0 +1,517 @@
+import type { AnyZodObject } from 'zod';
+import { z } from 'zod';
+import { ZodOptional } from 'zod';
+
+declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+    readonly token: InjectionToken<T, S>;
+    readonly value: z.input<S>;
+    id: string;
+    name: string | symbol | ClassType;
+    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    constructor(token: InjectionToken<T, S>, value: z.input<S>);
+    toString(): string;
+}
+export { BoundInjectionToken }
+export { BoundInjectionToken as BoundInjectionToken_alias_1 }
+
+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 }
+
+declare type ClassType = new (...args: any[]) => any;
+export { ClassType }
+export { ClassType as ClassType_alias_1 }
+
+declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
+export { ClassTypeWithInstance }
+export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
+
+declare interface CreateInjectorsOptions {
+    baseLocator: ServiceLocator;
+}
+export { CreateInjectorsOptions }
+export { CreateInjectorsOptions as CreateInjectorsOptions_alias_1 }
+export { CreateInjectorsOptions as CreateInjectorsOptions_alias_2 }
+
+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 }
+
+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 }
+
+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 }
+
+declare type EventsArgs<Events extends EventsConfig, Name extends EventsNames<Events>> = Events[Name] extends any[] ? Events[Name] : [];
+export { EventsArgs }
+export { EventsArgs as EventsArgs_alias_1 }
+
+declare type EventsConfig = {
+    [event: string]: any[];
+};
+export { EventsConfig }
+export { EventsConfig as EventsConfig_alias_1 }
+
+declare type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>;
+export { EventsNames }
+export { EventsNames as EventsNames_alias_1 }
+
+declare interface Factory<T> {
+    create(ctx?: any): Promise<T> | T;
+}
+export { Factory }
+export { Factory as Factory_alias_1 }
+export { Factory as Factory_alias_2 }
+
+declare interface FactoryContext {
+    inject: Injectors['inject'];
+    on: ServiceLocatorEventBus['on'];
+    getDependencies: () => string[];
+    invalidate: () => void;
+    addEffect: (listener: () => void) => void;
+    getDestroyListeners: () => (() => void)[];
+    setTtl: (ttl: number) => void;
+    getTtl: () => number;
+    locator: ServiceLocator;
+}
+export { FactoryContext }
+export { FactoryContext as FactoryContext_alias_1 }
+
+declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+    readonly token: InjectionToken<T, S>;
+    readonly factory: () => Promise<z.input<S>>;
+    value?: z.input<S>;
+    resolved: boolean;
+    id: string;
+    name: string | symbol | ClassType;
+    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
+    resolve(): Promise<z.input<S>>;
+    toString(): string;
+}
+export { FactoryInjectionToken }
+export { FactoryInjectionToken as FactoryInjectionToken_alias_1 }
+
+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 }
+
+declare type FactoryRecord<Instance = any, Schema = any> = {
+    scope: InjectableScope;
+    originalToken: InjectionToken<Instance, Schema>;
+    factory: InjectionFactory<Instance, Schema extends AnyZodObject ? z.input<Schema> : unknown>;
+};
+export { FactoryRecord }
+export { FactoryRecord as FactoryRecord_alias_1 }
+
+declare class FactoryTokenNotResolved extends Error {
+    code: ErrorsEnum;
+    constructor(name: string | symbol | ClassType);
+}
+export { FactoryTokenNotResolved }
+export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
+export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
+
+declare interface FactoryWithArgs<T, A extends AnyZodObject> {
+    create(ctx: any, args: z.output<A>): Promise<T> | T;
+}
+export { FactoryWithArgs }
+export { FactoryWithArgs as FactoryWithArgs_alias_1 }
+export { FactoryWithArgs as FactoryWithArgs_alias_2 }
+
+declare function getGlobalServiceLocator(): ServiceLocator;
+export { getGlobalServiceLocator }
+export { getGlobalServiceLocator as getGlobalServiceLocator_alias_1 }
+
+declare function getInjectableToken<R>(target: ClassType): R extends {
+    create(...args: any[]): infer V;
+} ? InjectionToken<V> : InjectionToken<R>;
+export { getInjectableToken }
+export { getInjectableToken as getInjectableToken_alias_1 }
+export { getInjectableToken as getInjectableToken_alias_2 }
+
+declare function getInjectors({ baseLocator }: CreateInjectorsOptions): Injectors;
+export { getInjectors }
+export { getInjectors as getInjectors_alias_1 }
+export { getInjectors as getInjectors_alias_2 }
+
+declare const globalRegistry: Registry;
+export { globalRegistry }
+export { globalRegistry as globalRegistry_alias_1 }
+
+declare const inject: Injectors['inject'];
+export { inject }
+export { inject as inject_alias_1 }
+
+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 }
+
+declare interface InjectableOptions {
+    scope?: InjectableScope;
+    type?: InjectableType;
+    token?: InjectionToken<any, any>;
+    registry?: Registry;
+}
+export { InjectableOptions }
+export { InjectableOptions as InjectableOptions_alias_1 }
+export { InjectableOptions as InjectableOptions_alias_2 }
+
+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 }
+
+declare const InjectableTokenMeta: unique symbol;
+export { InjectableTokenMeta }
+export { InjectableTokenMeta as InjectableTokenMeta_alias_1 }
+export { InjectableTokenMeta as InjectableTokenMeta_alias_2 }
+
+declare enum InjectableType {
+    Class = "Class",
+    Factory = "Factory"
+}
+export { InjectableType }
+export { InjectableType as InjectableType_alias_1 }
+export { InjectableType as InjectableType_alias_2 }
+
+declare type InjectionFactory<T = unknown, Args = unknown> = (ctx: FactoryContext, args: Args) => Promise<T>;
+export { InjectionFactory }
+export { InjectionFactory as InjectionFactory_alias_1 }
+
+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}`;
+    private formattedName;
+    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>;
+    toString(): string;
+}
+export { InjectionToken }
+export { InjectionToken as InjectionToken_alias_1 }
+
+declare interface Injectors {
+    inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
+    inject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+    inject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
+    inject<T>(token: InjectionToken<T, undefined>): Promise<T>;
+    inject<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+    inject<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+    syncInject<T extends ClassType>(token: T): InstanceType<T>;
+    syncInject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): T;
+    syncInject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): T;
+    syncInject<T>(token: InjectionToken<T, undefined>): T;
+    syncInject<T>(token: BoundInjectionToken<T, any>): T;
+    syncInject<T>(token: FactoryInjectionToken<T, any>): T;
+    wrapSyncInit(cb: () => any): () => [any, Promise<any>[]];
+    provideServiceLocator(locator: ServiceLocator): ServiceLocator;
+}
+export { Injectors }
+export { Injectors as Injectors_alias_1 }
+export { Injectors as Injectors_alias_2 }
+
+declare const InjectorsBase: Map<ServiceLocator, Injectors>;
+export { InjectorsBase }
+export { InjectorsBase as InjectorsBase_alias_1 }
+export { InjectorsBase as InjectorsBase_alias_2 }
+
+declare class InstanceDestroying extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+export { InstanceDestroying }
+export { InstanceDestroying as InstanceDestroying_alias_1 }
+export { InstanceDestroying as InstanceDestroying_alias_2 }
+
+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 }
+
+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 }
+
+declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: FactoryContext): ServiceLocator;
+export { makeProxyServiceLocator }
+export { makeProxyServiceLocator as makeProxyServiceLocator_alias_1 }
+
+declare const provideServiceLocator: Injectors['provideServiceLocator'];
+export { provideServiceLocator }
+export { provideServiceLocator as provideServiceLocator_alias_1 }
+
+declare class ProxyServiceLocator implements ServiceLocator {
+    private readonly serviceLocator;
+    private readonly ctx;
+    constructor(serviceLocator: ServiceLocator, ctx: FactoryContext);
+    getEventBus(): ServiceLocatorEventBus;
+    getInstance(token: InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args?: any): Promise<any[]>;
+    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 { ProxyServiceLocator as ProxyServiceLocator_alias_1 }
+
+declare class Registry {
+    private readonly parent?;
+    private readonly factories;
+    constructor(parent?: Registry | undefined);
+    has(token: InjectionToken<any, any>): boolean;
+    get<Instance, Schema>(token: InjectionToken<Instance, Schema>): FactoryRecord<Instance, Schema>;
+    set<Instance, Schema>(token: InjectionToken<Instance, Schema>, factory: InjectionFactory, scope: InjectableScope): void;
+    delete(token: InjectionToken<any, any>): void;
+}
+export { Registry }
+export { Registry as Registry_alias_1 }
+
+declare function resolveService<T extends ClassType>(ctx: FactoryContext, target: T, args?: any[]): Promise<InstanceType<T>>;
+export { resolveService }
+export { resolveService as resolveService_alias_1 }
+
+declare class ServiceLocator {
+    private readonly registry;
+    private readonly logger;
+    private readonly eventBus;
+    private readonly manager;
+    constructor(registry?: Registry, logger?: Console | null);
+    getEventBus(): ServiceLocatorEventBus;
+    storeInstance<Instance>(instance: Instance, token: BoundInjectionToken<Instance, any>): void;
+    storeInstance<Instance>(instance: Instance, token: FactoryInjectionToken<Instance, any>): void;
+    storeInstance<Instance>(instance: Instance, token: InjectionToken<Instance, undefined>): void;
+    storeInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(instance: Instance, token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    removeInstance<Instance>(token: BoundInjectionToken<Instance, any>): void;
+    removeInstance<Instance>(token: FactoryInjectionToken<Instance, any>): void;
+    removeInstance<Instance>(token: InjectionToken<Instance, undefined>): void;
+    removeInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    private resolveTokenArgs;
+    getInstanceIdentifier<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string;
+    getInstanceIdentifier<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string;
+    getInstanceIdentifier<Instance>(token: InjectionToken<Instance, undefined>): string;
+    getInstanceIdentifier<Instance>(token: BoundInjectionToken<Instance, any>): string;
+    getInstanceIdentifier<Instance>(token: FactoryInjectionToken<Instance, any>): string;
+    getInstance<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance>(token: BoundInjectionToken<Instance, any>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance>(token: FactoryInjectionToken<Instance, any>): 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 resolveInstance;
+    private createFactoryContext;
+    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> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: any): string;
+}
+export { ServiceLocator }
+export { ServiceLocator as ServiceLocator_alias_1 }
+
+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 }
+
+declare type ServiceLocatorInstanceDestroyListener = () => void | Promise<void>;
+export { ServiceLocatorInstanceDestroyListener }
+export { ServiceLocatorInstanceDestroyListener as ServiceLocatorInstanceDestroyListener_alias_1 }
+
+declare type ServiceLocatorInstanceEffect = () => void;
+export { ServiceLocatorInstanceEffect }
+export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_1 }
+
+declare type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance>;
+export { ServiceLocatorInstanceHolder }
+export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_1 }
+
+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 }
+
+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 }
+
+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 }
+
+declare enum ServiceLocatorInstanceHolderKind {
+    Instance = "instance",
+    Factory = "factory",
+    AbstractFactory = "abstractFactory"
+}
+export { ServiceLocatorInstanceHolderKind }
+export { ServiceLocatorInstanceHolderKind as ServiceLocatorInstanceHolderKind_alias_1 }
+
+declare enum ServiceLocatorInstanceHolderStatus {
+    Created = "created",
+    Creating = "creating",
+    Destroying = "destroying"
+}
+export { ServiceLocatorInstanceHolderStatus }
+export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_1 }
+
+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 }
+
+declare const syncInject: Injectors['syncInject'];
+export { syncInject }
+export { syncInject as syncInject_alias_1 }
+
+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 }
+
+declare const wrapSyncInit: Injectors['wrapSyncInit'];
+export { wrapSyncInit }
+export { wrapSyncInit as wrapSyncInit_alias_1 }
+
+export { }

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

@@ -0,0 +1,517 @@
+import type { AnyZodObject } from 'zod';
+import { z } from 'zod';
+import { ZodOptional } from 'zod';
+
+declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+    readonly token: InjectionToken<T, S>;
+    readonly value: z.input<S>;
+    id: string;
+    name: string | symbol | ClassType;
+    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    constructor(token: InjectionToken<T, S>, value: z.input<S>);
+    toString(): string;
+}
+export { BoundInjectionToken }
+export { BoundInjectionToken as BoundInjectionToken_alias_1 }
+
+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 }
+
+declare type ClassType = new (...args: any[]) => any;
+export { ClassType }
+export { ClassType as ClassType_alias_1 }
+
+declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
+export { ClassTypeWithInstance }
+export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
+
+declare interface CreateInjectorsOptions {
+    baseLocator: ServiceLocator;
+}
+export { CreateInjectorsOptions }
+export { CreateInjectorsOptions as CreateInjectorsOptions_alias_1 }
+export { CreateInjectorsOptions as CreateInjectorsOptions_alias_2 }
+
+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 }
+
+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 }
+
+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 }
+
+declare type EventsArgs<Events extends EventsConfig, Name extends EventsNames<Events>> = Events[Name] extends any[] ? Events[Name] : [];
+export { EventsArgs }
+export { EventsArgs as EventsArgs_alias_1 }
+
+declare type EventsConfig = {
+    [event: string]: any[];
+};
+export { EventsConfig }
+export { EventsConfig as EventsConfig_alias_1 }
+
+declare type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>;
+export { EventsNames }
+export { EventsNames as EventsNames_alias_1 }
+
+declare interface Factory<T> {
+    create(ctx?: any): Promise<T> | T;
+}
+export { Factory }
+export { Factory as Factory_alias_1 }
+export { Factory as Factory_alias_2 }
+
+declare interface FactoryContext {
+    inject: Injectors['inject'];
+    on: ServiceLocatorEventBus['on'];
+    getDependencies: () => string[];
+    invalidate: () => void;
+    addEffect: (listener: () => void) => void;
+    getDestroyListeners: () => (() => void)[];
+    setTtl: (ttl: number) => void;
+    getTtl: () => number;
+    locator: ServiceLocator;
+}
+export { FactoryContext }
+export { FactoryContext as FactoryContext_alias_1 }
+
+declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+    readonly token: InjectionToken<T, S>;
+    readonly factory: () => Promise<z.input<S>>;
+    value?: z.input<S>;
+    resolved: boolean;
+    id: string;
+    name: string | symbol | ClassType;
+    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
+    resolve(): Promise<z.input<S>>;
+    toString(): string;
+}
+export { FactoryInjectionToken }
+export { FactoryInjectionToken as FactoryInjectionToken_alias_1 }
+
+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 }
+
+declare type FactoryRecord<Instance = any, Schema = any> = {
+    scope: InjectableScope;
+    originalToken: InjectionToken<Instance, Schema>;
+    factory: InjectionFactory<Instance, Schema extends AnyZodObject ? z.input<Schema> : unknown>;
+};
+export { FactoryRecord }
+export { FactoryRecord as FactoryRecord_alias_1 }
+
+declare class FactoryTokenNotResolved extends Error {
+    code: ErrorsEnum;
+    constructor(name: string | symbol | ClassType);
+}
+export { FactoryTokenNotResolved }
+export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
+export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
+
+declare interface FactoryWithArgs<T, A extends AnyZodObject> {
+    create(ctx: any, args: z.output<A>): Promise<T> | T;
+}
+export { FactoryWithArgs }
+export { FactoryWithArgs as FactoryWithArgs_alias_1 }
+export { FactoryWithArgs as FactoryWithArgs_alias_2 }
+
+declare function getGlobalServiceLocator(): ServiceLocator;
+export { getGlobalServiceLocator }
+export { getGlobalServiceLocator as getGlobalServiceLocator_alias_1 }
+
+declare function getInjectableToken<R>(target: ClassType): R extends {
+    create(...args: any[]): infer V;
+} ? InjectionToken<V> : InjectionToken<R>;
+export { getInjectableToken }
+export { getInjectableToken as getInjectableToken_alias_1 }
+export { getInjectableToken as getInjectableToken_alias_2 }
+
+declare function getInjectors({ baseLocator }: CreateInjectorsOptions): Injectors;
+export { getInjectors }
+export { getInjectors as getInjectors_alias_1 }
+export { getInjectors as getInjectors_alias_2 }
+
+declare const globalRegistry: Registry;
+export { globalRegistry }
+export { globalRegistry as globalRegistry_alias_1 }
+
+declare const inject: Injectors['inject'];
+export { inject }
+export { inject as inject_alias_1 }
+
+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 }
+
+declare interface InjectableOptions {
+    scope?: InjectableScope;
+    type?: InjectableType;
+    token?: InjectionToken<any, any>;
+    registry?: Registry;
+}
+export { InjectableOptions }
+export { InjectableOptions as InjectableOptions_alias_1 }
+export { InjectableOptions as InjectableOptions_alias_2 }
+
+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 }
+
+declare const InjectableTokenMeta: unique symbol;
+export { InjectableTokenMeta }
+export { InjectableTokenMeta as InjectableTokenMeta_alias_1 }
+export { InjectableTokenMeta as InjectableTokenMeta_alias_2 }
+
+declare enum InjectableType {
+    Class = "Class",
+    Factory = "Factory"
+}
+export { InjectableType }
+export { InjectableType as InjectableType_alias_1 }
+export { InjectableType as InjectableType_alias_2 }
+
+declare type InjectionFactory<T = unknown, Args = unknown> = (ctx: FactoryContext, args: Args) => Promise<T>;
+export { InjectionFactory }
+export { InjectionFactory as InjectionFactory_alias_1 }
+
+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}`;
+    private formattedName;
+    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>;
+    toString(): string;
+}
+export { InjectionToken }
+export { InjectionToken as InjectionToken_alias_1 }
+
+declare interface Injectors {
+    inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
+    inject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+    inject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
+    inject<T>(token: InjectionToken<T, undefined>): Promise<T>;
+    inject<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+    inject<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+    syncInject<T extends ClassType>(token: T): InstanceType<T>;
+    syncInject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): T;
+    syncInject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): T;
+    syncInject<T>(token: InjectionToken<T, undefined>): T;
+    syncInject<T>(token: BoundInjectionToken<T, any>): T;
+    syncInject<T>(token: FactoryInjectionToken<T, any>): T;
+    wrapSyncInit(cb: () => any): () => [any, Promise<any>[]];
+    provideServiceLocator(locator: ServiceLocator): ServiceLocator;
+}
+export { Injectors }
+export { Injectors as Injectors_alias_1 }
+export { Injectors as Injectors_alias_2 }
+
+declare const InjectorsBase: Map<ServiceLocator, Injectors>;
+export { InjectorsBase }
+export { InjectorsBase as InjectorsBase_alias_1 }
+export { InjectorsBase as InjectorsBase_alias_2 }
+
+declare class InstanceDestroying extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+export { InstanceDestroying }
+export { InstanceDestroying as InstanceDestroying_alias_1 }
+export { InstanceDestroying as InstanceDestroying_alias_2 }
+
+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 }
+
+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 }
+
+declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: FactoryContext): ServiceLocator;
+export { makeProxyServiceLocator }
+export { makeProxyServiceLocator as makeProxyServiceLocator_alias_1 }
+
+declare const provideServiceLocator: Injectors['provideServiceLocator'];
+export { provideServiceLocator }
+export { provideServiceLocator as provideServiceLocator_alias_1 }
+
+declare class ProxyServiceLocator implements ServiceLocator {
+    private readonly serviceLocator;
+    private readonly ctx;
+    constructor(serviceLocator: ServiceLocator, ctx: FactoryContext);
+    getEventBus(): ServiceLocatorEventBus;
+    getInstance(token: InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args?: any): Promise<any[]>;
+    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 { ProxyServiceLocator as ProxyServiceLocator_alias_1 }
+
+declare class Registry {
+    private readonly parent?;
+    private readonly factories;
+    constructor(parent?: Registry | undefined);
+    has(token: InjectionToken<any, any>): boolean;
+    get<Instance, Schema>(token: InjectionToken<Instance, Schema>): FactoryRecord<Instance, Schema>;
+    set<Instance, Schema>(token: InjectionToken<Instance, Schema>, factory: InjectionFactory, scope: InjectableScope): void;
+    delete(token: InjectionToken<any, any>): void;
+}
+export { Registry }
+export { Registry as Registry_alias_1 }
+
+declare function resolveService<T extends ClassType>(ctx: FactoryContext, target: T, args?: any[]): Promise<InstanceType<T>>;
+export { resolveService }
+export { resolveService as resolveService_alias_1 }
+
+declare class ServiceLocator {
+    private readonly registry;
+    private readonly logger;
+    private readonly eventBus;
+    private readonly manager;
+    constructor(registry?: Registry, logger?: Console | null);
+    getEventBus(): ServiceLocatorEventBus;
+    storeInstance<Instance>(instance: Instance, token: BoundInjectionToken<Instance, any>): void;
+    storeInstance<Instance>(instance: Instance, token: FactoryInjectionToken<Instance, any>): void;
+    storeInstance<Instance>(instance: Instance, token: InjectionToken<Instance, undefined>): void;
+    storeInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(instance: Instance, token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    removeInstance<Instance>(token: BoundInjectionToken<Instance, any>): void;
+    removeInstance<Instance>(token: FactoryInjectionToken<Instance, any>): void;
+    removeInstance<Instance>(token: InjectionToken<Instance, undefined>): void;
+    removeInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    private resolveTokenArgs;
+    getInstanceIdentifier<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string;
+    getInstanceIdentifier<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string;
+    getInstanceIdentifier<Instance>(token: InjectionToken<Instance, undefined>): string;
+    getInstanceIdentifier<Instance>(token: BoundInjectionToken<Instance, any>): string;
+    getInstanceIdentifier<Instance>(token: FactoryInjectionToken<Instance, any>): string;
+    getInstance<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance>(token: BoundInjectionToken<Instance, any>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance>(token: FactoryInjectionToken<Instance, any>): 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 resolveInstance;
+    private createFactoryContext;
+    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> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: any): string;
+}
+export { ServiceLocator }
+export { ServiceLocator as ServiceLocator_alias_1 }
+
+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 }
+
+declare type ServiceLocatorInstanceDestroyListener = () => void | Promise<void>;
+export { ServiceLocatorInstanceDestroyListener }
+export { ServiceLocatorInstanceDestroyListener as ServiceLocatorInstanceDestroyListener_alias_1 }
+
+declare type ServiceLocatorInstanceEffect = () => void;
+export { ServiceLocatorInstanceEffect }
+export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_1 }
+
+declare type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance>;
+export { ServiceLocatorInstanceHolder }
+export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_1 }
+
+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 }
+
+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 }
+
+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 }
+
+declare enum ServiceLocatorInstanceHolderKind {
+    Instance = "instance",
+    Factory = "factory",
+    AbstractFactory = "abstractFactory"
+}
+export { ServiceLocatorInstanceHolderKind }
+export { ServiceLocatorInstanceHolderKind as ServiceLocatorInstanceHolderKind_alias_1 }
+
+declare enum ServiceLocatorInstanceHolderStatus {
+    Created = "created",
+    Creating = "creating",
+    Destroying = "destroying"
+}
+export { ServiceLocatorInstanceHolderStatus }
+export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_1 }
+
+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 }
+
+declare const syncInject: Injectors['syncInject'];
+export { syncInject }
+export { syncInject as syncInject_alias_1 }
+
+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 }
+
+declare const wrapSyncInit: Injectors['wrapSyncInit'];
+export { wrapSyncInit }
+export { wrapSyncInit as wrapSyncInit_alias_1 }
+
+export { }

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+export { Injectable } from './_tsup-dts-rollup.mjs';
+export { InjectableOptions } from './_tsup-dts-rollup.mjs';
+export { InjectableScope } from './_tsup-dts-rollup.mjs';
+export { InjectableType } from './_tsup-dts-rollup.mjs';
+export { ErrorsEnum } from './_tsup-dts-rollup.mjs';
+export { FactoryNotFound } from './_tsup-dts-rollup.mjs';
+export { FactoryTokenNotResolved } from './_tsup-dts-rollup.mjs';
+export { InstanceDestroying } from './_tsup-dts-rollup.mjs';
+export { InstanceExpired } from './_tsup-dts-rollup.mjs';
+export { InstanceNotFound } from './_tsup-dts-rollup.mjs';
+export { UnknownError } from './_tsup-dts-rollup.mjs';
+export { Factory } from './_tsup-dts-rollup.mjs';
+export { FactoryWithArgs } from './_tsup-dts-rollup.mjs';
+export { getInjectors } from './_tsup-dts-rollup.mjs';
+export { CreateInjectorsOptions } from './_tsup-dts-rollup.mjs';
+export { Injectors } from './_tsup-dts-rollup.mjs';
+export { InjectorsBase } from './_tsup-dts-rollup.mjs';
+export { getInjectableToken } from './_tsup-dts-rollup.mjs';
+export { EventsConfig_alias_1 as EventsConfig } from './_tsup-dts-rollup.mjs';
+export { EventsNames_alias_1 as EventsNames } from './_tsup-dts-rollup.mjs';
+export { EventsArgs_alias_1 as EventsArgs } from './_tsup-dts-rollup.mjs';
+export { ChannelEmitter_alias_1 as ChannelEmitter } from './_tsup-dts-rollup.mjs';
+export { EventEmitterInterface_alias_1 as EventEmitterInterface } from './_tsup-dts-rollup.mjs';
+export { EventEmitter_alias_1 as EventEmitter } from './_tsup-dts-rollup.mjs';
+export { FactoryContext_alias_1 as FactoryContext } from './_tsup-dts-rollup.mjs';
+export { ClassType } from './_tsup-dts-rollup.mjs';
+export { ClassTypeWithInstance } from './_tsup-dts-rollup.mjs';
+export { InjectionToken } from './_tsup-dts-rollup.mjs';
+export { BoundInjectionToken } from './_tsup-dts-rollup.mjs';
+export { FactoryInjectionToken } from './_tsup-dts-rollup.mjs';
+export { getGlobalServiceLocator } from './_tsup-dts-rollup.mjs';
+export { inject } from './_tsup-dts-rollup.mjs';
+export { syncInject } from './_tsup-dts-rollup.mjs';
+export { wrapSyncInit } from './_tsup-dts-rollup.mjs';
+export { provideServiceLocator } from './_tsup-dts-rollup.mjs';
+export { makeProxyServiceLocator } from './_tsup-dts-rollup.mjs';
+export { ProxyServiceLocator } from './_tsup-dts-rollup.mjs';
+export { InjectionFactory } from './_tsup-dts-rollup.mjs';
+export { FactoryRecord } from './_tsup-dts-rollup.mjs';
+export { Registry } from './_tsup-dts-rollup.mjs';
+export { globalRegistry } from './_tsup-dts-rollup.mjs';
+export { resolveService } from './_tsup-dts-rollup.mjs';
+export { ServiceLocator } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorEventBus } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceHolderKind } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceHolderStatus } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceEffect } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceDestroyListener } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceHolderCreating } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceHolderCreated } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceHolderDestroying } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorInstanceHolder } from './_tsup-dts-rollup.mjs';
+export { ServiceLocatorManager } from './_tsup-dts-rollup.mjs';
+export { InjectableTokenMeta } from './_tsup-dts-rollup.mjs';

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+export { Injectable } from './_tsup-dts-rollup.js';
+export { InjectableOptions } from './_tsup-dts-rollup.js';
+export { InjectableScope } from './_tsup-dts-rollup.js';
+export { InjectableType } from './_tsup-dts-rollup.js';
+export { ErrorsEnum } from './_tsup-dts-rollup.js';
+export { FactoryNotFound } from './_tsup-dts-rollup.js';
+export { FactoryTokenNotResolved } from './_tsup-dts-rollup.js';
+export { InstanceDestroying } from './_tsup-dts-rollup.js';
+export { InstanceExpired } from './_tsup-dts-rollup.js';
+export { InstanceNotFound } from './_tsup-dts-rollup.js';
+export { UnknownError } from './_tsup-dts-rollup.js';
+export { Factory } from './_tsup-dts-rollup.js';
+export { FactoryWithArgs } from './_tsup-dts-rollup.js';
+export { getInjectors } from './_tsup-dts-rollup.js';
+export { CreateInjectorsOptions } from './_tsup-dts-rollup.js';
+export { Injectors } from './_tsup-dts-rollup.js';
+export { InjectorsBase } from './_tsup-dts-rollup.js';
+export { getInjectableToken } from './_tsup-dts-rollup.js';
+export { EventsConfig_alias_1 as EventsConfig } from './_tsup-dts-rollup.js';
+export { EventsNames_alias_1 as EventsNames } from './_tsup-dts-rollup.js';
+export { EventsArgs_alias_1 as EventsArgs } from './_tsup-dts-rollup.js';
+export { ChannelEmitter_alias_1 as ChannelEmitter } from './_tsup-dts-rollup.js';
+export { EventEmitterInterface_alias_1 as EventEmitterInterface } from './_tsup-dts-rollup.js';
+export { EventEmitter_alias_1 as EventEmitter } from './_tsup-dts-rollup.js';
+export { FactoryContext_alias_1 as FactoryContext } from './_tsup-dts-rollup.js';
+export { ClassType } from './_tsup-dts-rollup.js';
+export { ClassTypeWithInstance } from './_tsup-dts-rollup.js';
+export { InjectionToken } from './_tsup-dts-rollup.js';
+export { BoundInjectionToken } from './_tsup-dts-rollup.js';
+export { FactoryInjectionToken } from './_tsup-dts-rollup.js';
+export { getGlobalServiceLocator } from './_tsup-dts-rollup.js';
+export { inject } from './_tsup-dts-rollup.js';
+export { syncInject } from './_tsup-dts-rollup.js';
+export { wrapSyncInit } from './_tsup-dts-rollup.js';
+export { provideServiceLocator } from './_tsup-dts-rollup.js';
+export { makeProxyServiceLocator } from './_tsup-dts-rollup.js';
+export { ProxyServiceLocator } from './_tsup-dts-rollup.js';
+export { InjectionFactory } from './_tsup-dts-rollup.js';
+export { FactoryRecord } from './_tsup-dts-rollup.js';
+export { Registry } from './_tsup-dts-rollup.js';
+export { globalRegistry } from './_tsup-dts-rollup.js';
+export { resolveService } from './_tsup-dts-rollup.js';
+export { ServiceLocator } from './_tsup-dts-rollup.js';
+export { ServiceLocatorEventBus } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceHolderKind } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceHolderStatus } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceEffect } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceDestroyListener } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceHolderCreating } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceHolderCreated } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceHolderDestroying } from './_tsup-dts-rollup.js';
+export { ServiceLocatorInstanceHolder } from './_tsup-dts-rollup.js';
+export { ServiceLocatorManager } from './_tsup-dts-rollup.js';
+export { InjectableTokenMeta } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -229,6 +229,9 @@ function makeProxyServiceLocator(serviceLocator, ctx) {
   return new ProxyServiceLocator(serviceLocator, ctx);
 }
 
+// packages/di/src/symbols/injectable-token.mts
+var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+
 // packages/di/src/utils/get-injectors.mts
 var InjectorsBase = /* @__PURE__ */ new Map();
 function getInjectors({ baseLocator }) {
@@ -333,7 +336,6 @@ async function resolveService(ctx, target, args = []) {
 }
 
 // packages/di/src/decorators/injectable.decorator.mts
-var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
 function Injectable({
   scope = "Singleton" /* Singleton */,
   type = "Class" /* Class */,
@@ -978,9 +980,13 @@ function getGlobalServiceLocator() {
   }
   return globalServiceLocator;
 }
-var { inject, syncInject, wrapSyncInit, provideServiceLocator } = getInjectors({
+var values = getInjectors({
   baseLocator: globalServiceLocator
 });
+var inject = values.inject;
+var syncInject = values.syncInject;
+var wrapSyncInit = values.wrapSyncInit;
+var provideServiceLocator = values.provideServiceLocator;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BoundInjectionToken,

package/dist/index.mjs

@@ -171,6 +171,9 @@ function makeProxyServiceLocator(serviceLocator, ctx) {
   return new ProxyServiceLocator(serviceLocator, ctx);
 }
 
+// packages/di/src/symbols/injectable-token.mts
+var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+
 // packages/di/src/utils/get-injectors.mts
 var InjectorsBase = /* @__PURE__ */ new Map();
 function getInjectors({ baseLocator }) {
@@ -275,7 +278,6 @@ async function resolveService(ctx, target, args = []) {
 }
 
 // packages/di/src/decorators/injectable.decorator.mts
-var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
 function Injectable({
   scope = "Singleton" /* Singleton */,
   type = "Class" /* Class */,
@@ -920,9 +922,13 @@ function getGlobalServiceLocator() {
   }
   return globalServiceLocator;
 }
-var { inject, syncInject, wrapSyncInit, provideServiceLocator } = getInjectors({
+var values = getInjectors({
   baseLocator: globalServiceLocator
 });
+var inject = values.inject;
+var syncInject = values.syncInject;
+var wrapSyncInit = values.wrapSyncInit;
+var provideServiceLocator = values.provideServiceLocator;
 export {
   BoundInjectionToken,
   ErrorsEnum,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/di",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
@@ -15,7 +15,7 @@
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "peerDependencies": {
-    "@navios/common": "^0.1.5",
+    "@navios/common": "^0.1.6",
     "zod": "^3.23.8"
   },
   "exports": {
@@ -32,7 +32,7 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@navios/common": "^0.1.5",
+    "@navios/common": "^0.1.6",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "zod": "^3.24.4"

package/src/decorators/injectable.decorator.mts

@@ -10,6 +10,7 @@ import { InjectableScope, InjectableType } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
 import { globalRegistry } from '../registry.mjs'
 import { resolveService } from '../resolve-service.mjs'
+import { InjectableTokenMeta } from '../symbols/index.mjs'
 
 export interface InjectableOptions {
   scope?: InjectableScope
@@ -18,8 +19,6 @@ export interface InjectableOptions {
   registry?: Registry
 }
 
-export const InjectableTokenMeta = Symbol.for('InjectableTokenMeta')
-
 export function Injectable(): <T extends ClassType>(
   target: T,
   context: ClassDecoratorContext,

package/src/index.mts

@@ -14,3 +14,4 @@ export * from './service-locator.mjs'
 export * from './service-locator-event-bus.mjs'
 export * from './service-locator-instance-holder.mjs'
 export * from './service-locator-manager.mjs'
+export * from './symbols/injectable-token.mjs'

package/src/injector.mts

@@ -1,3 +1,5 @@
+import type { Injectors } from './utils/index.mjs'
+
 import { ServiceLocator } from './service-locator.mjs'
 import { getInjectors } from './utils/index.mjs'
 
@@ -11,9 +13,15 @@ export function getGlobalServiceLocator(): ServiceLocator {
   }
   return globalServiceLocator
 }
-const { inject, syncInject, wrapSyncInit, provideServiceLocator } =
-  getInjectors({
-    baseLocator: globalServiceLocator,
-  })
+const values = getInjectors({
+  baseLocator: globalServiceLocator,
+})
+
+export const inject: Injectors['inject'] = values.inject
+
+export const syncInject: Injectors['syncInject'] = values.syncInject
+
+export const wrapSyncInit: Injectors['wrapSyncInit'] = values.wrapSyncInit
 
-export { inject, syncInject, wrapSyncInit, provideServiceLocator }
+export const provideServiceLocator: Injectors['provideServiceLocator'] =
+  values.provideServiceLocator

package/src/symbols/index.mts

@@ -0,0 +1 @@
+export * from './injectable-token.mjs'

package/src/symbols/injectable-token.mts

@@ -0,0 +1 @@
+export const InjectableTokenMeta = Symbol.for('InjectableTokenMeta')

package/src/utils/get-injectable-token.mts

@@ -1,6 +1,6 @@
 import type { ClassType, InjectionToken } from '../injection-token.mjs'
 
-import { InjectableTokenMeta } from '../decorators/index.mjs'
+import { InjectableTokenMeta } from '../symbols/injectable-token.mjs'
 
 export function getInjectableToken<R>(
   target: ClassType,

package/src/utils/get-injectors.mts

@@ -1,14 +1,14 @@
 import type { AnyZodObject, z, ZodOptional } from 'zod'
 
-import type { ClassType } from '../injection-token.mjs'
-import type { ServiceLocator } from '../service-locator.mjs'
-
-import { InjectableTokenMeta } from '../decorators/index.mjs'
-import {
+import type {
   BoundInjectionToken,
+  ClassType,
   FactoryInjectionToken,
   InjectionToken,
 } from '../injection-token.mjs'
+import type { ServiceLocator } from '../service-locator.mjs'
+
+import { InjectableTokenMeta } from '../symbols/index.mjs'
 
 export interface CreateInjectorsOptions {
   baseLocator: ServiceLocator