/// <reference types="node" />
import { EventEmitter } from 'events';
import { IModule, IModuleFactory } from 'sdg-admin';
import Base from './base';
import * as Constants from './util/constants';
import { IComponent } from './interfaces/IComponent';
import { IComponents, ISettings, IServer, IServerMap, TServerType, IServerInfo, IServerId } from './interfaces/IApplication';
import { IApplicationOpts } from './interfaces/opts';
import { ObjectType } from './interfaces/define';
import SessionService from './common/service/sessionService';
import BackendSessionService from './common/service/backendSessionService';
import { IAfterHandlerFilter, IBeforeHandlerFilter, IHandlerFilter } from './interfaces/IHandlerFilter';
import { IChannelServiceOptions } from './interfaces/IChannelService';
import BackendSessionComponent from './components/backendSession';
import { IRemoteComponentOptions } from './interfaces/IRemote';
import { IConnectorComponentOptions } from './interfaces/IConnector';
import { IFrontendOrBackendSession, ISession, ISessionServiceOptions } from './interfaces/ISession';
import { IProxyComponentOptions, IRouteFunction } from './interfaces/IProxy';
import { IResponseErrorHandler, IServerOptions } from './interfaces/IServer';
import { IDictionaryComponentOptions } from './interfaces/IDictionary';
import { IProtobufComponentOptions } from './interfaces/IProtobuf';
import { IPlugin } from './interfaces/IPlugin';
import ChannelService from './common/service/channelService';
import { IMasterServerOpts } from './interfaces/IAdmin';
export declare type IConfigureFunc = () => Promise<void>;
declare global {
    interface UserRpc {
        test(): void;
    }
    interface SysRpc {
        [serverType: string]: {
            msgRemote: {
                forwardMessage: (routeParam: IFrontendOrBackendSession, msg: any, session: ISession) => Promise<void>;
            };
        };
    }
}
export default class Application extends Base {
    opts: IApplicationOpts;
    servers: IServer;
    serverTypeMaps: IServerMap;
    rpc: UserRpc;
    sysRpc: SysRpc;
    rpcInvoke: Function;
    sessionService: SessionService;
    channelService: ChannelService;
    backendSessionService: BackendSessionService;
    serverInfo: IServerInfo;
    serverId: IServerId;
    serverType: string;
    startTime: number;
    usedPlugins: IPlugin[];
    private readonly loaded;
    components: IComponents;
    settings: ISettings;
    event: EventEmitter;
    constructor(opts: IApplicationOpts);
    private initCurServerInfo;
    getCurServer(): IServerInfo;
    private initEvent;
    restore(): void;
    start(): Promise<void>;
    afterStart(): Promise<void>;
    /**
     * server管理器，这里只管理serverInfo，具体逻辑交给proxy
     * @param servers
     */
    addServers(servers: IServerInfo[]): void;
    removeServers(ids: IServerId[]): void;
    replaceServers(servers: IServer): void;
    /**
     * 更新serverInfo的配置信息
     * @param serverInfo
     */
    updateServerInfo(serverInfo: IServerInfo): void;
    /**
     * 基础设置
     * @param setting
     * @param val
     * @param attach 是否将配置写到实例上
     */
    set(setting: 'sessionService', val: SessionService, attach?: boolean): Application;
    set(setting: 'backendSessionService', val: BackendSessionComponent, attach?: boolean): Application;
    set(setting: 'channelService', val: ChannelService, attach?: boolean): Application;
    set(setting: 'channelConfig', val: IChannelServiceOptions, attach?: boolean): Application;
    set(setting: 'remoteConfig', val: IRemoteComponentOptions, attach?: boolean): Application;
    set(setting: 'sessionConfig', val: ISessionServiceOptions, attach?: boolean): Application;
    set(setting: 'proxyConfig', val: IProxyComponentOptions, attach?: boolean): Application;
    set(setting: 'serverConfig', val: IServerOptions, attach?: boolean): Application;
    set(setting: 'connectorConfig', val: IConnectorComponentOptions, attach?: boolean): Application;
    set(setting: 'dictionaryConfig', val: IDictionaryComponentOptions, attach?: boolean): Application;
    set(setting: 'protobufConfig', val: IProtobufComponentOptions, attach?: boolean): Application;
    set(setting: Constants.KEYWORDS.BEFORE_FILTER, val: IBeforeHandlerFilter[], attach?: boolean): Application;
    set(setting: Constants.KEYWORDS.AFTER_FILTER, val: IAfterHandlerFilter[], attach?: boolean): Application;
    set(setting: Constants.KEYWORDS.GLOBAL_BEFORE_FILTER, val: IBeforeHandlerFilter[], attach?: boolean): Application;
    set(setting: Constants.KEYWORDS.GLOBAL_AFTER_FILTER, val: IAfterHandlerFilter[], attach?: boolean): Application;
    set(setting: Constants.RESERVED.BASE, val: string, attach?: boolean): Application;
    set(setting: Constants.RESERVED.ENV, val: string, attach?: boolean): Application;
    set(setting: Constants.RESERVED.GLOBAL_ERROR_HANDLER, val: IResponseErrorHandler, attach?: boolean): Application;
    set(setting: Constants.RESERVED.ERROR_HANDLER, val: IResponseErrorHandler, attach?: boolean): Application;
    set(setting: Constants.RESERVED.MASTER, val: IMasterServerOpts): Application;
    set(setting: string, val: string | any, attach?: boolean): Application;
    get(setting: 'channelService'): ChannelService;
    get(setting: 'sessionService'): SessionService;
    get(setting: 'backendSessionService'): BackendSessionComponent;
    get(setting: 'channelConfig'): IChannelServiceOptions;
    get(setting: 'remoteConfig'): IRemoteComponentOptions;
    get(setting: 'connectorConfig'): IConnectorComponentOptions;
    get(setting: 'sessionConfig'): ISessionServiceOptions;
    get(setting: 'proxyConfig'): IProxyComponentOptions;
    get(setting: 'serverConfig'): IServerOptions;
    get(setting: 'dictionaryConfig'): IDictionaryComponentOptions;
    get(setting: 'protobufConfig'): IProtobufComponentOptions;
    get(setting: Constants.RESERVED.GLOBAL_ERROR_HANDLER): IResponseErrorHandler;
    get(setting: Constants.RESERVED.ERROR_HANDLER): IResponseErrorHandler;
    get(setting: Constants.RESERVED.MASTER): IMasterServerOpts;
    get(setting: string): string | any;
    /**
     * Set the route function for the specified server type.
     *
     * Examples:
     *
     *  app.route('area', routeFunc);
     *
     *  let routeFunc = function(session, msg, app, cb) {
     *    // all request to area would be route to the first area server
     *    let areas = app.getServersByType('area');
     *    cb(null, areas[0].id);
     *  };
     *
     * @param  {String} serverType server type string
     * @param  {Function} routeFunc  route function. routeFunc(session, msg, app, cb)
     * @return {Object}     current application instance for chain invoking
     * @memberOf Application
     */
    route(routeFunc: IRouteFunction, serverType?: string): this;
    configure(fn: IConfigureFunc): Application;
    configure(env: string, fn: IConfigureFunc): Application;
    configure(env: string, type: string, fn: IConfigureFunc): Application;
    /**
     * 注册管理组件
     * @param module
     * @param opts
     */
    registerAdmin(module: IModule, opts?: any): any;
    registerAdmin(moduleId: string, module?: IModule, opts?: any): any;
    registerAdmin(module: IModuleFactory, opts?: any): any;
    registerAdmin(moduleId: string, module?: IModuleFactory, opts?: any): any;
    /**
     * Check if `setting` is enabled.
     *
     * @param {String} setting application setting
     * @return {Boolean}
     * @memberOf Application
     */
    enabled(setting: string): boolean;
    /**
     * Check if `setting` is disabled.
     *
     * @param {String} setting application setting
     * @return {Boolean}
     * @memberOf Application
     */
    disabled(setting: string): boolean;
    get serverTypes(): TServerType;
    getBase(): string;
    getServerIds(): string[];
    getServers(): IServer;
    getServerType(serverInfo?: IServerInfo): string;
    getServerId(serverInfo?: IServerInfo): IServerId;
    getServerById(id: IServerId): IServerInfo | null;
    getServersByType(type: string): IServerInfo[];
    isFrontend(server?: IServerInfo): boolean;
    /**
     * 加载配置 config目录下
     * @param key
     * @param val
     * @param reload
     */
    loadConfigBaseApp(key: string, val: string, reload?: boolean): void;
    /**
     * Use plugin.
     * @param  {Object} plugin plugin instance
     * @param  {[type]} opts    (optional) construct parameters for the factory function
     * @memberOf Application
     */
    use(plugin: IPlugin, opts?: any): void;
    /**
     * add a filter to before and after filter
     */
    filter(filter: IHandlerFilter): void;
    /**
     * Add before filter.
     * @param {Object|Function} bf before filter, bf(msg, session, next)
     * @memberOf Application
     */
    before(bf: IBeforeHandlerFilter): void;
    /**
     * Add after filter.
     * @param {Object|Function} af after filter, `af(err, msg, session, resp, next)`
     * @memberOf Application
     */
    after(af: IAfterHandlerFilter): void;
    /**
     * add a global filter to before and after global filter
     */
    globalFilter(filter: IHandlerFilter): void;
    /**
     * Add global before filter.
     *
     * @param {Object|Function} bf before filter, bf(msg, session, next)
     * @memberOf Application
     */
    globalBefore(bf: IBeforeHandlerFilter): void;
    /**
     * Add global after filter.
     */
    globalAfter(af: IAfterHandlerFilter): void;
    load<T extends IComponent>(component: ObjectType<T>, opts?: any): T;
    load<T extends IComponent>(name: string, component: ObjectType<T>, opts?: any): T;
    load<T extends IComponent>(component: T, opts?: any): T;
    load<T extends IComponent>(name: string, component: T, opts?: any): T;
    private replaceServer;
    private addFilter;
    /**
     * 加载master服务器配置
     */
    private loadMaster;
    /**
     * 加载一个事件侦听
     * @param Event
     * @param opts
     */
    private loadEvent;
    private contains;
}