@navios/di 0.2.0 → 0.3.0

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

@@ -4,7 +4,15 @@ import type { ZodOptional } from 'zod/v4';
 import type { ZodRecord } from 'zod/v4';
 import type { ZodType } from 'zod/v4';
 
-declare type BaseInjectionTokenSchemaType = ZodObject<any> | ZodRecord;
+declare type AnyInjectableType = ClassType | InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
+export { AnyInjectableType }
+export { AnyInjectableType as AnyInjectableType_alias_1 }
+
+declare const asyncInject: Injectors['asyncInject'];
+export { asyncInject }
+export { asyncInject as asyncInject_alias_1 }
+
+declare type BaseInjectionTokenSchemaType = ZodObject | ZodRecord;
 export { BaseInjectionTokenSchemaType }
 export { BaseInjectionTokenSchemaType as BaseInjectionTokenSchemaType_alias_1 }
 
@@ -50,12 +58,144 @@ declare type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any;
 export { ClassTypeWithOptionalArgument }
 export { ClassTypeWithOptionalArgument as ClassTypeWithOptionalArgument_alias_1 }
 
-declare interface CreateInjectorsOptions {
-    baseLocator: ServiceLocator;
+/**
+ * Container class that provides a simplified public API for dependency injection.
+ * It wraps a ServiceLocator instance and provides convenient methods for getting instances.
+ */
+declare class Container {
+    private readonly serviceLocator;
+    constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
+    private registerSelf;
+    /**
+     * Gets an instance from the container.
+     * This method has the same type signature as the inject method from get-injectors.mts
+     */
+    get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
+    get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+    get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+    get<T>(token: InjectionToken<T, undefined>): Promise<T>;
+    get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+    get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+    /**
+     * Gets the underlying ServiceLocator instance for advanced usage
+     */
+    getServiceLocator(): ServiceLocator;
+    /**
+     * Invalidates a service and its dependencies
+     */
+    invalidate(service: unknown): Promise<void>;
+    /**
+     * Waits for all pending operations to complete
+     */
+    ready(): Promise<void>;
+    /**
+     * Begins a new request context with the given parameters.
+     * @param requestId Unique identifier for this request
+     * @param metadata Optional metadata for the request
+     * @param priority Priority for resolution (higher = more priority)
+     * @returns The created request context holder
+     */
+    beginRequest(requestId: string, metadata?: Record<string, any>, priority?: number): RequestContextHolder;
+    /**
+     * Ends a request context and cleans up all associated instances.
+     * @param requestId The request ID to end
+     */
+    endRequest(requestId: string): Promise<void>;
+    /**
+     * Gets the current request context.
+     * @returns The current request context holder or null
+     */
+    getCurrentRequestContext(): RequestContextHolder | null;
+    /**
+     * Sets the current request context.
+     * @param requestId The request ID to set as current
+     */
+    setCurrentRequestContext(requestId: string): void;
+}
+export { Container }
+export { Container as Container_alias_1 }
+
+/**
+ * Creates a new deferred promise.
+ * @returns A new Deferred instance
+ */
+declare function createDeferred<T>(): Deferred<T>;
+export { createDeferred }
+export { createDeferred as createDeferred_alias_1 }
+export { createDeferred as createDeferred_alias_2 }
+
+/**
+ * Creates a new request context holder with the given parameters.
+ */
+declare function createRequestContextHolder(requestId: string, priority?: number, initialMetadata?: Record<string, any>): RequestContextHolder;
+export { createRequestContextHolder }
+export { createRequestContextHolder as createRequestContextHolder_alias_1 }
+
+declare const defaultInjectors: Injectors;
+export { defaultInjectors }
+export { defaultInjectors as defaultInjectors_alias_1 }
+
+/**
+ * Default implementation of RequestContextHolder.
+ */
+declare class DefaultRequestContextHolder implements RequestContextHolder {
+    readonly requestId: string;
+    readonly priority: number;
+    readonly instances: Map<string, any>;
+    readonly holders: Map<string, ServiceLocatorInstanceHolder>;
+    readonly metadata: Map<string, any>;
+    readonly createdAt: number;
+    constructor(requestId: string, priority?: number, initialMetadata?: Record<string, any>);
+    addInstance(instanceName: string, instance: any, holder: ServiceLocatorInstanceHolder): void;
+    getInstance(instanceName: string): any | undefined;
+    getHolder(instanceName: string): ServiceLocatorInstanceHolder | undefined;
+    hasInstance(instanceName: string): boolean;
+    clear(): void;
+    getMetadata(key: string): any | undefined;
+    setMetadata(key: string, value: any): void;
 }
-export { CreateInjectorsOptions }
-export { CreateInjectorsOptions as CreateInjectorsOptions_alias_1 }
-export { CreateInjectorsOptions as CreateInjectorsOptions_alias_2 }
+export { DefaultRequestContextHolder }
+export { DefaultRequestContextHolder as DefaultRequestContextHolder_alias_1 }
+
+/**
+ * Creates a deferred promise that can be resolved or rejected externally.
+ * This is useful for creating stub holders that can be fulfilled later.
+ */
+declare class Deferred<T> {
+    readonly promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    private _isResolved;
+    private _isRejected;
+    constructor();
+    /**
+     * Resolves the deferred promise with the given value.
+     * @param value The value to resolve with
+     * @throws Error if the promise has already been resolved or rejected
+     */
+    resolve(value: T): void;
+    /**
+     * Rejects the deferred promise with the given reason.
+     * @param reason The reason for rejection
+     * @throws Error if the promise has already been resolved or rejected
+     */
+    reject(reason?: any): void;
+    /**
+     * Returns true if the promise has been resolved.
+     */
+    get isResolved(): boolean;
+    /**
+     * Returns true if the promise has been rejected.
+     */
+    get isRejected(): boolean;
+    /**
+     * Returns true if the promise has been settled (resolved or rejected).
+     */
+    get isSettled(): boolean;
+}
+export { Deferred }
+export { Deferred as Deferred_alias_1 }
+export { Deferred as Deferred_alias_2 }
 
 declare enum ErrorsEnum {
     InstanceExpired = "InstanceExpired",
@@ -75,7 +215,6 @@ declare class EventEmitter<Events extends EventsConfig = {}> implements EventEmi
     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 }
@@ -83,7 +222,6 @@ 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 }
@@ -102,37 +240,54 @@ declare type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, sy
 export { EventsNames }
 export { EventsNames as EventsNames_alias_1 }
 
