//#region src/provider/provider.d.ts
/**
 * The symbol used to identify providable classes.
 *
 * @category Provider
 */
declare const provide: unique symbol;
/**
 * An object which contains provider information.
 *
 * @param TValue The value type provided by the Providable.
 * @category Provider
 */
type Providable<TValue = unknown> = {
  readonly [provide]: ProviderInfo<TValue>;
};
/**
 * The provider information used to resolve a value.
 *
 * @param TValue The value type provided by the provider.
 * @category Provider
 */
type ProviderInfo<TValue = unknown> = {
  readonly async?: undefined | false;
  getValue: (ctx: Context) => TValue;
} | {
  readonly async: true;
  getValue: (ctx: Context) => Promise<TValue> | TValue;
};
/**
 * Infer the value type provided by a {@link ProvidableClass}.
 *
 * @param T The class to infer the value type from.
 * @category Provider
 */
type ProvidedValue<T extends Class> = T extends ProvidableClass<infer TValue> ? TValue : never;
/**
 * A class which provides a value and conforms to {@link Providable}.
 *
 * @param TValue The value type provided by the class.
 * @param TArgs The arguments of the class.
 * @category Provider
 */
type ProvidableClass<TValue, TArgs extends readonly any[] = any[]> = Class<TArgs, Providable<TValue>>;
//#endregion
//#region src/types.d.ts
/**
 * A representation of a class type.
 *
 * @param TArgs The arguments of the class.
 * @param TInstance The instance type of the class.
 * @category Utility Type
 */
type Class<TArgs extends readonly any[] = readonly any[], TInstance = any> = abstract new (...args: TArgs) => TInstance;
/**
 * Extracts properties from a type `T` whose types match `V` exactly.
 *
 * @param T The source type.
 * @param V The value type to extract.
 * @category Utility Type
 */
type ExtractProperties<T, V> = { [K in keyof T as T[K] extends V ? (V extends T[K] ? K : never) : never]: T[K] };
/**
 * A type representing a postconstruct function for a class.
 *
 * This can be:
 * - A function that returns a void promise and is bound to the instance.
 * - A function that returns another function which is bound to the instance and returns a void promise.
 * - A key of a method on the instance that returns a void promise.
 */
type Postcontructable<T extends Class> = ((this: InstanceType<T>) => void | Promise<void>) | (() => (this: InstanceType<T>) => void | Promise<void>) | keyof ExtractProperties<InstanceType<T>, (() => Promise<void>) | (() => void)>;
/**
 * The resolved instance of a class when {@link tap} or {@link tapAsync} is called.
 *
 * It is similar to the {@link InstanceType} utility type, but resolves {@link Providable} classes.
 *
 * @param TClass The class to resolve.
 * @category Utility Type
 */
type ResolvedInstance<TClass extends Class> = ProvidedValue<TClass> extends never ? InstanceType<TClass> : ProvidedValue<TClass>;
/**
 * The resolved instances of multiple classes in an array.
 *
 * It is similar to the {@link ResolvedInstance} type, but for multiple classes.
 *
 * @category Utility Type
 */
type ResolvedInstances<TClasses extends readonly Class[]> = TClasses extends never[] ? readonly [] : { readonly [TKey in keyof TClasses]: ResolvedInstance<TClasses[TKey]> };
/**
 * The context which is provided inside preconstructors and providers.
 *
 * @param TOrigin The origin class of the context.
 * @category Utility Type
 */
type Context<TOrigin extends Class = Class> = {
  /**
   * The circuit which is currently resolving the target.
   */
  circuit: Circuit;
  /**
   * The target class which is currently being resolved.
   */
  target: TOrigin;
  /**
   * The class which depends on the target and the reason why it is being resolved.
   *
   * This can be `undefined` if the target is being resolved directly using {@link tap} or {@link tapAsync}.
   */
  dependent?: Class;
};
//#endregion
//#region src/circuit.d.ts
/**
 * A circuit is a container which is responsible for managing the instances by holding and initializing them.
 *
 * Only one instance of a class can exist in a circuit.
 *
 * @category Core
 */
