@navios/di 0.1.7 → 0.1.9

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

@@ -1,541 +0,0 @@
-import type { AnyZodObject } from 'zod';
-import { z } from 'zod';
-import { ZodOptional } from 'zod';
-import { ZodRecord } from 'zod';
-
-declare type BaseInjectionTokenSchemaType = AnyZodObject | ZodRecord;
-export { BaseInjectionTokenSchemaType }
-export { BaseInjectionTokenSchemaType as BaseInjectionTokenSchemaType_alias_1 }
-
-declare class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
-    readonly token: InjectionToken<T, S>;
-    readonly value: z.input<S>;
-    id: string;
-    name: string | symbol | ClassType;
-    schema: InjectionTokenSchemaType;
-    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 ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
-export { ClassTypeWithArgument }
-export { ClassTypeWithArgument as ClassTypeWithArgument_alias_1 }
-
-declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
-export { ClassTypeWithInstance }
-export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
-
-declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
-export { ClassTypeWithInstanceAndArgument }
-export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_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 InjectionTokenSchemaType> {
-    readonly token: InjectionToken<T, S>;
-    readonly factory: () => Promise<z.input<S>>;
-    value?: z.input<S>;
-    resolved: boolean;
-    id: string;
-    name: string | symbol | ClassType;
-    schema: InjectionTokenSchemaType;
-    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 InjectionTokenSchemaType> {
-    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;
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<S extends InjectionTokenSchemaType>(options: {
-    scope?: InjectableScope;
-    type?: InjectableType.Class;
-    token: InjectionToken<undefined, S>;
-}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends InjectionTokenSchemaType>(options: {
-    scope?: InjectableScope;
-    type?: InjectableType.Class;
-    token: InjectionToken<R, S>;
-}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends InjectionTokenSchemaType>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, S>;
-}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, undefined>;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
-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 InjectionTokenSchemaType | 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 InjectionTokenSchemaType>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
-    static create<T>(name: string | symbol): InjectionToken<T, undefined>;
-    static create<T, Schema extends InjectionTokenSchemaType>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
-    static bound<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
-    static factory<T, S extends InjectionTokenSchemaType>(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 type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalInjectionTokenSchemaType;
-export { InjectionTokenSchemaType }
-export { InjectionTokenSchemaType as InjectionTokenSchemaType_alias_1 }
-
-declare interface Injectors {
-    inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
-    inject<T, S extends BaseInjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-    inject<T, S extends OptionalInjectionTokenSchemaType>(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 BaseInjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T;
-    syncInject<T, S extends OptionalInjectionTokenSchemaType>(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 type OptionalInjectionTokenSchemaType = ZodOptional<AnyZodObject> | ZodOptional<ZodRecord>;
-export { OptionalInjectionTokenSchemaType }
-export { OptionalInjectionTokenSchemaType as OptionalInjectionTokenSchemaType_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 BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
-    removeInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): void;
-    private resolveTokenArgs;
-    getInstanceIdentifier<Instance, Schema extends BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string;
-    getInstanceIdentifier<Instance, Schema extends OptionalInjectionTokenSchemaType>(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 BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(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 InjectionTokenSchemaType | 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 InjectionTokenSchemaType | 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

@@ -1,59 +0,0 @@
-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 { ClassTypeWithArgument } from './_tsup-dts-rollup.mjs';
-export { ClassTypeWithInstance } from './_tsup-dts-rollup.mjs';
-export { ClassTypeWithInstanceAndArgument } from './_tsup-dts-rollup.mjs';
-export { BaseInjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';
-export { OptionalInjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';
-export { InjectionTokenSchemaType } 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

@@ -1,59 +0,0 @@
-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 { ClassTypeWithArgument } from './_tsup-dts-rollup.js';
-export { ClassTypeWithInstance } from './_tsup-dts-rollup.js';
-export { ClassTypeWithInstanceAndArgument } from './_tsup-dts-rollup.js';
-export { BaseInjectionTokenSchemaType } from './_tsup-dts-rollup.js';
-export { OptionalInjectionTokenSchemaType } from './_tsup-dts-rollup.js';
-export { InjectionTokenSchemaType } 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';