import { ICtor } from '../ctor';
import { Token } from '../token';
declare type ProviderToken = Token | ICtor<any>;
export interface IPluginProvider<T> {
    /** Key to use as provider if different than the decorated class itself */
    token?: ProviderToken;
    /** use a factory to provide the plugin instantiation */
    factory?: (...deps: any[]) => T;
    /** source dependencies to resolve for the factory or the constructor itself */
    deps?: any[];
}
/**
 * Plugin record once decorator factory is provided
 * @internal
 */
export interface IPluginRecord<T> extends IPluginProvider<T> {
    ctor: ICtor<T>;
}
/**
 * Map of registered plugin objects
 * @internal
 */
export declare const PluginRegistry: Map<ProviderToken, IPluginRecord<any>>;
/**
 * @Provide decorator factory
 * @param config plugin provider configuration
 */
export declare function Provide<T = any>(config?: IPluginProvider<T>): any;
/**
 * Signature when prototype property decorator is used:
 * ```ts
 * class Foo {
 *   @Bar()
 *   public bar: any;
 * }
 * ```
 */
export declare type PropertyDecorator<T = any> = (target: T, propertyKey: string, descriptor: undefined) => void;
/**
 * Signature when a ctor argument is decorated
 * class Foo {
 *   constructor(@Bar() public bar: any)
 * }
 */
export declare type CtorArgDecorator<T = any> = (target: ICtor<T>, propertyKey: undefined, index: number) => void;
/**
 * Injects a plugin into a class member or constructor argument
 * @param token a registered plugin token for injection
 * @param args any extra args to provide to the plugin factory
 */
export declare function Plugin(token: ProviderToken, ...args: any[]): any;
export {};