-declare interface Factory<T> {
+declare interface Factorable<T> {
     create(ctx?: FactoryContext): Promise<T> | T;
 }
+export { Factorable }
+export { Factorable as Factorable_alias_1 }
+export { Factorable as Factorable_alias_2 }
+
+declare interface FactorableWithArgs<T, A extends InjectionTokenSchemaType> {
+    create(ctx?: FactoryContext, ...args: [z.output<A>]): Promise<T> | T;
+}
+export { FactorableWithArgs }
+export { FactorableWithArgs as FactorableWithArgs_alias_1 }
+export { FactorableWithArgs as FactorableWithArgs_alias_2 }
+
+declare function Factory<R>(options?: {
+    scope?: InjectableScope;
+    registry?: Registry;
+}): <T extends ClassTypeWithInstance<Factorable<R>>>(target: T, context?: ClassDecoratorContext) => T;
+
+declare function Factory<R, S>(options: {
+    scope?: InjectableScope;
+    token: InjectionToken<R, S>;
+    registry?: Registry;
+}): R extends undefined ? never : S extends InjectionTokenSchemaType ? <T extends ClassTypeWithInstance<FactorableWithArgs<R, S>>>(// #2.2.1 Token have a schema
+target: T, context?: ClassDecoratorContext) => T : S extends undefined ? <T extends ClassTypeWithInstance<Factorable<R>>>(// #2.3.1 Token without a schema
+target: T, context?: ClassDecoratorContext) => T : never;
 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;
+    inject: Injectors['asyncInject'];
     locator: ServiceLocator;
+    addDestroyListener: (listener: () => void) => void;
 }
 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>>;
+    readonly factory: (ctx: FactoryContext) => 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>>;
+    constructor(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>);
+    resolve(ctx: FactoryContext): Promise<z.input<S>>;
     toString(): string;
 }
 export { FactoryInjectionToken }
@@ -147,10 +302,20 @@ export { FactoryNotFound }
 export { FactoryNotFound as FactoryNotFound_alias_1 }
 export { FactoryNotFound as FactoryNotFound_alias_2 }
 
