import { PublicOnlyIfObject } from '../shared/types.js';
import { Constructable, InjectionToken, Scope } from './inject.js';
export interface FactoryRegistration<T = unknown, Deps extends readonly unknown[] = []> {
    token: InjectionToken<T>;
    useFactory: (...deps: Deps) => PublicOnlyIfObject<T>;
    inject?: InjectionToken[];
    scope?: Scope;
}
export type ModuleRegistryEntry<T = unknown, D extends readonly unknown[] = any[]> = Constructable<T> | FactoryRegistration<T, D>;
export interface ModuleOptions {
    imports?: ModuleMetadata[];
    register?: ModuleRegistryEntry[];
}
export interface ProviderDefinition<T = unknown> {
    token: InjectionToken<T>;
    scope: Scope;
    inject: InjectionToken[];
    create: (...deps: unknown[]) => T;
}
export interface ModuleMetadata {
    providers: Map<InjectionToken<unknown>, ProviderDefinition>;
}
/**
 * Describes an injection token for error messages.
 */
export declare function describeToken(token: InjectionToken<unknown>): string;
/**
 * Creates metadata for a dependency injection module.
 *
 * @example
 * ```ts
 * const myModule = module({
 *   register: [
 *     MyClass,
 *     { token: myToken, useFactory: () => new Dependency() },
 *     {
 *       token: otherToken,
 *       useFactory: (MyClass) => ...,
 *       inject: [MyClass],
 *     },
 *   ],
 * });
 * ```
 * @param options Module options.
 */
export declare function module(options?: ModuleOptions): ModuleMetadata;
/**
 * Shorthand to create a factory registration that does not require dependencies.
 */
export declare function provideValue<T>(token: InjectionToken<T>, factory: () => PublicOnlyIfObject<T>, scope?: Scope): FactoryRegistration<T>;
/**
 * Shorthand to create a factory registration that does not require dependencies.
 * Allows providing a partial implementation of an object type.
 */
export declare function provideTestValue<T>(token: InjectionToken<T>, factory: () => Partial<PublicOnlyIfObject<T>>, scope?: Scope): FactoryRegistration<T>;