@navios/di 0.1.5 → 0.1.7

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

@@ -1,13 +1,18 @@
 import type { AnyZodObject } from 'zod';
 import { z } from 'zod';
 import { ZodOptional } from 'zod';
+import { ZodRecord } from 'zod';
 
-declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+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: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, value: z.input<S>);
     toString(): string;
 }
@@ -109,14 +114,14 @@ declare interface FactoryContext {
 export { FactoryContext }
 export { FactoryContext as FactoryContext_alias_1 }
 
-declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+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: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
     resolve(): Promise<z.input<S>>;
     toString(): string;
@@ -149,7 +154,7 @@ export { FactoryTokenNotResolved }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
 
-declare interface FactoryWithArgs<T, A extends AnyZodObject> {
+declare interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
     create(ctx: any, args: z.output<A>): Promise<T> | T;
 }
 export { FactoryWithArgs }
@@ -180,55 +185,41 @@ 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>(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 & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
+}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<S extends AnyZodObject>(options: {
+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 & {
-    [InjectableTokenMeta]: InjectionToken<T, S>;
-};
+}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<R, S extends AnyZodObject>(options: {
+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 & {
-    [InjectableTokenMeta]: 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 & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
+}): (target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<R, S extends AnyZodObject>(options: {
+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 & {
-    [InjectableTokenMeta]: 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 & {
-    [InjectableTokenMeta]: 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 }
@@ -274,34 +265,38 @@ declare type InjectionFactory<T = unknown, Args = unknown> = (ctx: FactoryContex
 export { InjectionFactory }
 export { InjectionFactory as InjectionFactory_alias_1 }
 
-declare class InjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown> {
+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 AnyZodObject | ZodOptional<AnyZodObject>>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
+    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 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 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 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, 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 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, 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;
@@ -348,6 +343,10 @@ declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: Fa
 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 }
@@ -397,24 +396,25 @@ declare class ServiceLocator {
     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;
+    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 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, 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 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, 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 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>;
+    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 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;
+    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;

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

@@ -1,13 +1,18 @@
 import type { AnyZodObject } from 'zod';
 import { z } from 'zod';
 import { ZodOptional } from 'zod';
+import { ZodRecord } from 'zod';
 
-declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+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: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, value: z.input<S>);
     toString(): string;
 }
@@ -109,14 +114,14 @@ declare interface FactoryContext {
 export { FactoryContext }
 export { FactoryContext as FactoryContext_alias_1 }
 
-declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+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: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
     resolve(): Promise<z.input<S>>;
     toString(): string;
@@ -149,7 +154,7 @@ export { FactoryTokenNotResolved }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
 
-declare interface FactoryWithArgs<T, A extends AnyZodObject> {
+declare interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
     create(ctx: any, args: z.output<A>): Promise<T> | T;
 }
 export { FactoryWithArgs }
@@ -180,55 +185,41 @@ 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>(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 & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
+}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<S extends AnyZodObject>(options: {
+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 & {
-    [InjectableTokenMeta]: InjectionToken<T, S>;
-};
+}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<R, S extends AnyZodObject>(options: {
+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 & {
-    [InjectableTokenMeta]: 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 & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
+}): (target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<R, S extends AnyZodObject>(options: {
+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 & {
-    [InjectableTokenMeta]: 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 & {
-    [InjectableTokenMeta]: 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 }
@@ -274,34 +265,38 @@ declare type InjectionFactory<T = unknown, Args = unknown> = (ctx: FactoryContex
 export { InjectionFactory }
 export { InjectionFactory as InjectionFactory_alias_1 }
 
-declare class InjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown> {
+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 AnyZodObject | ZodOptional<AnyZodObject>>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
+    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 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 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 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, 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 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, 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;
@@ -348,6 +343,10 @@ declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: Fa
 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 }
@@ -397,24 +396,25 @@ declare class ServiceLocator {
     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;
+    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 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, 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 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, 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 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>;
+    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 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;
+    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;

package/dist/index.d.mts

@@ -27,6 +27,9 @@ 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';

package/dist/index.d.ts

@@ -27,6 +27,9 @@ 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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/di",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"

package/src/decorators/injectable.decorator.mts

@@ -1,5 +1,3 @@
-import type { AnyZodObject } from 'zod'
-
 import { NaviosException } from '@navios/common'
 
 import { z } from 'zod'
@@ -9,6 +7,7 @@ import type {
   ClassTypeWithArgument,
   ClassTypeWithInstance,
   ClassTypeWithInstanceAndArgument,
+  InjectionTokenSchemaType,
 } from '../injection-token.mjs'
 import type { Factory, FactoryWithArgs } from '../interfaces/index.mjs'
 import type { Registry } from '../registry.mjs'
@@ -29,48 +28,42 @@ export interface InjectableOptions {
 export function Injectable(): <T extends ClassType>(
   target: T,
   context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined> }
+) => T
 export function Injectable<R>(options: {
   scope?: InjectableScope
   type: InjectableType.Factory
 }): <T extends ClassTypeWithInstance<Factory<R>>>(
   target: T,
   context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
-export function Injectable<S extends AnyZodObject>(options: {
+) => T
+export 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 & { [InjectableTokenMeta]: InjectionToken<T, S> }
-export function Injectable<R, S extends AnyZodObject>(options: {
+) => T
+export 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 & { [InjectableTokenMeta]: InjectionToken<R, S> }
+) => T
 export function Injectable<T extends ClassType>(options: {
   scope?: InjectableScope
   token: InjectionToken<T, undefined>
-}): (
-  target: T,
-  context: ClassDecoratorContext,
-) => T & {
-  [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>
-}
-
-export function Injectable<R, S extends AnyZodObject>(options: {
+}): (target: T, context: ClassDecoratorContext) => T
+export 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 & { [InjectableTokenMeta]: InjectionToken<R, S> }
+) => T
 export function Injectable<R>(options: {
   scope?: InjectableScope
   type: InjectableType.Factory
@@ -78,7 +71,7 @@ export function Injectable<R>(options: {
 }): <T extends ClassTypeWithInstance<Factory<R>>>(
   target: T,
   context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
+) => T
 export function Injectable({
   scope = InjectableScope.Singleton,
   type = InjectableType.Class,
@@ -88,9 +81,7 @@ export function Injectable({
   return <T extends ClassType>(
     target: T,
     context: ClassDecoratorContext,
-  ): T & {
-    [InjectableTokenMeta]: InjectionToken<any, any>
-  } => {
+  ): T => {
     if (context.kind !== 'class') {
       throw new Error(
         '[ServiceLocator] @Injectable decorator can only be used on classes.',
@@ -123,8 +114,6 @@ export function Injectable({
     // @ts-expect-error
     target[InjectableTokenMeta] = injectableToken
 
-    return target as T & {
-      [InjectableTokenMeta]: InjectionToken<any, any>
-    }
+    return target
   }
 }

package/src/injection-token.mts

@@ -2,7 +2,7 @@ import type { AnyZodObject } from 'zod'
 
 import { randomUUID } from 'crypto'
 
-import { z, ZodOptional } from 'zod'
+import { z, ZodOptional, ZodRecord } from 'zod'
 
 export type ClassType = new (...args: any[]) => any
 export type ClassTypeWithArgument<Arg> = new (arg: Arg) => any
@@ -10,9 +10,19 @@ export type ClassTypeWithArgument<Arg> = new (arg: Arg) => any
 export type ClassTypeWithInstance<T> = new (...args: any[]) => T
 export type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T
 
+export type BaseInjectionTokenSchemaType = AnyZodObject | ZodRecord
+
+export type OptionalInjectionTokenSchemaType =
+  | ZodOptional<AnyZodObject>
+  | ZodOptional<ZodRecord>
+
+export type InjectionTokenSchemaType =
+  | BaseInjectionTokenSchemaType
+  | OptionalInjectionTokenSchemaType
+
 export class InjectionToken<
   T,
-  S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown,
+  S extends InjectionTokenSchemaType | unknown = unknown,
 > {
   public id = randomUUID()
   private formattedName: string | null = null
@@ -25,12 +35,12 @@ export class InjectionToken<
   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 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 AnyZodObject | ZodOptional<AnyZodObject>>(
+  static create<T, Schema extends InjectionTokenSchemaType>(
     name: string | any,
     schema: Schema,
   ): InjectionToken<T, Schema>
@@ -39,14 +49,14 @@ export class InjectionToken<
     return new InjectionToken(name, schema)
   }
 
-  static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+  static bound<T, S extends InjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     value: z.input<S>,
   ): BoundInjectionToken<T, S> {
     return new BoundInjectionToken(token, value)
   }
 
-  static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+  static factory<T, S extends InjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     factory: () => Promise<z.input<S>>,
   ): FactoryInjectionToken<T, S> {
@@ -77,13 +87,10 @@ export class InjectionToken<
   }
 }
 
-export class BoundInjectionToken<
-  T,
-  S extends AnyZodObject | ZodOptional<AnyZodObject>,
-> {
+export class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
   public id: string
   public name: string | symbol | ClassType
-  public schema: AnyZodObject | ZodOptional<AnyZodObject>
+  public schema: InjectionTokenSchemaType
 
   constructor(
     public readonly token: InjectionToken<T, S>,
@@ -91,7 +98,7 @@ export class BoundInjectionToken<
   ) {
     this.name = token.name
     this.id = token.id
-    this.schema = token.schema as AnyZodObject | ZodOptional<AnyZodObject>
+    this.schema = token.schema as InjectionTokenSchemaType
   }
 
   toString() {
@@ -99,15 +106,12 @@ export class BoundInjectionToken<
   }
 }
 
-export class FactoryInjectionToken<
-  T,
-  S extends AnyZodObject | ZodOptional<AnyZodObject>,
-> {
+export class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
   public value?: z.input<S>
   public resolved = false
   public id: string
   public name: string | symbol | ClassType
-  public schema: AnyZodObject | ZodOptional<AnyZodObject>
+  public schema: InjectionTokenSchemaType
 
   constructor(
     public readonly token: InjectionToken<T, S>,
@@ -115,7 +119,7 @@ export class FactoryInjectionToken<
   ) {
     this.name = token.name
     this.id = token.id
-    this.schema = token.schema as AnyZodObject | ZodOptional<AnyZodObject>
+    this.schema = token.schema as InjectionTokenSchemaType
   }
 
   async resolve(): Promise<z.input<S>> {

package/src/interfaces/factory.interface.mts

@@ -1,11 +1,11 @@
-import type { AnyZodObject } from 'zod'
-
 import { z } from 'zod'
 
+import type { InjectionTokenSchemaType } from '../injection-token.mjs'
+
 export interface Factory<T> {
   create(ctx?: any): Promise<T> | T
 }
 
-export interface FactoryWithArgs<T, A extends AnyZodObject> {
+export interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
   create(ctx: any, args: z.output<A>): Promise<T> | T
 }

package/src/service-locator.mts

@@ -3,6 +3,11 @@
 import type { AnyZodObject, z, ZodOptional } from 'zod'
 
 import type { FactoryContext } from './factory-context.mjs'
+import type {
+  BaseInjectionTokenSchemaType,
+  InjectionTokenSchemaType,
+  OptionalInjectionTokenSchemaType,
+} from './injection-token.mjs'
 import type { Registry } from './registry.mjs'
 import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
 
@@ -98,13 +103,15 @@ export class ServiceLocator {
   public removeInstance<Instance>(
     token: InjectionToken<Instance, undefined>,
   ): void
-  public removeInstance<
-    Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject>,
-  >(
+  public removeInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<Instance, Schema>,
     args: z.input<Schema>,
   ): void
+  public removeInstance<
+    Instance,
+    Schema extends OptionalInjectionTokenSchemaType,
+  >(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): void
+
   public removeInstance(
     token:
       | InjectionToken<any, any>
@@ -116,18 +123,25 @@ export class ServiceLocator {
     const instanceName = this.getInstanceIdentifier(token, args)
     return this.invalidate(instanceName)
   }
-  private resolveTokenArgs<Instance, Schema extends AnyZodObject>(
+
+  private resolveTokenArgs<
+    Instance,
+    Schema extends BaseInjectionTokenSchemaType,
+  >(
     token: InjectionToken<Instance, Schema>,
     args: z.input<Schema>,
   ): [undefined, z.output<Schema>] | [UnknownError]
-  private resolveTokenArgs<Instance, Schema extends ZodOptional<AnyZodObject>>(
+  private resolveTokenArgs<
+    Instance,
+    Schema extends OptionalInjectionTokenSchemaType,
+  >(
     token: InjectionToken<Instance, Schema>,
     args?: z.input<Schema>,
   ): [undefined, z.output<Schema>] | [UnknownError]
-  private resolveTokenArgs<Instance, Schema extends AnyZodObject>(
+  private resolveTokenArgs<Instance, Schema extends InjectionTokenSchemaType>(
     token: BoundInjectionToken<Instance, Schema>,
   ): [undefined, z.output<Schema>] | [UnknownError]
-  private resolveTokenArgs<Instance, Schema extends AnyZodObject>(
+  private resolveTokenArgs<Instance, Schema extends InjectionTokenSchemaType>(
     token: FactoryInjectionToken<Instance, Schema>,
   ): [undefined, z.output<Schema>] | [FactoryTokenNotResolved | UnknownError]
   private resolveTokenArgs(
@@ -161,13 +175,13 @@ export class ServiceLocator {
     return [undefined, validatedArgs?.data]
   }
 
-  public getInstanceIdentifier<Instance, Schema extends AnyZodObject>(
-    token: InjectionToken<Instance, Schema>,
-    args: z.input<Schema>,
-  ): string
   public getInstanceIdentifier<
     Instance,
-    Schema extends ZodOptional<AnyZodObject>,
+    Schema extends BaseInjectionTokenSchemaType,
+  >(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string
+  public getInstanceIdentifier<
+    Instance,
+    Schema extends OptionalInjectionTokenSchemaType,
   >(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string
   public getInstanceIdentifier<Instance>(
     token: InjectionToken<Instance, undefined>,
@@ -195,11 +209,11 @@ export class ServiceLocator {
     return this.makeInstanceName(token as InjectionToken<any>, realArgs)
   }
 
-  public getInstance<Instance, Schema extends AnyZodObject>(
+  public getInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<Instance, Schema>,
     args: z.input<Schema>,
   ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>
-  public getInstance<Instance, Schema extends ZodOptional<AnyZodObject>>(
+  public getInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(
     token: InjectionToken<Instance, Schema>,
     args?: z.input<Schema>,
   ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>
@@ -273,7 +287,7 @@ export class ServiceLocator {
 
   public async getOrThrowInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends InjectionTokenSchemaType | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
     args: Schema extends AnyZodObject
@@ -301,7 +315,7 @@ export class ServiceLocator {
 
   private async createInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends InjectionTokenSchemaType | undefined,
   >(
     instanceName: string,
     token: InjectionToken<Instance, Schema>,
@@ -328,10 +342,10 @@ export class ServiceLocator {
 
   private async resolveInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
-    Args extends Schema extends AnyZodObject
+    Schema extends InjectionTokenSchemaType | undefined,
+    Args extends Schema extends BaseInjectionTokenSchemaType
       ? z.input<Schema>
-      : Schema extends ZodOptional<AnyZodObject>
+      : Schema extends OptionalInjectionTokenSchemaType
         ? z.input<Schema> | undefined
         : undefined,
   >(
@@ -455,7 +469,7 @@ export class ServiceLocator {
 
   public getSyncInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends InjectionTokenSchemaType | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
     args: Schema extends AnyZodObject

package/src/utils/get-injectors.mts

@@ -1,10 +1,12 @@
-import type { AnyZodObject, z, ZodOptional } from 'zod'
+import type { AnyZodObject, z } from 'zod'
 
 import type {
+  BaseInjectionTokenSchemaType,
   BoundInjectionToken,
   ClassType,
   FactoryInjectionToken,
   InjectionToken,
+  OptionalInjectionTokenSchemaType,
 } from '../injection-token.mjs'
 import type { ServiceLocator } from '../service-locator.mjs'
 
@@ -16,11 +18,11 @@ export interface CreateInjectorsOptions {
 
 export interface Injectors {
   inject<T extends ClassType>(token: T): Promise<InstanceType<T>>
-  inject<T, S extends AnyZodObject>(
+  inject<T, S extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args: z.input<S>,
   ): Promise<T>
-  inject<T, S extends ZodOptional<AnyZodObject>>(
+  inject<T, S extends OptionalInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args?: z.input<S>,
   ): Promise<T>
@@ -29,11 +31,11 @@ export interface Injectors {
   inject<T>(token: FactoryInjectionToken<T, any>): Promise<T>
 
   syncInject<T extends ClassType>(token: T): InstanceType<T>
-  syncInject<T, S extends AnyZodObject>(
+  syncInject<T, S extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args: z.input<S>,
   ): T
-  syncInject<T, S extends ZodOptional<AnyZodObject>>(
+  syncInject<T, S extends OptionalInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args?: z.input<S>,
   ): T