+declare interface FactoryOptions {
+    scope?: InjectableScope;
+    token?: InjectionToken<any, any>;
+    registry?: Registry;
+}
+export { FactoryOptions }
+export { FactoryOptions as FactoryOptions_alias_1 }
+export { FactoryOptions as FactoryOptions_alias_2 }
+
 declare type FactoryRecord<Instance = any, Schema = any> = {
     scope: InjectableScope;
     originalToken: InjectionToken<Instance, Schema>;
-    factory: InjectionFactory<Instance, Schema extends ZodObject<any> ? z.input<Schema> : unknown>;
+    target: ClassType;
+    type: InjectableType;
 };
 export { FactoryRecord }
 export { FactoryRecord as FactoryRecord_alias_1 }
@@ -163,17 +328,6 @@ export { FactoryTokenNotResolved }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
 
-declare interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
-    create(...args: [FactoryContext, 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>;
@@ -181,7 +335,7 @@ export { getInjectableToken }
 export { getInjectableToken as getInjectableToken_alias_1 }
 export { getInjectableToken as getInjectableToken_alias_2 }
 
-declare function getInjectors({ baseLocator }: CreateInjectorsOptions): Injectors;
+declare function getInjectors(): Injectors;
 export { getInjectors }
 export { getInjectors as getInjectors_alias_1 }
 export { getInjectors as getInjectors_alias_2 }
@@ -197,18 +351,16 @@ export { inject as inject_alias_1 }
 declare function Injectable(): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T;
 
 declare function Injectable(options: {
+    scope?: InjectableScope;
     registry: Registry;
 }): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T;
 
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    registry?: Registry;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context?: ClassDecoratorContext) => T;
+declare function Injectable(options: {
+    scope: InjectableScope;
+}): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T;
 
 declare function Injectable<Type, Schema>(options: {
     scope?: InjectableScope;
-    type?: InjectableType.Class;
     token: InjectionToken<Type, Schema>;
     registry?: Registry;
 }): Schema extends BaseInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithArgument<z.output<Schema>>>(// #3.1.1 Typeless token
@@ -216,22 +368,12 @@ target: T, context?: ClassDecoratorContext) => T : <T extends ClassTypeWithInsta
 target: T, context?: ClassDecoratorContext) => T : Schema extends OptionalInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>(// #3.2.1 Typeless token
 target: T, context?: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndOptionalArgument<Type, z.output<Schema>>>(target: T, context?: ClassDecoratorContext) => T : Schema extends undefined ? <R extends ClassTypeWithInstance<Type>>(// #3.3.1 Token must have a type
 target: R, context?: ClassDecoratorContext) => R : never;
-
-declare function Injectable<R, S>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, S>;
-    registry?: Registry;
-}): R extends undefined ? never : S extends InjectionTokenSchemaType ? <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(// #4.2.1 Token have a schema
-target: T, context?: ClassDecoratorContext) => T : S extends undefined ? <T extends ClassTypeWithInstance<Factory<R>>>(// #4.3.1 Token without a schema
-target: T, context?: ClassDecoratorContext) => T : never;
 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;
 }
@@ -247,7 +389,11 @@ declare enum InjectableScope {
     /**
      * Instance scope: A new instance is created for each injection.
      */
-    Instance = "Instance"
+    Transient = "Transient",
+    /**
+     * Request scope: The instance is created once per request and shared within that request context.
+     */
+    Request = "Request"
 }
 export { InjectableScope }
 export { InjectableScope as InjectableScope_alias_1 }
