import { BoundInjectionToken, ClassType, ClassTypeWithArgument, ClassTypeWithoutArguments, FactoryInjectionToken, InjectionToken, InjectionTokenSchemaType } from "../token/injection-token.mjs";
import { InjectState, Join, UnionToArray } from "./types.mjs";
import { ServiceInitializationContext } from "../internal/context/service-initialization-context.mjs";
import { Factorable, FactorableWithArgs } from "../interfaces/factory.interface.mjs";
import { ZodType, z } from "zod/v4";

//#region src/utils/get-injectors.d.mts
interface Injectors {
  asyncInject<T extends ClassTypeWithoutArguments>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
  asyncInject<Args, T extends ClassTypeWithArgument<Args>>(token: T, args: Args): Promise<InstanceType<T>>;
  asyncInject<Schema extends InjectionTokenSchemaType, R, T extends FactorableWithArgs<R, Schema>>(token: T, args: z.input<Schema>): Promise<R>;
  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 ClassTypeWithoutArguments>(token: T): InstanceType<T> extends Factorable<infer R> ? R : InstanceType<T>;
  inject<Args, T extends ClassTypeWithArgument<Args>>(token: T, args: Args): InstanceType<T>;
  inject<Schema extends InjectionTokenSchemaType, R, T extends FactorableWithArgs<R, Schema>>(token: T, args: z.input<Schema>): R;
  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;
  /**
   * Optional injection that returns null if the service fails to initialize
   * or is not available. This is useful when you want to inject a service
   * that may not be configured or may fail gracefully.
   *
   * @example
   * ```ts
   * class MyService {
   *   constructor() {
   *     const optionalService = optional(OptionalServiceToken)
   *     // optionalService will be null if initialization fails
   *     if (optionalService) {
   *       optionalService.doSomething()
   *     }
   *   }
   * }
   * ```
   */
  optional<T extends ClassType>(token: T): (InstanceType<T> extends Factorable<infer R> ? R : InstanceType<T>) | null;
  optional<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T | null;
  optional<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? T | null : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
  optional<T>(token: InjectionToken<T, undefined>): T | null;
  optional<T>(token: BoundInjectionToken<T, any>): T | null;
  optional<T>(token: FactoryInjectionToken<T, any>): T | null;
  wrapSyncInit(cb: () => any): (injectState?: InjectState) => [any, Promise<any>[], InjectState];
  provideFactoryContext(context: ServiceInitializationContext | null): ServiceInitializationContext | null;
}
declare function getInjectors(): Injectors;
//#endregion
export { Injectors, getInjectors };
//# sourceMappingURL=get-injectors.d.mts.map