import { BoundInjectionToken, ClassType, ClassTypeWithArgument, FactoryInjectionToken, InjectionToken, InjectionTokenSchemaType } from "../token/injection-token.mjs";
import { Join, UnionToArray } from "../utils/types.mjs";
import { Factorable } from "./factory.interface.mjs";
import { ZodType, z } from "zod/v4";

//#region src/interfaces/container.interface.d.mts

/**
 * Interface for dependency injection containers.
 * Both Container and ScopedContainer implement this interface,
 * allowing them to be used interchangeably in factory contexts.
 */
interface IContainer {
  /**
   * Gets an instance from the container.
   */
  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: 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>;
  /**
   * Invalidates a service and its dependencies.
   */
  invalidate(service: unknown): Promise<void>;
  /**
   * Checks if a service is registered in the container.
   */
  isRegistered(token: any): boolean;
  /**
   * Adds an instance to the container.
   * Accepts class types, InjectionTokens, and BoundInjectionTokens.
   * Rejects InjectionTokens with required schemas (use BoundInjectionToken instead).
   *
   * @param token The class type, InjectionToken, or BoundInjectionToken to register the instance for
   * @param instance The instance to store
   */
  addInstance<T>(token: ClassType | InjectionToken<T, any> | BoundInjectionToken<T, any>, instance: T): void;
  /**
   * Disposes the container and cleans up all resources.
   */
  dispose(): Promise<void>;
  /**
   * Waits for all pending operations to complete.
   */
  ready(): Promise<void>;
  /**
   * @internal
   * Attempts to get an instance synchronously if it already exists.
   * Returns null if the instance doesn't exist or is not ready.
   * Used internally by the inject system for synchronous property initialization.
   */
  tryGetSync<T>(token: any, args?: any): T | null;
}
//#endregion
export { IContainer };
//# sourceMappingURL=container.interface.d.mts.map