import { BoundInjectionToken, ClassType, ClassTypeWithArgument, FactoryInjectionToken, InjectionToken, InjectionTokenSchemaType } from "../token/injection-token.mjs";
import { Join, UnionToArray } from "../utils/types.mjs";
import { InjectableScope } from "../enums/injectable-scope.enum.mjs";
import { Factorable } from "../interfaces/factory.interface.mjs";
import { Registry } from "../token/registry.mjs";
import { NameResolver } from "../internal/core/name-resolver.mjs";
import { ServiceInvalidator } from "../internal/core/service-invalidator.mjs";
import { TokenResolver } from "../internal/core/token-resolver.mjs";
import { UnifiedStorage } from "../internal/holder/unified-storage.mjs";
import { AbstractContainer } from "./abstract-container.mjs";
import { Container } from "./container.mjs";
import { ZodType, z } from "zod/v4";

//#region src/container/scoped-container.d.mts

/**
 * Request-scoped dependency injection container.
 *
 * Wraps a parent Container and provides isolated request-scoped instances
 * while delegating singleton and transient resolution to the parent.
 * This design eliminates race conditions that can occur with async operations
 * when multiple requests are processed concurrently.
 */
declare class ScopedContainer extends AbstractContainer {
  private readonly parent;
  private readonly registry;
  readonly requestId: string;
  protected readonly defaultScope = InjectableScope.Request;
  private readonly storage;
  private disposed;
  private readonly metadata;
  constructor(parent: Container, registry: Registry, requestId: string, metadata?: Record<string, any>);
  getStorage(): UnifiedStorage;
  protected getRegistry(): Registry;
  protected getTokenResolver(): TokenResolver;
  protected getNameResolver(): NameResolver;
  protected getServiceInvalidator(): ServiceInvalidator;
  /**
   * Gets the request ID for this scoped container.
   */
  getRequestId(): string;
  /**
   * Gets the parent container.
   */
  getParent(): Container;
  /**
   * Gets metadata from the request context.
   */
  getMetadata(key: string): any | undefined;
  /**
   * Sets metadata on the request context.
   */
  setMetadata(key: string, value: any): void;
  /**
   * Gets an instance from the container.
   * Request-scoped services are resolved from this container's storage.
   * All other services are delegated to the parent 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>;
  /**
   * Disposes the container and cleans up all resources.
   * Alias for endRequest().
   */
  dispose(): Promise<void>;
  /**
   * @internal
   * Attempts to get an instance synchronously if it already exists.
   * Checks request storage first, then delegates to parent.
   */
  tryGetSync<T>(token: any, args?: any): T | null;
  /**
   * Adds an instance to the container.
   * Overrides base class to check disposed state.
   */
  addInstance<T>(token: ClassType | InjectionToken<T, any> | BoundInjectionToken<T, any>, instance: T): void;
  /**
   * Ends the request and cleans up all request-scoped services.
   */
  endRequest(): Promise<void>;
}
//#endregion
export { ScopedContainer };
//# sourceMappingURL=scoped-container.d.mts.map