@@ -266,22 +412,18 @@ 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, Required extends boolean = S extends ZodOptional<ZodObject<any>> ? false : S extends ZodOptional<ZodRecord> ? false : S extends ZodObject<any> ? true : S extends ZodRecord ? true : false> {
+declare class InjectionToken<T, S extends InjectionTokenSchemaType | unknown = unknown, Required extends boolean = S extends ZodOptional<ZodObject> ? false : S extends ZodOptional<ZodRecord> ? false : S extends ZodObject ? true : S extends ZodRecord ? true : false> {
     readonly name: string | symbol | ClassType;
-    readonly schema: ZodObject<any> | undefined;
+    readonly schema: ZodObject | undefined;
     id: `${string}-${string}-${string}-${string}-${string}`;
     private formattedName;
-    constructor(name: string | symbol | ClassType, schema: ZodObject<any> | undefined);
+    constructor(name: string | symbol | ClassType, schema: ZodObject | undefined);
     static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
     static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(name: T, schema: Schema): Schema['_def']['type'] extends 'ZodOptional' ? InjectionToken<InstanceType<T>, Schema, false> : InjectionToken<InstanceType<T>, Schema, true>;
     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 factory<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
     static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
     toString(): string;
 }
@@ -292,30 +434,41 @@ declare type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalI
 export { InjectionTokenSchemaType }
 export { InjectionTokenSchemaType as InjectionTokenSchemaType_alias_1 }
 
+declare type InjectionTokenType = InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
+export { InjectionTokenType }
+export { InjectionTokenType as InjectionTokenType_alias_1 }
+
 declare interface Injectors {
-    inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
-    inject<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-    inject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-    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 InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T;
-    syncInject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? T : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-    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;
+    asyncInject<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
+    asyncInject<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+    asyncInject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+    asyncInject<T>(token: InjectionToken<T, undefined>): Promise<T>;
+    asyncInject<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+    asyncInject<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+    inject<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? R : InstanceType<T>;
+    inject<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T;
+    inject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? T : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+    inject<T>(token: InjectionToken<T, undefined>): T;
+    inject<T>(token: BoundInjectionToken<T, any>): T;
+    inject<T>(token: FactoryInjectionToken<T, any>): T;
+    wrapSyncInit(cb: () => any): (injectState?: InjectState) => [any, Promise<any>[], InjectState];
+    provideFactoryContext(context: FactoryContext | null): FactoryContext | null;
 }
 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 interface InjectState {
+    currentIndex: number;
+    isFrozen: boolean;
+    requests: {
+        token: InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any> | ClassType;
+        promise: Promise<any>;
+    }[];
+}
+export { InjectState }
+export { InjectState as InjectState_alias_1 }
+export { InjectState as InjectState_alias_2 }
 
 declare class InstanceDestroying extends Error {
     name: string;
@@ -345,37 +498,41 @@ export { InstanceNotFound as InstanceNotFound_alias_1 }
 export { InstanceNotFound as InstanceNotFound_alias_2 }
 
 declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+export { IsUnion }
+export { IsUnion as IsUnion_alias_1 }
+export { IsUnion as IsUnion_alias_2 }
 
 declare type Join<TElements, TSeparator extends string> = TElements extends Readonly<[infer First, ...infer Rest]> ? Rest extends ReadonlyArray<string> ? First extends string ? `${First}${Rest extends [] ? '' : TSeparator}${Join<Rest, TSeparator>}` : never : never : '';
+export { Join }
+export { Join as Join_alias_1 }
+export { Join as Join_alias_2 }
 
-declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: FactoryContext): ServiceLocator;
-export { makeProxyServiceLocator }
-export { makeProxyServiceLocator as makeProxyServiceLocator_alias_1 }
+declare interface OnServiceDestroy {
+    onServiceDestroy(): Promise<void> | void;
+}
+export { OnServiceDestroy }
+export { OnServiceDestroy as OnServiceDestroy_alias_1 }
+export { OnServiceDestroy as OnServiceDestroy_alias_2 }
+
+declare interface OnServiceInit {
+    onServiceInit(): Promise<void> | void;
+}
+export { OnServiceInit }
+export { OnServiceInit as OnServiceInit_alias_1 }
+export { OnServiceInit as OnServiceInit_alias_2 }
 
-declare type OptionalInjectionTokenSchemaType = ZodOptional<ZodObject<any>> | ZodOptional<ZodRecord>;
+declare type OptionalInjectionTokenSchemaType = ZodOptional<ZodObject> | ZodOptional<ZodRecord>;
 export { OptionalInjectionTokenSchemaType }
 export { OptionalInjectionTokenSchemaType as OptionalInjectionTokenSchemaType_alias_1 }
 
 declare type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never;
+export { PopUnion }
+export { PopUnion as PopUnion_alias_1 }
+export { PopUnion as PopUnion_alias_2 }
 
-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 ZodObject<any> | ZodOptional<ZodObject<any>> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends ZodObject<any> ? z.input<Schema> : Schema extends ZodOptional<ZodObject<any>> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
-    getSyncInstance<Instance, Schema extends ZodObject<any> | ZodOptional<ZodObject<any>> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends ZodObject<any> ? z.input<Schema> : Schema extends ZodOptional<ZodObject<any>> ? 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 const provideFactoryContext: Injectors['provideFactoryContext'];
+export { provideFactoryContext }
+export { provideFactoryContext as provideFactoryContext_alias_1 }
 
 declare class Registry {
     private readonly parent?;
@@ -383,52 +540,188 @@ declare class Registry {
     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;
+    set<Instance, Schema>(token: InjectionToken<Instance, Schema>, scope: InjectableScope, target: ClassType, type: InjectableType): 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 }
+/**
+ * Request context holder that manages pre-prepared instances for a specific request.
+ * This allows for efficient instantiation of request-scoped services.
+ */
+declare interface RequestContextHolder {
+    /**
+     * Unique identifier for this request context.
+     */
+    readonly requestId: string;
+    /**
+     * Pre-prepared instances for this request, keyed by instance name.
+     */
+    readonly instances: Map<string, any>;
+    /**
+     * Instance holders for request-scoped services.
+     */
+    readonly holders: Map<string, ServiceLocatorInstanceHolder>;
+    /**
+     * Priority for resolution in FactoryContext.inject method.
+     * Higher values take precedence.
+     */
+    readonly priority: number;
+    /**
+     * Request-specific metadata that can be used during instantiation.
+     */
+    readonly metadata: Map<string, any>;
+    /**
+     * Timestamp when this context was created.
+     */
+    readonly createdAt: number;
+    /**
+     * Adds a pre-prepared instance to this context.
+     */
+    addInstance(instanceName: string, instance: any, holder: ServiceLocatorInstanceHolder): void;
+    /**
+     * Gets a pre-prepared instance from this context.
+     */
+    getInstance(instanceName: string): any | undefined;
+    /**
+     * Gets an instance holder from this context.
+     */
+    getHolder(instanceName: string): ServiceLocatorInstanceHolder | undefined;
+    /**
+     * Checks if this context has a pre-prepared instance.
+     */
+    hasInstance(instanceName: string): boolean;
+    /**
+     * Clears all instances and holders from this context.
+     */
+    clear(): void;
+    /**
+     * Gets metadata value by key.
+     */
+    getMetadata(key: string): any | undefined;
+    /**
+     * Sets metadata value by key.
+     */
+    setMetadata(key: string, value: any): void;
+}
+export { RequestContextHolder }
+export { RequestContextHolder as RequestContextHolder_alias_1 }
+
+/**
+ * ServiceInstantiator handles the instantiation of services based on registry records.
+ * It replaces the hard-coded logic in Injectable and Factory decorators.
+ */
+declare class ServiceInstantiator {
+    private readonly injectors;
+    constructor(injectors: Injectors);
+    /**
+     * Instantiates a service based on its registry record.
+     * @param ctx The factory context for dependency injection
+     * @param record The factory record from the registry
+     * @param args Optional arguments for the service
+     * @returns Promise resolving to [undefined, instance] or [error]
+     */
+    instantiateService<T>(ctx: FactoryContext, record: FactoryRecord<T, any>, args?: any): Promise<[undefined, T] | [Error]>;
+    /**
+     * Instantiates a class-based service (Injectable decorator).
+     * @param ctx The factory context for dependency injection
+     * @param record The factory record from the registry
+     * @param args Optional arguments for the service constructor
+     * @returns Promise resolving to [undefined, instance] or [error]
+     */
+    private instantiateClass;
+    /**
+     * Instantiates a factory-based service (Factory decorator).
+     * @param ctx The factory context for dependency injection
+     * @param record The factory record from the registry
+     * @param args Optional arguments for the factory
+     * @returns Promise resolving to [undefined, instance] or [error]
+     */
+    private instantiateFactory;
+}
+export { ServiceInstantiator }
+export { ServiceInstantiator as ServiceInstantiator_alias_1 }
 
 declare class ServiceLocator {
     private readonly registry;
     private readonly logger;
+    private readonly injectors;
     private readonly eventBus;
     private readonly manager;
-    constructor(registry?: Registry, logger?: Console | null);
+    private readonly serviceInstantiator;
+    private readonly requestContexts;
+    private currentRequestContext;
+    constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
     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 ZodObject<any> | ZodOptional<ZodObject<any>>>(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 ZodObject<any> ? z.input<Schema> : Schema extends ZodOptional<ZodObject<any>> ? 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 ZodObject<any> ? z.input<Schema> : Schema extends ZodOptional<ZodObject<any>> ? z.input<Schema> | undefined : undefined): Instance | null;
+    getManager(): ServiceLocatorManager;
+    getInstanceIdentifier(token: AnyInjectableType, args?: any): string;
+    getInstance(token: AnyInjectableType, args?: any, onPrepare?: (data: {
+        instanceName: string;
+        actualToken: InjectionTokenType;
+        validatedArgs?: any;
+    }) => void): Promise<any[]>;
+    getOrThrowInstance<Instance>(token: AnyInjectableType, args: any): Promise<Instance>;
+    getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: AnyInjectableType, args: Schema extends ZodObject ? z.input<Schema> : Schema extends ZodOptional<ZodObject> ? 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;
+    /**
+     * Begins a new request context with the given parameters.
+     * @param requestId Unique identifier for this request
+     * @param metadata Optional metadata for the request
+     * @param priority Priority for resolution (higher = more priority)
+     * @returns The created request context holder
+     */
+    beginRequest(requestId: string, metadata?: Record<string, any>, priority?: number): RequestContextHolder;
+    /**
+     * Ends a request context and cleans up all associated instances.
+     * @param requestId The request ID to end
+     */
+    endRequest(requestId: string): Promise<void>;
+    /**
+     * Gets the current request context.
+     * @returns The current request context holder or null
+     */
+    getCurrentRequestContext(): RequestContextHolder | null;
+    /**
+     * Sets the current request context.
+     * @param requestId The request ID to set as current
+     */
+    setCurrentRequestContext(requestId: string): void;
+    /**
+     * Validates and resolves token arguments, handling factory token resolution and validation.
+     */
+    private validateAndResolveTokenArgs;
+    /**
+     * Internal method to resolve token args and create instance name.
+     * Handles factory token resolution and validation.
+     */
+    private resolveTokenAndPrepareInstanceName;
+    /**
+     * Gets an instance by its instance name, handling all the logic after instance name creation.
+     */
+    private retrieveOrCreateInstanceByInstanceName;
+    /**
+     * Emits events to listeners for instance lifecycle events.
+     */
+    private emitInstanceEvent;
+    /**
+     * Creates a new instance for the given token and arguments.
+     */
+    private createNewInstance;
+    /**
+     * Instantiates a service from the registry using the service instantiator.
+     */
+    private instantiateServiceFromRegistry;
+    /**
+     * Creates a factory context for dependency injection during service instantiation.
+     * @param contextHolder Optional request context holder for priority-based resolution
+     */
+    private createFactoryContext;
+    /**
+     * Generates a unique instance name based on token and arguments.
+     */
+    private generateInstanceName;
 }
 export { ServiceLocator }
 export { ServiceLocator as ServiceLocator_alias_1 }
@@ -451,7 +744,7 @@ declare type ServiceLocatorInstanceEffect = () => void;
 export { ServiceLocatorInstanceEffect }
 export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_1 }
 
-declare type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance>;
+declare type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance> | ServiceLocatorInstanceHolderError;
 export { ServiceLocatorInstanceHolder }
 export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_1 }
 