declare class Circuit {
  #private;
  constructor();
  tap<TTarget extends Class>(target: TTarget): ResolvedInstance<TTarget>;
  tapAsync<TTarget extends Class>(target: TTarget): Promise<ResolvedInstance<TTarget>>;
  /**
   * Installing means to manually add an instance to the circuit.
   * The installed instance class also doesn't need to be wired
   * because you are responsible for initializing it.
   *
   * For example, when a circuit is created, it installs itself as an instance.
   * With this, it is possible to use the circuit class as an input.
   *
   * You can use this to manually add instances you already have initialized.
   *
   * @param target The class of the instance to install.
   * @param instance The instance to install.
   * @returns The instance that was installed.
   */
  install<TTarget extends Class>(target: TTarget, instance: InstanceType<TTarget>): InstanceType<TTarget>;
  /**
   * Uninstalling means to manually remove an instance from the circuit.
   *
   * This method should be used with caution!
   *
   * @param target The class of the instance to uninstall.
   * @returns The instance that was uninstalled, or undefined if not found.
   */
  uninstall<TTarget extends Class>(target: TTarget): InstanceType<TTarget> | undefined;
  /**
   * Check if the given class is installed (initialized) in this circuit.
   *
   * @param target The class to check.
   * @returns True if the class is installed (initialized), false otherwise.
   */
  isInstalled(target: Class): boolean;
  /**
   * Get the instance of the given class.
   *
   * NOTICE: This method is a low-level operation as it does not instantiate classes or resolve providable classes. Use it with caution.
   *
   * @param target The class to get the instance for.
   * @returns The instance of the class, or undefined if not found.
   */
  get<TTarget extends Class>(target: TTarget): ResolvedInstance<TTarget> | undefined;
  /**
   * Check if the given class has async initializer
   * or provides an async value.
   *
   * Classes without an async initializer will be instantiated
   * if not yet initialized in the circuit. This is necessary to
   * receive possible provider info.
   *
   * @param target The class to check.
   * @returns True if the class has async initializer or provides an async value, false otherwise.
   */
  isAsync(target: Class): boolean;
  static getDefault(): Circuit;
}
/**
 * @category Core
 */
declare const tap: <TTarget extends Class>(target: TTarget, circuit?: Circuit) => ResolvedInstance<TTarget>;
/**
 * @category Core
 */
declare const tapAsync: <TTarget extends Class>(target: TTarget, circuit?: Circuit) => Promise<ResolvedInstance<TTarget>>;
/**
 * @category Core
 */
declare const getContext: () => Context;
/**
 * @category Core
 */
declare const getCircuit: () => Circuit;
/**
 * @category Core
 */
declare const link: <T extends Class>(target: T) => ResolvedInstance<T>;
//#endregion
//#region src/definition/decorators.d.ts
/**
 * @category Definition
 */
declare const unwire: (target: Class) => boolean;
/**
 * @category Definition
 */
declare const isWired: (target: Class) => boolean;
/**
 * @category Definition Decorator
 */
declare const singleton: (circuit?: Circuit) => <T extends Class>(target: T) => void;
/**
 * @category Definition Function
 */
declare const defineSingleton: <T extends Class>(target: T, circuit?: Circuit) => void;
/**
 * @category Definition Decorator
 */
declare const requires: <TTarget extends Class<ResolvedInstances<TDeps>>, const TDeps extends readonly Class[]>(dependencies: () => TDeps) => (target: TTarget) => void;
/**
 * @category Definition Function
 */
declare const defineRequires: <TTarget extends Class<ResolvedInstances<TDeps>>, const TDeps extends readonly Class[]>(target: TTarget, dependencies: () => TDeps) => void;
/**
 * @category Definition Decorator
 */
declare const standalone: <T extends Class<readonly []>>() => (target: T) => void;
/**
 * @category Definition Function
 */
declare const defineStandalone: <T extends Class<readonly []>>(target: T) => void;
/**
 * @category Definition Decorator
 */
declare const preconstruct: <T extends Class, const TDeps extends readonly Class[] = readonly []>(preconstruct: (dependencies: ResolvedInstances<TDeps>, context: Context) => InstanceType<T>, dependencies?: () => TDeps) => (target: T) => void;
/**
 * @category Definition Function
 */
declare const definePreconstruct: <T extends Class, const TDeps extends readonly Class[] = readonly []>(target: T, preconstruct: (dependencies: ResolvedInstances<TDeps>, context: Context) => InstanceType<T>, dependencies?: () => TDeps) => void;
/**
 * @category Definition Decorator
 */
declare const preconstructAsync: <T extends Class, const TDeps extends readonly Class[] = readonly []>(preconstructAsync: (dependencies: ResolvedInstances<TDeps>, context: Context) => Promise<() => InstanceType<T>>, dependencies?: () => TDeps) => (target: T) => void;
/**
 * @category Definition Function
 */
