/// <reference types="node" />
import { Container } from './containers';
import { LifeTime } from './annotations';
import http = require('http');
import { IRequestContext } from '../pipeline/common';
export declare enum BusUsage {
    all = 0,
    commandOnly = 1,
    eventOnly = 2,
}
/**
 * Register direct route
 * @param verb Http verb in uppercase
 * @param path Path to compare
 * @param handler Request
 */
export declare class NativeEndpoint {
    kind: "SSE" | "HTTP";
    verb: string;
    path: string;
    handler: Function;
}
export interface IContainer {
    registerHTTPEndpoint(verb: string, path: string, handler: (req: http.IncomingMessage, res: http.ServerResponse) => void): any;
    registerSSEEndpoint(path: string, handler: (ctx: IRequestContext) => void, verb?: string): any;
    getCustomEndpoints(): Array<NativeEndpoint>;
    injectInstance(fn: any, name: string): IContainer;
    injectSingleton(fn: any, ...args: any[]): IContainer;
    injectSingleton(fn: any, name?: string, ...args: any[]): IContainer;
    injectSingleton(fn: any, nameOrArray: string | Array<any>, ...args: any[]): IContainer;
    injectTransient(fn: any, ...args: any[]): IContainer;
    injectTransient(fn: any, name?: string, ...args: any[]): IContainer;
    injectTransient(fn: any, nameOrArray: string | Array<any>, ...args: any[]): IContainer;
    injectScoped(fn: any, ...args: any[]): IContainer;
    injectScoped(fn: any, name?: string, ...args: any[]): IContainer;
    injectScoped(fn: any, nameOrArray: string | Array<any>, ...args: any[]): IContainer;
    /**
     * Inject all components founded recursively in a folder.
     *
     * @param {string} path Root folder relative to current folder
     * @returns {IContainer}
     */
    injectFrom(path: string): IContainer;
    /**
     * Get a component by name
     *
     * @template T
     * @param {string} name Component name
     * @param {boolean} [optional] if true doesn't throw an exception if the component doesn't exist
     * @param {LifeTime} [assertLifeTime] If provided check if the component has been injected with the same lifetime value
     * @returns {T} A component
     */
    get<T>(name: string, optional?: boolean, assertLifeTime?: LifeTime): T;
    getList<T>(name: string): T[];
    /**
     * Create a new component resolving all its dependencies
     *
     * @param {any} fn A component class
     * @param {any} args Custom arguments
     */
    resolve(fn: any, ...args: any[]): any;
    dispose(): any;
    useRabbitBusAdapter(address?: string, usage?: BusUsage): any;
    useMongoProvider(uri?: string, mongoOptions?: any): any;
    useMemoryProvider(folder?: string): any;
    inject(name: string, fn: any, lifeTime: LifeTime): any;
}
export interface IInjectionNotification {
    onInjectionCompleted(): any;
}
export interface IResolver {
    lifeTime: LifeTime;
    resolve(container: Container, name?: string, parentContainer?: Container): any;
}
export declare class InstanceResolver implements IResolver {
    private instance;
    lifeTime: LifeTime;
    constructor(instance: any);
    resolve(container: Container, name?: string): any;
}
export declare class Resolver implements IResolver {
    private fn;
    lifeTime: LifeTime;
    private args;
    static nb: number;
    constructor(fn: any, lifeTime: LifeTime, args?: Array<any>);
    resolve(container: Container, name?: string): any;
    private injectProperties(container, name, component);
    private injectArguments(container, name, params);
}
export declare class SingletonResolver extends Resolver {
    constructor(fn: any, args?: Array<any>);
    resolve(container: Container, name?: string, parentContainer?: Container): any;
}
export declare class ScopedResolver extends Resolver {
    constructor(fn: any, args?: Array<any>);
    resolve(container: Container, name?: string): any;
}