@@ -461,9 +754,9 @@ declare interface ServiceLocatorInstanceHolderCreated<Instance> {
     instance: Instance;
     creationPromise: null;
     destroyPromise: null;
-    kind: ServiceLocatorInstanceHolderKind;
-    effects: ServiceLocatorInstanceEffect[];
-    deps: string[];
+    type: InjectableType;
+    scope: InjectableScope;
+    deps: Set<string>;
     destroyListeners: ServiceLocatorInstanceDestroyListener[];
     createdAt: number;
     ttl: number;
@@ -477,9 +770,9 @@ declare interface ServiceLocatorInstanceHolderCreating<Instance> {
     instance: null;
     creationPromise: Promise<[undefined, Instance]> | null;
     destroyPromise: null;
-    kind: ServiceLocatorInstanceHolderKind;
-    effects: ServiceLocatorInstanceEffect[];
-    deps: string[];
+    type: InjectableType;
+    scope: InjectableScope;
+    deps: Set<string>;
     destroyListeners: ServiceLocatorInstanceDestroyListener[];
     createdAt: number;
     ttl: number;
@@ -493,9 +786,9 @@ declare interface ServiceLocatorInstanceHolderDestroying<Instance> {
     instance: Instance | null;
     creationPromise: null;
     destroyPromise: Promise<void>;
-    kind: ServiceLocatorInstanceHolderKind;
-    effects: ServiceLocatorInstanceEffect[];
-    deps: string[];
+    type: InjectableType;
+    scope: InjectableScope;
+    deps: Set<string>;
     destroyListeners: ServiceLocatorInstanceDestroyListener[];
     createdAt: number;
     ttl: number;
@@ -503,18 +796,27 @@ declare interface ServiceLocatorInstanceHolderDestroying<Instance> {
 export { ServiceLocatorInstanceHolderDestroying }
 export { ServiceLocatorInstanceHolderDestroying as ServiceLocatorInstanceHolderDestroying_alias_1 }
 
-declare enum ServiceLocatorInstanceHolderKind {
-    Instance = "instance",
-    Factory = "factory",
-    AbstractFactory = "abstractFactory"
+declare interface ServiceLocatorInstanceHolderError {
+    status: ServiceLocatorInstanceHolderStatus.Error;
+    name: string;
+    instance: Error;
+    creationPromise: null;
+    destroyPromise: null;
+    type: InjectableType;
+    scope: InjectableScope;
+    deps: Set<string>;
+    destroyListeners: ServiceLocatorInstanceDestroyListener[];
+    createdAt: number;
+    ttl: number;
 }
-export { ServiceLocatorInstanceHolderKind }
-export { ServiceLocatorInstanceHolderKind as ServiceLocatorInstanceHolderKind_alias_1 }
+export { ServiceLocatorInstanceHolderError }
+export { ServiceLocatorInstanceHolderError as ServiceLocatorInstanceHolderError_alias_1 }
 
 declare enum ServiceLocatorInstanceHolderStatus {
     Created = "created",
     Creating = "creating",
-    Destroying = "destroying"
+    Destroying = "destroying",
+    Error = "error"
 }
 export { ServiceLocatorInstanceHolderStatus }
 export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_1 }
@@ -528,19 +830,62 @@ declare class ServiceLocatorManager {
     has(name: string): [InstanceExpired | InstanceDestroying] | [undefined, boolean];
     delete(name: string): boolean;
     filter(predicate: (value: ServiceLocatorInstanceHolder<any>, key: string) => boolean): Map<string, ServiceLocatorInstanceHolder>;
+    /**
+     * Creates a new holder with Creating status and a deferred creation promise.
+     * This is useful for creating placeholder holders that can be fulfilled later.
+     * @param name The name of the instance
+     * @param type The injectable type
+     * @param scope The injectable scope
+     * @param deps Optional set of dependencies
+     * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
+     * @returns A tuple containing the deferred promise and the holder
+     */
+    createCreatingHolder<Instance>(name: string, type: InjectableType, scope: InjectableScope, deps?: Set<string>, ttl?: number): [
+    ReturnType<typeof createDeferred<[undefined, Instance]>>,
+    ServiceLocatorInstanceHolder<Instance>
+    ];
+    /**
+     * Creates a new holder with Created status and an actual instance.
+     * This is useful for creating holders that already have their instance ready.
+     * @param name The name of the instance
+     * @param instance The actual instance to store
+     * @param type The injectable type
+     * @param scope The injectable scope
+     * @param deps Optional set of dependencies
+     * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
+     * @returns The created holder
+     */
+    storeCreatedHolder<Instance>(name: string, instance: Instance, type: InjectableType, scope: InjectableScope, deps?: Set<string>, ttl?: number): ServiceLocatorInstanceHolder<Instance>;
 }
 export { ServiceLocatorManager }
 export { ServiceLocatorManager as ServiceLocatorManager_alias_1 }
 
-declare const syncInject: Injectors['syncInject'];
-export { syncInject }
-export { syncInject as syncInject_alias_1 }
+export declare const test1: string;
+
+export declare const test2: number;
+
+export declare const test3: boolean;
+
+export declare const test4: {
+    name: string;
+};
+
+export declare const test5: object;
 
 declare type UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
+export { UnionToArray }
+export { UnionToArray as UnionToArray_alias_1 }
+export { UnionToArray as UnionToArray_alias_2 }
 
 declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export { UnionToIntersection }
+export { UnionToIntersection as UnionToIntersection_alias_1 }
+export { UnionToIntersection as UnionToIntersection_alias_2 }
 
 declare type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+export { UnionToOvlds }
+export { UnionToOvlds as UnionToOvlds_alias_1 }
+export { UnionToOvlds as UnionToOvlds_alias_2 }
 
 declare class UnknownError extends Error {
     code: ErrorsEnum;