declare const definePreconstructAsync: <T extends Class<TDeps>, const TDeps extends readonly Class[] = readonly []>(target: T, preconstructAsync: (dependencies: ResolvedInstances<TDeps>, context: Context) => Promise<() => InstanceType<T>>, dependencies?: () => TDeps) => void;
/**
 * @category Definition Decorator
 */
declare const postconstructAsync: <T extends Class, TSetup extends Postcontructable<T>>(setup: TSetup) => (target: T) => void;
/**
 * @category Definition Function
 */
declare const definePostconstructAsync: <T extends Class, TSetup extends Postcontructable<T>>(target: T, setup: TSetup) => void;
/**
 * @category Definition Decorator
 */
declare const preloads: <T extends Class>(preloads: () => readonly Class[]) => (target: T) => void;
/**
 * @category Definition Function
 */
declare const definePreloads: <T extends Class>(target: T, preloads: () => readonly Class[]) => void;
//#endregion
//#region src/definition/definition.d.ts
/**
 * @category Definition
 */
declare class WireDefinition {
  readonly target: Class;
  private constructor();
  singleton?: Circuit;
  dependencies?: () => readonly Class[];
  preloads?: () => readonly Class[];
  preconstructAsync?: (dependencies: readonly unknown[], context: Context) => Promise<() => unknown>;
  preconstruct?: (dependencies: readonly unknown[], context: Context) => unknown;
  postconstructAsync?: (() => void | Promise<void>) | (() => () => void | Promise<void>);
  isValid(): boolean;
  remove(): boolean;
  static from(target: Class, createIfNotExists?: false): WireDefinition | undefined;
  static from(target: Class, createIfNotExists: true): WireDefinition;
  static define(target: Class, options?: Partial<WireDefinition>): WireDefinition;
}
//#endregion
//#region src/errors.d.ts
/**
 * The base class for all Wirebox errors.
 *
 * @category Error
 */
declare class WireboxError extends Error {}
/**
 * Thrown when a class is not set up for wiring.
 *
 * @category Error
 */
declare class UnwiredError extends WireboxError {
  readonly target: Class;
  /**
   * @param target The target class.
   */
  constructor(target: Class);
}
/**
 * Thrown when a class is already initialized.
 *
 * @category Error
 */
declare class AlreadyInitializedError extends WireboxError {
  readonly target: Class;
  /**
   * @param target The target class.
   */
  constructor(target: Class);
}
/**
 * Thrown when an async dependency is used in a sync context.
 *
 * @category Error
 */
declare class AsyncDependencyError extends WireboxError {
  readonly target: Class;
  /**
   * @param target The target class.
   * @param initializing Whether the class is currently initializing.
   */
  constructor(target: Class, initializing: boolean);
}
/**
 * Thrown when the circuit context is not available.
 *
 * @category Error
 */
declare class NoCircuitContextError extends WireboxError {
  constructor();
}
/**
 * Thrown when a class with an {@link provide} implementation is not a valid {@link Providable}.
 *
 * @category Error
 */
declare class InvalidProvidableError extends WireboxError {
  readonly target: Class;
  /**
   * @param target The target class.
   */
  constructor(target: Class);
}
//#endregion
//#region src/provider/common.d.ts
/**
 * @category Common Provider
 */
declare class BasicValueProvider<T> implements Providable<T> {
  readonly value: T;
  constructor(value: T);
  [provide]: {
    getValue: () => T;
  };
}
/**
 * @category Common Provider
 */
declare const createProvider: <const T>(getValue: (ctx: Context) => T) => ProvidableClass<T, [ctx: Context]>;
/**
 * @category Common Provider
 */
declare const createAsyncProvider: <const T>(getValue: (ctx: Context) => Promise<T>) => ProvidableClass<T, [ctx: Context]>;
/**
 * @category Common Provider
 */
declare const createStaticProvider: <const T>(value: T) => ProvidableClass<T, []>;
/**
 * @category Common Provider
 */
declare const createAsyncStaticProvider: <const T>(value: Promise<T>) => ProvidableClass<T, []>;
/**
 * @category Common Provider
 */
declare const createDynamicProvider: <const T>(getValue: (ctx: Context) => T) => ProvidableClass<T>;
/**
 * @category Common Provider
 */
declare const createAsyncDynamicProvider: <const T>(getValue: (ctx: Context) => Promise<T>) => ProvidableClass<T>;
//#endregion
//#region src/utilities/combine.d.ts
/**
 * Converts a record of classes to a record of resolved instances.
 *
 * @category Utility: Combine
 */
