import { IBind, IContainer, ResolvableObject } from './interfaces.js';
import { Class, InferClass, InferTypedArray, ResolveResult, ResolveArrayResult, Factory } from './types.js';
import { TypedArray } from './array.js';
/**
 * App main DI container
 */
export declare const RootContainer: IContainer;
/***
 * EVENT LISTENER STUFF
 *
 * Allows to use event listener stuff on root container
 */
export declare function setESMModuleSupport(): void;
export declare function on(event: string, listener: (...args: unknown[]) => void): IContainer;
export declare function addListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
export declare function once(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
export declare function removeListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
export declare function off(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
export declare function removeAllListeners(event?: string | symbol): IContainer;
export declare function setMaxListeners(n: number): IContainer;
export declare function getMaxListeners(): number;
export declare function listeners(event: string | symbol): ((...args: any[]) => void)[];
export declare function rawListeners(event: string | symbol): ((...args: any[]) => void)[];
export declare function emit(event: string | symbol, ...args: unknown[]): boolean;
export declare function listenerCount(type: string | symbol): number;
export declare function prependListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
export declare function prependOnceListener(event: string | symbol, listener: (...args: unknown[]) => void): IContainer;
export declare function eventNames(): (string | symbol)[];
/**
 * ===========================================================================
 */
/**
 * Clears root container registry and cache.
 */
export declare function clear(): void;
/**
 * Clears out root registry ( registered types in root container )
 */
export declare function clearRegistry(): void;
/**
 * Cleart ous root cache ( all resolved types )
 */
export declare function clearCache(): void;
export declare function dispose(): Promise<void>;
/**
 * Register class/interface to DI root container. If
 * @param type - interface object to register
 * @throws {@link InvalidArgument} if type is null or undefined
 */
export declare function register<T>(type: Class<T> | Factory<T> | ResolvableObject): IBind;
export declare function unregister<T>(type: string | Class<T> | Factory<T> | ResolvableObject): void;
export declare function uncache<T>(type: string | Class<T> | TypedArray<T>, parent?: boolean): void;
/**
 * Resolves specified type from root container.
 *
 * @param type - class to resolve
 * @param options - optional parameters passed to class constructor
 * @param check - use parent container to check when resolving
 * @throws {@link InvalidArgument} if type is null or undefined
 */
export declare function resolve<T>(type: string, options?: unknown[], check?: boolean): T;
export declare function resolve<T>(type: string, check?: boolean): T;
export declare function resolve<T>(type: Class<T>, check?: boolean): ResolveResult<T>;
export declare function resolve<T>(type: Class<T>, options?: unknown[] | boolean, check?: boolean): ResolveResult<T>;
export declare function resolve<T>(type: TypedArray<T>, check?: boolean): ResolveArrayResult<T>;
export declare function resolve<T>(type: TypedArray<T>, options?: unknown[] | boolean, check?: boolean): ResolveArrayResult<T>;
export declare function resolve<T extends Class<any>>(type: T, check?: boolean): ResolveResult<InferClass<T>>;
export declare function resolve<T extends TypedArray<any>>(type: T, check?: boolean): ResolveArrayResult<InferTypedArray<T>>;
export declare function resolve<T extends Class<any>>(type: T, options?: unknown[] | boolean, check?: boolean): ResolveResult<InferClass<T>>;
export declare function resolve<T extends TypedArray<any>>(type: T, options?: unknown[] | boolean, check?: boolean): ResolveArrayResult<InferTypedArray<T>>;
/**
 * Gets already resolved service from root container.
 *
 * @param serviceName - name of service to get
 */
export declare function get<T>(serviceName: TypedArray<T>): T[] | null;
export declare function get<T>(serviceName: string | Class<T>): T | null;
/**
 *
 * Returns list of types registered at given type, eg. all types/services registered under BaseService
 *
 * @param type - base type to check
 */
export declare function getRegisteredTypes<T>(type: string | Class<T>): Class<T>[];
/**
 * Checks if service is already resolved and exists in container cache.
 * NOTE: check is only valid for classes that are singletons.
 *
 * @param service - service name or class to check
 */
export declare function has<T>(service: string | Class<T>): boolean;
/**
 * Checks if service is registered in container.
 *
 * @param service - service class object to check
 */
export declare function check<T>(service: Class<T> | string): boolean;
/**
 * Checks if specific service is registered in container.
 * Eg. we can have multiple drivers registered for queue connections with different protocol implementations
 * and we want to check if specific driver is registered
 *
 * @param source - source class to check ( eg. base class )
 * @param type - specific type to check eg. base class implementation
 */
export declare function checkType<T>(source: Class<any> | string | TypedArray<any>, type: Class<T> | string | TypedArray<T> | object): boolean;
/**
 * Creates child DI container.
 *
 */
export declare function child(): IContainer;
/**
 * Injectable module loader seam. When a service is registered under
 * `__module_loader__` it takes over dynamic module loading entirely. This is
 * the browser / bundler escape hatch: no `require`, no bare dynamic import of a
 * file path — a DI-provided loader decides how ( and whether ) to load a module.
 */
export interface IModuleLoader {
    load(module: string): Promise<unknown>;
}
export declare function __spinajs_require__(module: string): Promise<unknown>;
//# sourceMappingURL=root.d.ts.map