type ResolvedCombine<TTargets extends Record<string, Class>> = { [Key in keyof TTargets]: ResolvedInstance<TTargets[Key]> };
/**
 * Combines multiple classes into a single value by resolving a record
 * of classes to a record of resolved instances.
 *
 * @param getTargets A function which returns the record of classes to resolve.
 * @returns A value provider which returns with a record of resolved instances.
 * @category Utility: Combine
 */
declare const combine: <const TTargets extends Record<string, Class>>(getTargets: () => TTargets) => ProvidableClass<ResolvedCombine<TTargets>, [circuit: Circuit]>;
//#endregion
//#region src/utilities/conditional.d.ts
/**
 * A target that a conditional decorator can resolve to, either a class
 * extending `T` or a providable class providing an instance of `T`.
 */
type ConditionalTarget<T extends Class> = Class<any[], InstanceType<T>> | ProvidableClass<InstanceType<T>>;
/**
 * @category Utility: Conditional
 */
declare const conditional: <T extends Class, const TDeps extends readonly Class[] = readonly []>(resolve: (dependencies: ResolvedInstances<TDeps>, context: Context) => ConditionalTarget<NoInfer<T>>, dependencies?: () => TDeps) => (target: T) => void;
/**
 * @category Utility: Conditional
 */
declare const defineConditional: <T extends Class, const TDeps extends readonly Class[] = readonly []>(target: T, resolve: (dependencies: ResolvedInstances<TDeps>, context: Context) => ConditionalTarget<NoInfer<T>>, dependencies?: () => TDeps) => void;
/**
 * @category Utility: Conditional
 */
declare const conditionalAsync: <T extends Class, const TDeps extends readonly Class[] = readonly []>(resolveAsync: (dependencies: ResolvedInstances<TDeps>, context: Context) => Promise<ConditionalTarget<NoInfer<T>>> | ConditionalTarget<NoInfer<T>>, dependencies?: () => TDeps) => (target: T) => void;
/**
 * @category Utility: Conditional
 */
declare const defineConditionalAsync: <T extends Class, const TDeps extends readonly Class[] = readonly []>(target: T, resolveAsync: (dependencies: ResolvedInstances<TDeps>, context: Context) => Promise<ConditionalTarget<NoInfer<T>>> | ConditionalTarget<NoInfer<T>>, dependencies?: () => TDeps) => void;
//#endregion
//#region src/utilities/lazy.d.ts
/**
 * Creates a lazy loaded class provider for a named export.
 *
 * @param loadModule The function which loads the module (most likely via dynamic import)
 * @param exportName The optional name of the export to load (defaults to default export ["default"])
 * @category Utility: Lazy
 */
declare const lazy: <TMod extends Record<TExport, Class>, TExport extends string = "default">(loadModule: () => Promise<TMod>, exportName?: TExport) => ProvidableClass<ResolvedInstance<TMod[TExport]>>;
//#endregion
//#region src/utilities/with-circuit.d.ts
/**
 * Bind a {@link Circuit} to a given class.
 *
 * This is useful when forced to use a specific circuit but can't or don't want to use singletons.
 *
 * Internally, this creates a custom provider which uses the given circuit to resolve the class.
 *
 * @param circuit The circuit to instantiate the class from.
 * @param getTarget The class getter of the target class which should be accessed from the circuit.
 * @returns An (async) value provider which provides the class instance from the given circuit.
 * @category Utility: With Circuit
 */
declare const withCircuit: <const TTarget extends Class>(circuit: Circuit, getTarget: () => TTarget) => ProvidableClass<ResolvedInstance<TTarget>>;
//#endregion
export { AlreadyInitializedError, AsyncDependencyError, BasicValueProvider, Circuit, type Class, type Context, InvalidProvidableError, NoCircuitContextError, type Providable, type ProvidableClass, type ProvidedValue, type ProviderInfo, type ResolvedCombine, type ResolvedInstance, type ResolvedInstances, UnwiredError, WireDefinition, WireboxError, combine, conditional, conditionalAsync, createAsyncDynamicProvider, createAsyncProvider, createAsyncStaticProvider, createDynamicProvider, createProvider, createStaticProvider, defineConditional, defineConditionalAsync, definePostconstructAsync, definePreconstruct, definePreconstructAsync, definePreloads, defineRequires, defineSingleton, defineStandalone, getCircuit, getContext, isWired, lazy, link, postconstructAsync, preconstruct, preconstructAsync, preloads, provide, requires, singleton, standalone, tap, tapAsync, unwire, withCircuit };