import { EventEmitter } from 'eventemitter3';

declare class ServContextedMessage {
    $id: string;
}
interface ServMessageAddOptions {
    timeout?: number;
    prewait?: Promise<any>;
    ctxData?: any;
}
declare class ServMessageContextManager {
    private contexts;
    init(): void;
    release(): void;
    add(message: ServContextedMessage, options?: ServMessageAddOptions): Promise<any> | undefined;
    has(id: string): boolean;
    get(id: string): ServContextedMessage | undefined;
    getPromise(id: string): Promise<any> | undefined;
    getCtxData<T = any>(id: string): T;
    succeed(id: string, data?: any): boolean;
    failed(id: string, error?: any): boolean;
    timeout(id: string, error?: any): boolean;
    protected clean(id: string): boolean;
}

declare enum EServMessage {
    SERVICE = "$service",
    SESSION_CALL = "$session_call",
    SESSION_CALL_RETURN = "$session_call_return",
    SESSION_HEARTBREAK = "$session_heartbreak"
}
declare class ServMessage {
    $id: string;
    $type: EServMessage;
}
declare enum EServServiceMessage {
    NULL = 0,
    API = 1,
    API_RETURN = 2,
    EVENT = 3,
    GET_VERSION = 4,
    GET_VERSION_RETURN = 5
}
interface ServServiceMessage extends ServMessage {
    service: string;
    serviceType: EServServiceMessage;
}
interface ServServiceReturnMessage extends ServServiceMessage {
    data?: any;
    error?: any;
}
interface ServServiceAPIMessage extends ServServiceMessage {
    api: string;
    args?: any;
}
interface ServServiceAPIReturnMessage extends ServServiceReturnMessage {
    api: string;
}
interface ServServiceEventMessage extends ServServiceMessage {
    event: string;
    args?: any;
}
interface ServServiceGetVersionMessage extends ServServiceMessage {
}
interface ServServiceGetVersionReturnMessage extends ServServiceReturnMessage {
}
interface ServSessionCallMessage<T = any> extends ServMessage {
    type: string;
    args?: T;
}
interface ServSessionCallReturnMessage<T = any> extends ServMessage {
    data?: any;
    error?: any;
}

declare type ServACL = any;
declare type ServEXT = any;
/**
 * Service声明注解参数；anno.decl
 *
 * @export
 * @interface ServDeclOptions
 */
interface ServDeclOptions {
    /**
     * Service id
     *
     * @type {string}
     * @memberof ServDeclOptions
     */
    id: string;
    /**
     * Service version
     *
     * @type {string}
     * @memberof ServDeclOptions
     */
    version: string;
    /**
     * Service粒度的访问权限
     *
     * @type {ServACL}
     * @memberof ServDeclOptions
     */
    ACL?: ServACL;
    /**
     * Service的扩展数据
     *
     * @type {ServEXT}
     * @memberof ServDeclOptions
     */
    EXT?: ServEXT;
    /**
     * 是否需要Service版本校对，默认为true
     *
     * @type {boolean}
     * @memberof ServDeclOptions
     */
    noVersionCheck?: boolean;
    noRPCCallEvent?: boolean;
}
/**
 * Service实现注解参数；anno.impl
 *
 * @export
 * @interface ServImplOptions
 */
interface ServImplOptions {
    /**
     * 指定Service api中是否需要ServAPICallContext；默认为false
     *
     * @type {boolean}
     * @memberof ServImplOptions
     */
    needCallContext?: boolean;
}
/**
 * API 调用时，数据传输过程当中的序列化与反序列化功能
 */
interface ServApiTransformOptions<T = any, R = any> {
    /**
     * 发送数据时，序列化操作
     * @param args
     */
    send: (args: T) => R;
    /**
     * 接收到数据，反序列化操作
     * @param rawArgs
     */
    recv: (rawArgs: R) => T;
}
/**
 * Service API 注解参数；anno.decl.api
 *
 * @export
 * @interface ServAPIOptions
 */
interface ServAPIOptions {
    /**
     * API调用timeout设置，如果为小于等于0，则无timeout机制；
     * 默认为30s
     *
     * @type {number}
     * @memberof ServAPIOptions
     */
    timeout?: number;
    /**
     * API是否有返回值，默认为true
     *
     * @type {boolean}
     * @memberof ServAPIOptions
     */
    dontRetn?: boolean;
    /**
     * 对API的参数和结果提供的序列化能力；
     * API调用阶段的数据转换回调，这是Client方的回调处理；
     * 回调调用时序为 Client.onCallTransform.send -> send message to Server
     *              -> Server.onRetnTransform.recv
     *              -> impl process
     *              -> Server.onRetnTransform.send -> send message to Client
     *              -> Client.onCallTransform.recv
     *
     * @memberof ServAPIOptions
     *
     * send  API调用时发送阶段的转换回调，args为原始参数，返回值为最终发送给Server的数据
     *
     * recv  Client API接收阶段的转换回调，args为接收的原始数据，返回值为最终API返回的数据
     *
     */
    onCallTransform?: ServApiTransformOptions;
    /**
     * 对API的参数和结果提供的序列化能力；
     * API返回阶段的数据转换回调，这是Server方的回调处理
     *
     * @memberof ServAPIOptions
     *
     * send Server API处理后在发送阶段的转换回调，args为处理返回的原始数据，返回值为最终发送给Client的数据
     * recv Server API接收阶段的转换回调，args为Client发送的原始数据，返回值为最终处理函数的参数
     *
     */
    onRetnTransform?: ServApiTransformOptions;
    /**
     * API 粒度的访问权限
     *
     * @type {ServACL}
     * @memberof ServAPIOptions
     */
    ACL?: ServACL;
    /**
     * API 的扩展数据
     *
     * @type {ServEXT}
     * @memberof ServAPIOptions
     */
    EXT?: ServEXT;
}
/**
 * notify 形式的注解参数；anno.decl.notify；参加ServAPIOptions
 *
 * @export
 * @interface ServNotifyOptions
 */
interface ServNotifyOptions {
    onCallTransform?: {
        send: (args: any) => any;
        recv: (rawArgs: any) => any;
    };
    ACL?: ServACL;
    EXT?: ServEXT;
}
/**
 * event 的注解参数；anno.event
 *
 * @export
 * @interface ServEventerOptions
 */
interface ServEventerOptions {
    /**
     * event 的访问权限
     *
     * @type {ServACL}
     * @memberof ServEventerOptions
     */
    ACL?: ServACL;
    /**
     * event 的扩展数据
     *
     * @type {ServEXT}
     * @memberof ServEventerOptions
     */
    EXT?: ServEXT;
    /**
     * 对API的参数和结果提供的序列化能力；
     * API调用阶段的数据转换回调，这是Client方的回调处理；
     * 回调调用时序为 Client.onCallTransform.send -> send message to Server
     *              -> Server.onRetnTransform.recv
     *              -> impl process
     *              -> Server.onRetnTransform.send -> send message to Client
     *              -> Client.onCallTransform.recv
     *
     * @memberof ServAPIOptions
     */
    transform?: ServApiTransformOptions;
}
/**
 * API 调用options参数，只有在Service Client端调用有效
 *
 * @export
 * @interface ServAPICallOptions
 */
interface ServAPICallOptions {
    /**
     * API 调用的timeout，如果小于等于0，则无timeout机制
     *
     * @type {number}
     * @memberof ServAPICallOptions
     */
    timeout?: number;
}
/**
 * Service API执行期间的context，在needCallContext为true的Service中有效；只有在Service Server端调用有效
 *
 * @export
 * @interface ServAPICallContext
 */
interface ServAPICallContext {
    terminal: ServTerminal;
    extData: any;
}
/**
 * Service API 签名
 *
 * @export
 * @interface ServAPI
 * @argument args API调用参数
 * @argument optionsOrContext 在Service Client端为options，在Service Server端为context；
 *  context只在RPC调用场景有效，如果直接通过service进行调用则无context信息
 * @template A 参数类型
 * @template R 结果类型
 */
interface ServAPI<A, R = void> {
    (args: A, optionsOrContext?: ServAPICallOptions | ServAPICallContext): Promise<R>;
}
declare type ServAPIArgs<A = void> = A;
declare type ServAPIRetn<R = void> = Promise<R>;
declare const API_UNSUPPORT: () => Promise<never>;
declare const API_ERROR: (error?: any) => Promise<never>;
declare function API_SUCCEED(): Promise<any>;
declare function API_SUCCEED<T>(data: Promise<T>): Promise<T>;
declare function API_SUCCEED<T>(data: T): Promise<T>;
declare type ServEventListener<A = any> = (args: A) => void;
declare type ServEventUnListener = () => void;
/**
 * Service event 类型，eventer用于在Service上做远程事件通知
 *
 * @export
 * @interface ServEventer
 * @template A
 */
interface ServEventer<A = void> {
    on(listener: ServEventListener<A>): ServEventUnListener;
    once(listener: ServEventListener<A>): ServEventUnListener;
    emit(args: A): void;
}
interface ServAPIMeta {
    name: string;
    options: ServAPIOptions;
}
interface ServEventerMeta {
    name: string;
    options: ServEventerOptions;
}
interface ServServiceMeta {
    id: string;
    version: string;
    ACL?: ServACL;
    EXT?: ServEXT;
    apis: ServAPIMeta[];
    evts: ServEventerMeta[];
    noVersionCheck?: boolean;
    noRPCCallEvent?: boolean;
}
/**
 * Service基类
 *
 * @export
 * @class ServService
 */
declare class ServService {
    /**
     * 获取Service meta数据
     *
     * @returns
     * @memberof ServService
     */
    meta(): ServServiceMeta | undefined;
    /**
     * 获取Service impl meta数据
     *
     * @returns
     * @memberof ServService
     */
    implMeta(): ServServiceImplMeta | undefined;
    /**
     * 根据ID获取Service，只能获取Service所在Manager中的服务
     *
     * @template T
     * @param {string} id
     * @returns {(T | undefined)}
     * @memberof ServService
     */
    getServiceByID<T extends ServService>(id: string): T | undefined;
    /**
     * 根据类型获取Service，只能获取Service所在Manager中的服务
     *
     * @template T
     * @param {T} decl
     * @returns {(InstanceType<T> | undefined)}
     * @memberof ServService
     */
    getService<T extends typeof ServService>(decl: T): InstanceType<T> | undefined;
    getService<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: InstanceType<M[key]> | undefined;
    };
    /**
     * 根据类型获取Service，只能获取Service所在Manager中的服务
     *
     * @template T
     * @param {T} decl
     * @returns {InstanceType<T>}
     * @memberof ServService
     */
    getServiceUnsafe<T extends typeof ServService>(decl: T): InstanceType<T>;
    getServiceUnsafe<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: InstanceType<M[key]>;
    };
    /**
     * 根据类型获取Service，异步版本，只能获取Service所在Manager中的服务
     *
     * @template T
     * @param {T} decl
     * @returns {Promise<InstanceType<T>>}
     * @memberof ServService
     */
    service<T extends typeof ServService>(decl: T): Promise<InstanceType<T>>;
    service<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): Promise<{
        [key in keyof M]: InstanceType<M[key]>;
    }>;
    /**
     * 根据类型获取Service，callback版本，只能获取Service所在Manager中的服务
     *
     * @template T
     * @template R
     * @param {T} decl
     * @param {((service: InstanceType<T>) => R)} exec
     * @returns {(R | null)}
     * @memberof ServService
     */
    serviceExec<T extends typeof ServService, R>(decl: T, exec: ((service: InstanceType<T>) => R)): R | null;
    serviceExec<M extends {
        [key: string]: typeof ServService;
    }, R>(decls: M, exec: ((services: {
        [key in keyof M]: InstanceType<M[key]>;
    }) => R)): R | null;
    /**
     * 根据ID获取Service，callback版本，只能获取Service所在Manager中的服务
     *
     * @template T
     * @template R
     * @param {string} id
     * @param {((service: T) => R)} exec
     * @returns {(R | null)}
     * @memberof ServService
     */
    serviceExecByID<T extends ServService, R>(id: string, exec: ((service: T) => R)): R | null;
    /**
     * 获取Service meta数据
     *
     * @static
     * @returns
     * @memberof ServService
     */
    static meta(): ServServiceMeta | undefined;
    /**
     * 获取Service impl meta数据
     *
     * @returns
     * @memberof ServService
     */
    static implMeta(): ServServiceImplMeta | undefined;
}
/**
 * Service decl相关注解
 *
 * @export
 * @interface ServAnnoDecl
 */
interface ServAnnoDecl {
    (options: ServDeclOptions): ((cls: typeof ServService) => void);
    api: typeof api;
    notify: typeof notify;
    event: typeof event;
}
/**
 * Service impl相关注解
 *
 * @export
 * @interface ServAnnoImpl
 */
interface ServAnnoImpl {
    (options?: ServImplOptions): ((cls: typeof ServService) => void);
}
/**
 * Service api 注解
 *
 * @param {ServAPIOptions} [options]
 * @returns
 */
declare function api(options?: ServAPIOptions): (proto: any, propKey: string) => void;
/**
 * Service notify 注解
 *
 * @param {ServNotifyOptions} [options]
 * @returns
 */
declare function notify(options?: ServNotifyOptions): (proto: any, propKey: string) => void;
/**
 * Service event 注解
 *
 * @param {ServEventerOptions} [options]
 * @returns
 */
declare function event(options?: ServEventerOptions): (proto: any, propKey: string) => void;
/**
 * Service impl相关meta数据
 *
 * @export
 * @interface ServServiceImplMeta
 */
interface ServServiceImplMeta {
    /**
     * 指定Service api中是否需要ServAPICallContext；默认为false
     *
     * @type {boolean}
     * @memberof ServServiceImplMeta
     */
    needCallContext?: boolean;
}
/**
 * Service 相关注解
 */
declare const anno: {
    decl: ServAnnoDecl;
    impl: ServAnnoImpl;
};

declare class Eventer implements ServEventer {
    protected readonly option?: ServApiTransformOptions<any, any> | undefined;
    static generateRawEvent(service: string, event: string): string;
    service: string;
    event: string;
    protected rawEvent: string;
    protected _unlisteners?: ServEventUnListener[];
    protected center?: EventEmitter;
    constructor(service: string, event: string, option?: ServApiTransformOptions<any, any> | undefined);
    protected wrapTransformListener(listener: ServEventListener): ServEventListener;
    on(listener: ServEventListener): ServEventUnListener;
    once(listener: ServEventListener): ServEventUnListener;
    emit(args: any): Promise<void>;
    attach(center: EventEmitter): void;
    detach(): void;
    protected generateUnlitener(listener: ServEventListener): ServEventUnListener;
    protected get unlisteners(): ServEventUnListener[];
}
declare type ServEventerOnEmitListener = (eventer: Eventer, args: any) => Promise<void>;
declare class ServEventerManager {
    protected eventers: Eventer[];
    protected center: EventEmitter;
    protected onEmit?: ServEventerOnEmitListener;
    protected oldEmit?: EventEmitter['emit'];
    init(onEmit?: ServEventerOnEmitListener): void;
    release(): void;
    spawn(service: string, event: string, option?: ServApiTransformOptions): Eventer;
    rawEmit(service: string, event: string, args: any): void;
    protected initCenter(): void;
    protected releaseCenter(): void;
}

interface ServServiceClientConfig {
}
declare type IServClientService<T extends typeof ServService = any> = Omit<InstanceType<T>, keyof ServService>;
declare class ServServiceClient {
    protected messageContextManager: ServMessageContextManager;
    protected eventerManager: ServEventerManager;
    protected services: {
        [key: string]: ServService;
    };
    protected terminal: ServTerminal;
    protected sessionUnlisten?: (() => void);
    constructor(terminal: ServTerminal);
    init(config?: ServServiceClientConfig): void;
    release(): void;
    private _getService;
    getService<T extends typeof ServService>(decl: T): IServClientService<T> | undefined;
    getService<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: IServClientService<M[key]> | undefined;
    };
    getServiceUnsafe<T extends typeof ServService>(decl: T): IServClientService<T>;
    getServiceUnsafe<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: IServClientService<M[key]>;
    };
    service<T extends typeof ServService>(decl: T): Promise<IServClientService<T>>;
    service<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): Promise<{
        [key in keyof M]: IServClientService<M[key]>;
    }>;
    serviceExec<T extends typeof ServService, R>(decl: T, exec: ((service: IServClientService<T>) => R)): any;
    serviceExec<M extends {
        [key: string]: typeof ServService;
    }, R>(decls: M, exec: ((services: {
        [key in keyof M]: IServClientService<M[key]>;
    }) => R)): any;
    protected checkServiceVersion(service: ServServiceMeta): void;
    private generateService;
    private generateServiceAPI;
    private generateServiceEvent;
    private sendMessage;
    protected onRecvMessage: (message: ServMessage) => boolean;
    protected handleAPIReturnMessage(message: ServServiceReturnMessage, origin: ServServiceMessage): boolean;
    protected sendCommonMessageForReturn(message: ServServiceMessage, timeout?: number): Promise<any>;
    protected handleCommonMessageReturn(message: ServServiceReturnMessage, origin: ServServiceMessage): boolean;
    protected handleEventMessage(message: ServServiceEventMessage): boolean;
}

declare class ServServiceServerACLResolver {
    canAccessService(server: ServServiceServer, service: ServServiceMeta): boolean;
    canAccessAPI(server: ServServiceServer, service: ServServiceMeta, api: ServAPIMeta): boolean;
    canAccessEventer(server: ServServiceServer, service: ServServiceMeta, event: ServEventerMeta): boolean;
}

interface ServServiceInfo {
    meta: ServServiceMeta;
    decl: typeof ServService;
    impl: typeof ServService;
}
interface ServServiceOptions {
    lazy?: boolean;
}
declare type ServServiceReferPattern = RegExp | string | ((service: string) => boolean) | Array<RegExp | string | ((service: string) => boolean)>;
declare type ServServiceOnEmitListener = (service: string, event: string, args: any) => void;
declare class ServServiceRefer {
    protected pattern: ServServiceReferPattern;
    protected manager: ServServiceManager;
    onEvnterEmit?: ServServiceOnEmitListener;
    constructor(manager: ServServiceManager, pattern: ServServiceReferPattern);
    canRefer(service: string): boolean;
    getServiceByID<T extends ServService>(id: string): T | undefined;
    getService<T extends typeof ServService>(decl: T): InstanceType<T> | undefined;
    rawEmit(service: string, event: string, args: any): void;
    setPattern(pattern: ServServiceReferPattern): void;
    detach(): void;
    _onEventerEmit(service: string, event: string, args: any): void;
}
interface ServServiceConfig {
    services?: Array<{
        decl: typeof ServService;
        impl: typeof ServService;
        options?: ServServiceOptions;
    }>;
}
declare class ServServiceManager {
    protected eventerManager: ServEventerManager;
    protected services: {
        [key: string]: ServService;
    };
    protected serviceInfos: {
        [key: string]: ServServiceInfo;
    };
    protected refers: ServServiceRefer[];
    protected serviceInjects?: {
        getService: ServServiceManager['getService'];
        getServiceUnsafe: ServServiceManager['getServiceUnsafe'];
        service: ServServiceManager['service'];
        serviceExec: ServServiceManager['serviceExec'];
        getServiceByID: ServServiceManager['getServiceByID'];
        serviceExecByID: ServServiceManager['serviceExecByID'];
    };
    onEvnterEmit?: ServServiceOnEmitListener;
    init(config?: ServServiceConfig): void;
    release(): void;
    getServiceByID<T extends ServService>(id: string): T | undefined;
    protected _getService<T extends typeof ServService>(decl: T): InstanceType<T> | undefined;
    getService<T extends typeof ServService>(decl: T): InstanceType<T> | undefined;
    getService<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: InstanceType<M[key]> | undefined;
    };
    getServiceUnsafe<T extends typeof ServService>(decl: T): InstanceType<T>;
    getServiceUnsafe<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: InstanceType<M[key]>;
    };
    service<T extends typeof ServService>(decl: T): Promise<InstanceType<T>>;
    service<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): Promise<{
        [key in keyof M]: InstanceType<M[key]>;
    }>;
    serviceExec<T extends typeof ServService, R>(decl: T, exec: ((service: InstanceType<T>) => R)): any;
    serviceExec<M extends {
        [key: string]: typeof ServService;
    }, R>(decls: M, exec: ((services: {
        [key in keyof M]: InstanceType<M[key]>;
    }) => R)): any;
    serviceExecByID<T extends ServService, R>(id: string, exec: ((service: T) => R)): R | null;
    addService<D extends typeof ServService, I extends D>(decl: D, impl: I, options?: ServServiceOptions): boolean;
    addServices(items: Array<{
        decl: typeof ServService;
        impl: typeof ServService;
        options?: ServServiceOptions;
    }>, options?: ServServiceOptions): void;
    remService(decl: typeof ServService): boolean;
    remServices(decls: Array<typeof ServService>): void;
    referServices(pattern: ServServiceReferPattern): ServServiceRefer;
    rawEmit(service: string, event: string, args: any): void;
    private generateService;
    private generateServiceEvent;
    private _onEventerEmit;
    onReferAttach(refer: ServServiceRefer): void;
    onReferDetach(refer: ServServiceRefer): void;
}

interface ServServiceServerConfig {
    service?: ServServiceConfig;
    serviceRefer?: ServServiceReferPattern;
    ACLResolver?: ServServiceServerACLResolver;
}
/**
 * Service RPC 相关事件
 *
 * @export
 * @enum {number}
 */
declare enum EServRPCEvent {
    /**
     * RPC处理事件；
     * 事件传递参数：API Return Promise，API Args，API Name，ServService，ServTerminal，Servkit
     */
    CALL = "SERV_RPC_CALL"
}
declare class ServServiceServer {
    terminal: ServTerminal;
    protected serviceManager: ServServiceManager;
    protected serviceRefer?: ServServiceRefer;
    protected ACLResolver?: ServServiceServerACLResolver;
    protected sessionUnlisten?: (() => void);
    constructor(terminal: ServTerminal);
    init(config?: ServServiceServerConfig): void;
    release(): void;
    getService<T extends typeof ServService>(decl: T): InstanceType<T> | undefined;
    getService<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: InstanceType<M[key]> | undefined;
    };
    getServiceUnsafe<T extends typeof ServService>(decl: T): InstanceType<T>;
    getServiceUnsafe<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): {
        [key in keyof M]: InstanceType<M[key]>;
    };
    service<T extends typeof ServService>(decl: T): Promise<InstanceType<T>>;
    service<M extends {
        [key: string]: typeof ServService;
    }>(decls: M): Promise<{
        [key in keyof M]: InstanceType<M[key]>;
    }>;
    serviceExec<T extends typeof ServService, R>(decl: T, exec: ((service: InstanceType<T>) => R)): any;
    serviceExec<M extends {
        [key: string]: typeof ServService;
    }, R>(decls: M, exec: ((services: {
        [key in keyof M]: InstanceType<M[key]>;
    }) => R)): any;
    serviceExecByID<T extends ServService, R>(id: string, exec: ((service: T) => R)): R | null;
    getServiceByID<T extends ServService>(id: string): T | undefined;
    protected _getService<T extends typeof ServService>(decl: T): InstanceType<T> | undefined;
    addService<D extends typeof ServService, I extends D>(decl: D, impl: I, options?: ServServiceOptions): boolean;
    addServices(items: Array<{
        decl: typeof ServService;
        impl: typeof ServService;
        options?: ServServiceOptions;
    }>, options?: ServServiceOptions): void;
    protected onRecvMessage: (message: ServMessage) => boolean;
    protected handleAPIMessage(message: ServServiceAPIMessage): boolean;
    protected handleGetVesionMessage(message: ServServiceGetVersionReturnMessage): boolean;
    protected sendReturnMessage(retnPromise: Promise<any>, origin: ServServiceMessage, retnCreator: (message: ServServiceMessage, data?: any, error?: any) => ServServiceReturnMessage): void;
    protected sendMessage(message: ServMessage): Promise<void>;
    protected onEventerEmit: ServServiceOnEmitListener;
}

interface ServGlobalServiceConfig extends ServServiceConfig {
}
declare class ServGlobalServiceManager extends ServServiceManager {
    init(config?: ServGlobalServiceConfig): void;
}

/**
 * Servkit配置
 *
 * @export
 * @interface ServkitConfig
 */
interface ServkitConfig {
    /**
     * 全局服务，也可在servkit初始化后，手动添加
     *
     * @type {ServGlobalServiceConfig}
     * @memberof ServkitConfig
     */
    service?: ServGlobalServiceConfig;
}
declare class Servkit extends EventEmitter {
    namespace: string;
    service: ServGlobalServiceManager;
    protected terminals: ServTerminal[];
    constructor(namespace?: string);
    init(config?: ServkitConfig): void;
    release(): void;
    createTerminal(config: ServTerminalConfig): ServTerminal;
    destroyTerminal(terminal: ServTerminal): void;
    onTerminalInit(terminal: ServTerminal): void;
    onTerminalRelease(terminal: ServTerminal): void;
}
declare const servkit: Servkit;

declare enum EServTerminal {
    NULL = 0,
    MASTER = 1,
    SLAVE = 2
}
interface ServTerminalConfig {
    id: string;
    type: EServTerminal;
    client?: ServServiceClientConfig;
    server?: ServServiceServerConfig;
    session: ServSessionConfig;
}
declare class ServTerminal {
    id: string;
    type: EServTerminal;
    servkit: Servkit;
    client: ServServiceClient;
    server: ServServiceServer;
    session: ServSession;
    protected extData: any;
    constructor(servkit: Servkit);
    init(config: ServTerminalConfig): void;
    isMaster(): boolean;
    release(): void;
    setExtData<T = any>(data: T): void;
    getExtData<T = any>(): T;
    openSession(options?: ServSessionOpenOptions): Promise<void>;
    closeSession(): void;
}

declare enum EServChannel {
    WINDOW = 1,
    MESSAGE = 2,
    EVENT = 3,
    EVENT_LOADER = 4
}
interface ServChannelConfig {
    ignoreSenderType?: boolean;
}
interface ServChannelOpenOptions {
}
interface ServChannelObjectPackage {
    __mark__: string;
    data: ServSessionPackage;
}
declare type ServChannelPackage = string | ServChannelObjectPackage;
declare abstract class ServChannel {
    protected session: ServSession;
    protected config: ServChannelConfig;
    protected sendMark: string;
    protected recvMark: string;
    protected recvable: boolean;
    protected sendable: boolean;
    protected sendStringMark: string;
    protected recvStringMark: string;
    init(session: ServSession, config?: ServChannelConfig): void;
    release(): void;
    isRecvable(): boolean;
    isSendable(): boolean;
    isOpened(): boolean;
    send(msg: ServSessionPackage): boolean;
    abstract open(options?: ServChannelOpenOptions): Promise<void>;
    abstract close(): void;
    protected toObjectPackage(data: ServSessionPackage): ServChannelObjectPackage;
    protected toStringPackage(data: ServSessionPackage): string;
    protected frObjectPackage(data: ServChannelObjectPackage): ServSessionPackage | undefined;
    protected frStringPackage(data: string): ServSessionPackage | undefined;
    protected frChannelPackage(rawData: ServChannelPackage): ServSessionPackage | undefined;
    protected abstract sendChannelPackage(msg: ServChannelPackage): boolean;
    protected canRecvChannelPackage(msg: ServChannelPackage): boolean;
    protected recvChannelPackage(msg: ServChannelPackage): void;
}

interface ServEventChannelConfig extends ServChannelConfig {
}
declare class ServEventChannel extends ServChannel {
    protected config: ServEventChannelConfig;
    protected asyncDispatchPromise: Promise<void>;
    init(session: ServSession, config: ServEventChannelConfig): void;
    open(options?: ServChannelOpenOptions): Promise<void>;
    close(): void;
    protected attachMessageChannel(): void;
    protected detachMessageChannel(): void;
    protected onEventMessage: (event: CustomEvent) => void;
    protected sendChannelPackage(pkg: ServChannelPackage): boolean;
}

interface ServChannelWindow {
    target: Window | null;
    window: Window | null;
    origin: string;
    element?: HTMLIFrameElement;
}
interface ServChanleWindowData {
    target: Window | null;
    window?: Window;
    origin?: string;
    element?: HTMLIFrameElement;
}
interface ServWindowChannelOpenOptions extends ServChannelOpenOptions {
    dontWaitSlaveEcho?: boolean;
}
interface ServWindowChannelConfig extends ServChannelConfig {
    master?: {
        dontWaitEcho?: boolean;
        createWindow(channel: ServWindowChannel): ServChanleWindowData;
        destroyWindow(windowInfo: ServChannelWindow, channel: ServWindowChannel): void;
        onCreate?(windowInfo: ServChannelWindow, channel: ServWindowChannel): void;
        onOpened?(windowInfo: ServChannelWindow, channel: ServWindowChannel): void;
        onOpenError?(channel: ServWindowChannel): void;
        onDestroy?(windowInfo: ServChannelWindow, channel: ServWindowChannel): void;
        onClosed?(channel: ServWindowChannel): void;
        onEcho?(info: ServChannelWindow, channel: ServWindowChannel): void;
    };
    slave?: {
        getWindow(channel: ServWindowChannel): ServChanleWindowData;
    };
}
declare class ServWindowChannel extends ServChannel {
    protected config: ServWindowChannelConfig;
    protected windowInfo: ServChannelWindow;
    protected doWaitSlaveCleanWork?: (() => void);
    open(options?: ServWindowChannelOpenOptions): Promise<void>;
    close(): void;
    protected waitSlaveEcho(options: ServWindowChannelOpenOptions): Promise<void>;
    protected slaveEcho(): void;
    protected attachMessageChannel(): void;
    protected detachMessageChannel?: () => void;
    protected onWindowMessage: (event: MessageEvent) => void;
    protected sendChannelPackage(msg: ServChannelPackage): boolean;
}

interface ServMessageChannelConfig {
}
declare class ServMessageChannel extends ServWindowChannel {
    protected config: ServMessageChannelConfig;
    open(options?: ServWindowChannelOpenOptions): Promise<void>;
    protected onWindowMessage: (event: MessageEvent) => void;
}

declare class ServMessageCreator {
    static create(type: EServMessage): ServMessage;
    static clone(origin: ServMessage): ServMessage;
}
declare class ServServiceMessageCreator {
    static create(type: EServServiceMessage, service: string): ServServiceMessage;
    static createReturn(origin: ServServiceGetVersionMessage, type: EServServiceMessage, data: any, error?: any): ServServiceGetVersionReturnMessage;
    static clone(origin: ServServiceMessage): ServServiceMessage;
    static createAPI(service: string, api: string, args?: any): ServServiceAPIMessage;
    static createAPIReturn(origin: ServServiceAPIMessage, data?: any, error?: any): ServServiceAPIReturnMessage;
    static createEvent(service: string, event: string, args?: any): ServServiceEventMessage;
    static isServiceMessage(message: ServMessage): boolean;
    static isAPIMessage(message: ServServiceMessage): boolean;
    static isEventMessage(message: ServServiceMessage): boolean;
    static isAPIReturnMessage(message: ServServiceReturnMessage, origin?: ServServiceMessage): boolean;
    static isGetVersionMessage(message: ServServiceMessage): boolean;
    static isGetVersionReturnMessage(message: ServServiceMessage, origin?: ServServiceMessage): boolean;
}
declare class ServSessionCallMessageCreator {
    static create(type: string, args: any): ServSessionCallMessage;
    static createReturn(origin: ServSessionCallMessage, data?: any, error?: any): ServSessionCallReturnMessage;
    static isCallMessage(message: ServMessage): boolean;
    static isCallReturnMessage(message: ServMessage, origin?: ServSessionCallMessage): boolean;
}

interface ServSessionCheckerStartOptions {
    interval?: number;
    tryCount?: number;
    onBroken?: (session: ServSession) => void;
}
declare class ServSessionChecker {
    protected session: ServSession;
    protected options: ServSessionCheckerStartOptions;
    protected isStarted: boolean;
    protected timer: number;
    protected latestEchoTime: number;
    protected lastCheckEchoTime: number;
    protected checkCount: number;
    protected unlisten?: (() => void);
    constructor(session: ServSession);
    start(options?: ServSessionCheckerStartOptions): void;
    startChecking(): void;
    stop(): void;
    protected onCheck: () => void;
    handleEchoMessage(msg: ServMessage): boolean;
    protected resetCheckData(): void;
}

declare enum EDeferredResult {
    NONE = 0,
    RESOLVED = 1,
    REJECTED = 2,
    TIMEOUT = 3
}
interface DeferredOptions {
    timeout?: number;
    rejectIf?: Promise<void>;
    resolveIf?: Promise<void>;
}
interface Deferred<T = void> extends Promise<T> {
    reject(error?: any): void;
    resolve(): void;
    resolve(data: T): void;
    isFinished(): EDeferredResult;
}
declare class DeferredUtil {
    static create<T = void>(options?: DeferredOptions): Deferred<T>;
    static resolve<T = void>(data?: any): Deferred<T>;
    static reject<T = void>(error?: any): Deferred<T>;
    static reEntryGuard<T extends Function>(func: T, options?: DeferredOptions): T & {
        deferred: Deferred | undefined;
    };
}

declare enum EServSessionStatus {
    CLOSED = 0,
    OPENNING = 1,
    OPENED = 2
}
interface ServSessionCallOptions {
    timeout?: number;
}
interface ServSessionConfig {
    checkSession?: boolean;
    checkOptions?: ServSessionCheckerStartOptions;
    channel: {
        type: EServChannel | typeof ServChannel;
        config?: ServChannelConfig | ServWindowChannelConfig | ServMessageChannelConfig | ServEventChannelConfig;
    };
}
interface ServSessionOpenOptions {
    timeout?: number;
    waiting?: Promise<void>;
}
declare type ServSessionPackage = ServMessage;
interface ServSessionListener {
    onRecvData<T>(data: any): boolean;
}
declare type ServSessionOnRecvMessageListener = (message: ServMessage, session: ServSession, terminal: ServTerminal) => boolean;
declare type ServSessionOnRecvCallMessageListener = (type: string, args: any, doReturn: ((data?: any, error?: any) => void), session: ServSession, terminal: ServTerminal) => boolean;
interface PendingMessage {
    isSend?: boolean;
    sendDeferred?: Deferred;
    message: ServMessage;
}
declare class ServSession {
    protected terminal: ServTerminal;
    protected status: EServSessionStatus;
    protected openningPromise?: Promise<void>;
    protected openningCancel?: (() => void);
    protected channel: ServChannel;
    protected onRecvListeners: ServSessionOnRecvMessageListener[];
    protected onRecvCallListeners: ServSessionOnRecvCallMessageListener[];
    protected messageContextManager: ServMessageContextManager;
    protected sessionChecker?: ServSessionChecker;
    protected sessionCheckOptions?: ServSessionCheckerStartOptions;
    protected pendingQueue: PendingMessage[];
    constructor(terminal: ServTerminal);
    init(config: ServSessionConfig): void;
    release(): void;
    protected initChannel(config: ServSessionConfig['channel']): void;
    protected releaseChannel(): void;
    isMaster(): boolean;
    getID(): string;
    isOpened(): boolean;
    open(options?: ServSessionOpenOptions): Promise<void>;
    close(): void;
    sendMessage(msg: ServMessage): Promise<void>;
    callMessage<T = any>(type: string, args?: any, options?: ServSessionCallOptions): Promise<T>;
    protected handleReturnMessage(message: ServSessionCallReturnMessage): boolean;
    recvPackage(pkg: ServSessionPackage): void;
    protected dispatchMessage(msg: ServMessage): void;
    onRecvMessage(listener: ServSessionOnRecvMessageListener): () => void;
    onRecvCallMessage(listener: ServSessionOnRecvCallMessageListener): () => void;
    protected flushPendingQueue(): void;
}

declare function nextUUID(): string;
declare function safeExec<T extends (...args: any) => any>(func: T): ReturnType<T>;

declare function aspect<O = any>(obj: O, fn: string, beforeImpl?: () => void, afterImpl?: (result?: any) => any): void;
declare function aspectBefore<O = any>(obj: O, fn: string, impl: () => void): void;
declare function aspectAfter<O = any>(obj: O, fn: string, impl: (result: any) => any): void;

declare type AsyncMutexUnlock = () => void;
interface AsyncMutexLock {
    deferred: Deferred<AsyncMutexUnlock>;
    unlock: AsyncMutexUnlock;
}
interface AsyncMutexOptions {
    max?: number;
}
declare class AsyncMutex {
    protected lockQueue: AsyncMutexLock[];
    protected lockMax: number;
    constructor(options?: AsyncMutexOptions);
    lock(): Promise<AsyncMutexUnlock>;
    lockGuard<T extends Function>(func: T): T;
    protected tryLock(): void;
}

declare function wrapServQueryParams(url: string, params: any): string;
declare function generateServQueryParams(params: any): string;
declare function parseServQueryParams(): any;
declare function replacePlaceholders(url: string, params: {
    [key: string]: string;
}): string;

interface SappShowParams$1 {
    force?: boolean;
    data?: any;
}
interface SappHideParams$1 {
    force?: boolean;
    data?: any;
}
interface SappAuthParams {
    token: string;
    [property: string]: any;
}
interface SappCloseResult {
    data?: any;
    error?: any;
}

interface SappShowParams extends SappShowParams$1 {
    byCreate?: boolean;
}
interface SappHideParams extends SappHideParams$1 {
    byClose?: boolean;
}
interface SappOnShowResult {
    dontShow?: boolean;
}
interface SappOnHideResult {
    dontHide?: boolean;
}
interface SappOnCloseResult {
    dontClose?: boolean;
}

declare abstract class SappController {
    app: Sapp;
    protected cleanHideLifeChecker?: () => void;
    private layoutOptions?;
    constructor(app: Sapp);
    setLayoutOptions(options?: SappCreateOptions['layout']): void;
    protected abstract setupLayout(options: SappLayoutOptions): void;
    doConfig(options: SappCreateOptions): Promise<void>;
    doStart(): Promise<void>;
    doAsyncStart(): Promise<void>;
    doCreate(): Promise<void>;
    doShow(): Promise<void>;
    doHide(): Promise<void>;
    doClose(result?: SappCloseResult): Promise<void>;
    doAuth(params: SappAuthParams): Promise<void>;
    protected beforeStart(): Promise<void>;
    protected afterStart(): Promise<void>;
    protected beforeStartBeforeAspect(): void;
    protected doHideAfterAspect(): void;
    protected doShowBeforeAspect(): void;
    protected doCloseAfterAspect(): void;
    protected resolveServiceClientConfig(options: SappCreateOptions): ServServiceClientConfig;
    protected resolveServiceServerConfig(options: SappCreateOptions): ServServiceServerConfig;
    protected resolveSessionConfig(options: SappCreateOptions): ServSessionConfig;
    protected resolveSessionChannelConfig(options: SappCreateOptions): ServSessionConfig['channel'];
    protected onSessionBroken(): void;
    onAttach(app: Sapp): boolean;
    onDetach(app: Sapp): false | undefined;
}

declare class SappACLResolver extends ServServiceServerACLResolver {
    protected app: Sapp;
    constructor(app: Sapp);
    init(): Promise<void>;
}

/**
 * Sapp创建策略，当应用重复创建时，使用该枚举值进行控制
 */
declare enum ESappCreatePolicy {
    NONE = 0,
    /**
     * 单例模式，重复创建应用会失败；默认值
     */
    SINGLETON = 1,
    /**
     * 无限模式，可以创建任意多应用实例
     */
    INFINITE = 2
}
/**
 * Sapp在隐藏时的生命管理策略；对于一些加载敏感的应用，可以使用显示/隐藏来提高应用的加载体验；而如果应用占优资源较多，隐藏时间过长时，则可以基于该枚举来控制是否直接关闭应用而释放资源
 */
declare enum ESappLifePolicy {
    NONE = 0,
    /**
     * 手动模式，在隐藏后，需要显式关闭应用；默认值
     */
    MANUAL = 1,
    /**
     * 自动模式，在隐藏超过lifeMaxHideTime时间后，应用自动被关闭
     */
    AUTO = 2
}
/**
 * Sapp类型
 */
declare enum ESappType {
    /**
     * 基于IFrame的应用，应用运行在一个IFrame Web上下文，与主应用运行环境完全隔离；默认值
     */
    IFRAME = "IFRAME",
    /**
     * 基于异步机制的应用，应用与主应用运行在同一个Web环境；
     */
    ASYNC_LOAD = "ASYNC_LOAD",
    HOST_PAGE = "HOST_PAGE"
}
/**
 * Sapp信息
 */
declare class SappInfo {
    /**
     * 应用唯一ID，建议使用类Java的域ID命名方式，比如“com.servkit.example”
     *
     * @type {string}
     * @memberof SappInfo
     */
    id: string;
    /**
     * 应用版本
     *
     * @type {string}
     * @memberof SappInfo
     */
    version: string;
    /**
     * 应用名称
     *
     * @type {string}
     * @memberof SappInfo
     */
    name?: string;
    /**
     * 应用描述
     *
     * @type {string}
     * @memberof SappInfo
     */
    desc?: string;
    /**
     * 引用类型，默认为SappType.IFRAME
     *
     * @type {ESappType}
     * @memberof SappInfo
     */
    type?: ESappType;
    /**
     * 对于SappType.IFRAME应用，url为页面链接；
     * 对于SappType.ASYNC_LOAD应用，url为应用的script entry链接；
     *
     * @type {string}
     * @memberof SappInfo
     */
    url: string;
    /**
     * 对于SappType.ASYNC_LOAD应用，有时候一个简单的script entry链接可能是不够的，这个时候需要以的html来整合应用的entry信息；
     *
     * 注意：
     * 1：与SappInfo.url不能同时存在
     * 2：只对SappType.ASYNC_LOAD应用生效
     *
     * @type {string}
     * @memberof SappInfo
     *
     * @example
     * ``` ts
     * html:
     *   `
     *    <html>
     *        <script type="text/javascript" src="assets/a.js?\${version}" crossorigin></script>
     *        <script type="text/javascript" src="assets/b.js?\${version}" crossorigin></script>
     *    </html>
     *    `
     * ```
     */
    html?: string;
    /**
     * 其他option项
     *
     * @memberof SappInfo
     */
    options: {
        /**
         * 应用创建策略
         *
         * @type {ESappCreatePolicy}
         */
        create?: ESappCreatePolicy;
        /**
         * 应用隐藏生命管理策略
         *
         * @type {ESappLifePolicy}
         */
        life?: ESappLifePolicy;
        /**
         * 对于SappLifePolicy.AUTO模式下，应用可hide的最大时间，单位为毫秒
         *
         * @type {number}
         */
        lifeMaxHideTime?: number;
        /**
         * 在SappMGR.create应用时，先不要start应用；默认会自动start；
         * 刚字段可用于手动管理应用 创建和启动 两个生命周期阶段；
         *
         * @type {boolean}
         */
        dontStartOnCreate?: boolean;
        /**
         * 应用的布局配置
         *
         * @type {string}
         */
        layout?: string;
        /**
         * 应用是否是普通网页；如果应用是一个普通网页，则简单的以IFrame元素加载页面即可；应用和主应用之间没有权限校验，也没有API交互，纯粹展示页面；
         *
         * @type {boolean}
         */
        isPlainPage?: boolean;
        /**
         * 应用start时的timeout配置，默认为30s；当指定值<0时，则start永远不会超时；
         * start不需要超时的场景：
         * 1：比如应用里面需要登录，但是登录会是另一个页面；
         * 2：应用是一个多页面结构；
         *
         * @type {number}
         */
        startTimeout?: number;
        /**
         * 显式指定应用与主应用之间的通信ID；默认主应用会随机生成一个ID，并通过URL参数传递给从应用，但是当从应用内存在多页面跳转，则通过URL参数传递会失效，因此可以通过该字段显式指定通信ID
         *
         * @type {string}
         */
        useTerminalId?: string;
    };
}
/**
 * Sapp配置项，必须在sapp.start之前设置好
 *
 * @export
 * @interface SappConfig
 */
interface SappConfig {
    /**
     * 在start时，先隐藏应用；默认情况下，start会自动显式
     *
     * @type {boolean}
     * @memberof SappConfig
     */
    hideOnStart?: boolean;
    /**
     * start前置回调
     *
     * @param {Sapp} app
     * @returns {Promise<void>}
     * @memberof SappConfig
     */
    beforeStart?(app: Sapp): Promise<void>;
    /**
     * start生命周期阶段，data构造回调，SappSDK在onCreate回调中会拿到该数据
     *
     * @param {Sapp} app
     * @returns {(Promise<any> | any)}
     * @memberof SappConfig
     */
    resolveStartData?(app: Sapp): Promise<any> | any;
    /**
     * 用于在start中自动调用show时，传递的data；SappSDK在onShow回调中会拿到该数据
     *
     * @param {Sapp} app
     * @returns {(Promise<any> | any)}
     * @memberof SappConfig
     */
    resolveStartShowData?(app: Sapp): Promise<any> | any;
    /**
     * servkit底层配置构造API；构造Sapp向SappSDK中暴露的服务
     *
     * @param {Sapp} app
     * @returns {(Promise<ServServiceServerConfig> | ServServiceServerConfig)}
     * @memberof SappConfig
     */
    resolveServiceServerConfig?(app: Sapp): Promise<ServServiceServerConfig> | ServServiceServerConfig;
    /**
     * servkit底层配置构造API；暂无
     *
     * @param {Sapp} app
     * @returns {(Promise<ServServiceClientConfig> | ServServiceClientConfig)}
     * @memberof SappConfig
     */
    resolveServiceClientConfig?(app: Sapp): Promise<ServServiceClientConfig> | ServServiceClientConfig;
    /**
     * servkit底层配置构造API；构造会话配置
     *
     * @param {Sapp} app
     * @returns {(Promise<ServSessionConfig> | ServSessionConfig)}
     * @memberof SappConfig
     */
    resolveSessionConfig?(app: Sapp): Promise<ServSessionConfig> | ServSessionConfig;
    /**
     * servkit底层配置构造API；ServTerminal相关构造回调
     *
     * @param {Sapp} app
     * @param {ServTerminalConfig} config
     * @returns {(Promise<ServTerminalConfig> | ServTerminalConfig | void)}
     * @memberof SappConfig
     */
    resolveTerminalConfig?(app: Sapp, config: ServTerminalConfig): Promise<ServTerminalConfig> | ServTerminalConfig | void;
    /**
     * servkit底层配置构造API；Service ACL权限管理
     *
     * @param {Sapp} app
     * @returns {SappACLResolver}
     * @memberof SappConfig
     */
    resolveACLResolver?(app: Sapp): SappACLResolver;
    /**
     * start后置回调
     *
     * @param {Sapp} app
     * @returns {Promise<void>}
     * @memberof SappConfig
     */
    afterStart?(app: Sapp): Promise<void>;
    /**
     * 参见SappInfo.options.startTimeout
     *
     * @type {number}
     * @memberof SappConfig
     */
    startTimeout?: number;
    /**
     * 参见SappInfo.options.useTerminalId
     *
     * @type {string}
     * @memberof SappConfig
     */
    useTerminalId?: string;
}
/**
 * Sapp.start参数
 *
 * @export
 * @interface SappStartOptions
 */
interface SappStartOptions {
    /**
     * 参加SappConfig.resolveStartData
     *
     * @type {(any | SappConfig['resolveStartData'])}
     * @memberof SappStartOptions
     */
    data?: any | SappConfig['resolveStartData'];
    /**
     * 参加SappConfig.resolveStartShowData
     *
     * @type {(any | SappConfig['resolveStartShowData'])}
     * @memberof SappStartOptions
     */
    showData?: any | SappConfig['resolveStartShowData'];
}
/**
 * Sapp在Terminal中的扩展数据，该数据可以在needCallContext的service中拿到
 *
 * @export
 * @interface SappTerminalExtData
 */
interface SappTerminalExtData {
    app: Sapp;
    info: SappInfo;
}
/**
 * 基于Sapp机制的RPC API上下文
 *
 * @export
 * @interface SappAPICallContext
 * @extends {ServAPICallContext}
 */
interface SappAPICallContext extends ServAPICallContext {
    extData: SappTerminalExtData;
}
/**
 * 在主应用中，从应用抽象类；可通过Sapp实例操作从应用，并与从应用进行同行；
 *
 * Sapp主要提供：
 * 1：应用信息、生命周期状态
 * 2：生命周期操作API：start、show、hide、close
 * 3：服务通信
 *
 * 可通过SappController对Sapp做更多定制化控制
 *
 * @export
 * @class Sapp
 */
declare class Sapp {
    static transformContentByInfo(content: string, info: SappInfo): string;
    /**
     * 唯一ID
     *
     * @type {string}
     * @memberof Sapp
     */
    uuid: string;
    /**
     * 应用信息
     *
     * @type {SappInfo}
     * @memberof Sapp
     */
    info: SappInfo;
    /**
     * 应用是否已经成功start；
     * 注意：
     * 在start过程中isStarted仍然为false
     *
     * @type {boolean}
     * @memberof Sapp
     */
    isStarted: boolean;
    /**
     * 应用start deferred promise；
     *
     * @type {Deferred}
     * @memberof Sapp
     *
     * @example
     * ``` ts
     * app.started
     * .then(() => { ... })
     * .catch(() => { ... })
     * ```
     */
    started: Deferred;
    showDone?: Deferred<any>;
    /**
     * 应用是否已经关闭
     *
     * @type {boolean}
     * @memberof Sapp
     */
    isClosed: boolean;
    /**
     * 应用close deferred promise；只用应用创建后，就可通过该字段等待应用close事件；
     *
     * @type {Deferred<any>}
     * @memberof Sapp
     *
     * @example
     * ``` ts
     * // 应用启动
     * app.start();
     * // 等待应用close事件
     * app.closed.then(() => { ... });
     * ```
     */
    closed: Deferred<any>;
    /**
     * servkit底层通信terminal
     *
     * @type {ServTerminal}
     * @memberof Sapp
     */
    terminal: ServTerminal;
    /**
     * 应用关联Controller
     *
     * @protected
     * @type {SappController}
     * @memberof Sapp
     */
    protected controller?: SappController;
    protected config: SappConfig;
    protected waitOnStart?: Deferred;
    protected waitOnAuth?: Deferred;
    protected mutex: AsyncMutex;
    protected showHideMutex: AsyncMutex;
    /**
     * 应用关联Manager
     *
     * @protected
     * @type {SappMGR}
     * @memberof Sapp
     */
    protected manager: SappMGR;
    /**
     * 构造函数
     * @param {string} uuid 应用唯一ID
     * @param {SappInfo} info 应用信息
     * @param {SappMGR} manager 应用所属管理器
     * @memberof Sapp
     */
    constructor(uuid: string, info: SappInfo, manager: SappMGR);
    attachController(controller: SappController): boolean;
    detachController(): void;
    /**
     * 获取应用关联的Controller
     *
     * @returns
     * @memberof Sapp
     */
    getController(): SappController | undefined;
    setConfig(config: SappConfig): this;
    getConfig(): SappConfig;
    getServkit(): Servkit;
    /**
     * 启动应用；具有防重入处理，重复的调用会得到第一次调用返回的Promise对象
     *
     * @param {SappStartOptions} options
     * @memberof Sapp
     */
    start: ((options?: SappStartOptions | undefined) => Promise<void>) & {
        deferred: Deferred<void> | undefined;
    };
    /**
     * 获取应用类型
     *
     * @returns {ESappType}
     * @memberof Sapp
     */
    getAppType(): ESappType;
    /**
     * 显示应用，params.data会传递给SappSDK onShow回调
     *
     * @param {SappShowParams} [params]
     * @returns
     * @memberof Sapp
     */
    show(params?: SappShowParams$1): Promise<boolean>;
    /**
     * 隐藏应用，params.data会传递给SappSDK onHide回调
     *
     * @param {SappHideParams} [params]
     * @returns
     * @memberof Sapp
     */
    hide(params?: SappHideParams$1): Promise<boolean>;
    protected _show: ((params?: SappShowParams$1 | undefined, byCreate?: boolean | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    protected _hide: ((params?: SappHideParams$1 | undefined, byClose?: boolean | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    /**
     * 隐藏应用；具有防重入处理；result将会传递给SappSDK onClose回调；
     *
     * @param {SappCloseResult} result
     * @memberof Sapp
     */
    close: ((result?: SappCloseResult | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    /**
     * 获取从应用提供的Service，同步版本
     *
     * @type {ServServiceClient['getService']}
     * @memberof Sapp
     * @example
     * ``` ts
     * // 获取单个服务
     * const serv = app.getService(CommServiceDecl);
     * if (serv) {
     *     serv.func();
     * }
     *
     * or
     *
     * // 同时获取多个服务
     * const { serv } = app.getService({ serv: CommServiceDecl });
     * if (serv) {
     *     serv.func();
     * }
     * ```
     */
    getService: ServServiceClient['getService'];
    /**
     * 获取从应用提供的Service，与getService区别在于，返回值没有保证是否为undefined
     *
     * @type {ServServiceClient['getServiceUnsafe']}
     * @memberof Sapp
     *
     * @example
     * ``` ts
     * const serv = app.getServiceUnsafe(CommServiceDecl);
     * serv.func(); // 没有 undefined 错误提示
     * ```
     */
    getServiceUnsafe: ServServiceClient['getServiceUnsafe'];
    /**
     * 获取从应用提供的Service，异步版本
     *
     * @type {ServServiceClient['service']}
     * @memberof Sapp
     *
     * @example
     * ``` ts
     * const serv = await app.service(CommServiceDecl);
     * ```
     */
    service: ServServiceClient['service'];
    /**
     * 获取从应用提供的Service，回调版本
     *
     * @type {ServServiceClient['serviceExec']}
     * @memberof Sapp
     *
     * @example
     * ``` ts
     * app.serviceExec(CommServiceDecl, (serv) => {
     *     serv.func();
     * });
     * ```
     */
    serviceExec: ServServiceClient['serviceExec'];
    /**
     * 获取主应用向从应用提供的服务
     *
     * @type {ServServiceServer['getService']}
     * @memberof Sapp
     */
    getServerService: ServServiceServer['getService'];
    /**
     * 获取主应用向从应用提供的服务
     *
     * @type {ServServiceServer['getServiceUnsafe']}
     * @memberof Sapp
     */
    getServerServiceUnsafe: ServServiceServer['getServiceUnsafe'];
    /**
     * 获取主应用向从应用提供的服务
     *
     * @type {ServServiceServer['service']}
     * @memberof Sapp
     */
    serverService: ServServiceServer['service'];
    /**
     * 获取主应用向从应用提供的服务
     *
     * @type {ServServiceServer['serviceExec']}
     * @memberof Sapp
     */
    serverServiceExec: ServServiceServer['serviceExec'];
    protected auth(params: SappAuthParams): Promise<void>;
    protected beforeStart(options: SappStartOptions): Promise<void>;
    protected afterStart(): Promise<void>;
    protected onStartFailed(): void;
    protected resolveStartData(options: SappStartOptions): Promise<any>;
    protected resolveStartShowData(options: SappStartOptions): Promise<any>;
    protected beforeInitTerminal(): Promise<void>;
    protected initTerminal(options: SappStartOptions): Promise<void>;
    protected afterInitTerminal(): Promise<void>;
    /**
     * servkit底层API，获取terminal id
     *
     * @returns
     * @memberof Sapp
     */
    getTerminalId(): string;
}

interface SappHostOnCloseResult {
    dontClose?: boolean;
}

interface SappHostInfo {
    id: string;
    token: string;
    [property: string]: any;
}

declare type SappHostOnCloseHandle = (app: SappHostPage) => Promise<SappHostOnCloseResult>;
declare class SappHostPage extends Sapp {
    static APP_ID: string;
    static isInHostEnv(): boolean;
    hostInfo: SappHostInfo;
    protected _onCloseHandle?: SappHostOnCloseHandle;
    protected _onCloseHandles?: {
        [key: string]: SappHostOnCloseHandle;
    };
    /**
     * 启动应用
     *
     * @memberof SappHostPage
     */
    start: ((options?: SappStartOptions | undefined) => Promise<void>) & {
        deferred: Deferred<void> | undefined;
    };
    show(params?: SappShowParams$1): Promise<never>;
    hide(params?: SappHideParams$1): Promise<never>;
    /**
     * 关闭应用
     *
     * @memberof SappHostPage
     */
    close: (() => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    protected onClose(): Promise<SappHostOnCloseResult>;
    /**
     * 获取host页面提供的数据
     *
     * @param {*} [params]
     * @returns
     * @memberof SappHostPage
     */
    getHostData(params?: any): Promise<any>;
    private _close;
    protected initTerminal(options: SappStartOptions): Promise<void>;
    protected checkAuth(): Promise<void>;
    /**
     * 设置onClose处理函数；
     * 可通过key设置匹配host页面的处理函数，key为host页面id，在hostInfo中提供；
     * 如果没有提供key，将设置全局的onClose处理函数。
     *
     * @param {SappHostOnCloseHandle} handle
     * @param {string} [key]
     * @memberof SappHostPage
     */
    setOnCloseHandle(handle: SappHostOnCloseHandle, key?: string): void;
    /**
     * 获取onClose处理函数；
     * 可通过key获取匹配host页面的处理函数，key为host页面id，在hostInfo中提供；
     * 如果没有提供key，将获取到全局的onClose处理函数。
     *
     * @param {string} [key]
     * @returns
     * @memberof SappHostPage
     */
    getOnCloseHandle(key?: string): SappHostOnCloseHandle | undefined;
}

/**
 * Sapp布局配置项
 *
 * @export
 * @class SappLayoutOptions
 *
 * @example
 * ``` ts
 * // layout管理容器元素
 * const container = document.createElement('div');
 * // some code to config container class and style
 * ...
 * // 实际的layout options
 * const layout = {
 *     container,
 *     onStart: () => { document.body.appendChild(container); },
 *     onClose: () => { document.body.removeChild(container); }
 * };
 *
 * ```
 */
declare class SappLayoutOptions {
    /**
     * 应用容器元素；如果是一个string，则是元素的选择器
     *
     * @type {(string | HTMLElement)}
     * @memberof SappLayoutOptions
     */
    container?: string | HTMLElement;
    /**
     * iframe节点class；只对ESappType.IFRAME有效
     *
     * @type {string}
     * @memberof SappLayoutOptions
     */
    className?: string;
    /**
     * iframe节点style；只对ESappType.IFRAME有效
     *
     * @type {string}
     * @memberof SappLayoutOptions
     */
    style?: Partial<HTMLElement['style']>;
    /**
     * 应用start回调，对于布局而言，可以在这里将容器元素真正的append到document上
     *
     * @memberof SappLayoutOptions
     */
    doStart?: ((app: Sapp) => void);
    /**
     * 应用show回调，对于布局而言，可以在这里将容器元素真正的显示可见
     *
     * @memberof SappLayoutOptions
     */
    doShow?: ((app: Sapp) => void);
    /**
     * 应用show回调，对于布局而言，可以在这里将容器元素真正的隐藏
     *
     * @memberof SappLayoutOptions
     */
    doHide?: ((app: Sapp) => void);
    /**
     * 应用close回调，对于布局而言，可以在这里将容器元素真正的从document移除
     *
     * @memberof SappLayoutOptions
     */
    doClose?: ((app: Sapp) => void);
    /**
     * 容器元素显示时的class
     *
     * @type {string}
     * @memberof SappLayoutOptions
     */
    showClassName?: string;
    /**
     * 容器元素显示时的style
     *
     * @type {Partial<HTMLElement['style']>}
     * @memberof SappLayoutOptions
     */
    showStyle?: Partial<HTMLElement['style']>;
    /**
     * 容器元素隐藏时的class
     *
     * @type {string}
     * @memberof SappLayoutOptions
     */
    hideClassName?: string;
    /**
     * 容器元素隐藏时的style
     *
     * @type {Partial<HTMLElement['style']>}
     * @memberof SappLayoutOptions
     */
    hideStyle?: Partial<HTMLElement['style']>;
}
/**
 * SappMGR createHost参数
 */
interface SappHostCreateOptions {
    /**
     * create时不要自动启动应用；即不要调用Sapp.start
     *
     * @type {boolean}
     * @memberof SappHostCreateOptions
     */
    dontStartOnCreate?: boolean;
    /**
     * 应用Controller创建回调；默认会自动创建一个Default Controller
     *
     * @param {SappMGR} mgr
     * @param {Sapp} app
     * @returns {SappController}
     * @memberof SappHostCreateOptions
     */
    createAppController?(mgr: SappMGR, app: Sapp): SappController;
    /**
     * 应用 Service ACL 权限管理创建回调；默认无ACL权限管理
     *
     * @param {Sapp} app
     * @returns {SappACLResolver}
     * @memberof SappHostCreateOptions
     */
    createACLResolver?(app: Sapp): SappACLResolver;
    /**
     * 配置主应用向从应用提供的服务
     *
     * @type {ServServiceConfig['services']}
     * @memberof SappHostCreateOptions
     */
    services?: ServServiceConfig['services'];
    /**
     * 配置主应用向从应用提供的引用型服务；引用型服务由Global Service Manager提供；
     *
     * @type {ServServiceReferPattern}
     * @memberof SappHostCreateOptions
     */
    serviceRefer?: ServServiceReferPattern;
    /**
     * Host应用在关闭前的拦截函数，在这里面可以进行完成：
     * 1：关闭处理逻辑
     * 2：或者打断关闭逻辑，通过返回值 SappHostOnCloseResult.dontClose 进行控制
     *
     * @type {SappHostOnCloseHandle}
     * @memberof SappHostCreateOptions
     */
    onCloseHandle?: SappHostOnCloseHandle;
}
/**
 * SappMGR create参数
 *
 * @export
 * @interface SappCreateOptions
 */
interface SappCreateOptions {
    /**
     * create时不要自动启动应用；即不要调用Sapp.start
     *
     * @type {boolean}
     * @memberof SappCreateOptions
     */
    dontStartOnCreate?: boolean;
    /**
     * 应用Controller创建回调；默认会自动创建一个Default Controller
     *
     * @param {SappMGR} mgr
     * @param {Sapp} app
     * @returns {SappController}
     * @memberof SappCreateOptions
     */
    createAppController?(mgr: SappMGR, app: Sapp): SappController;
    /**
     * 应用 Service ACL 权限管理创建回调；默认无ACL权限管理
     *
     * @param {Sapp} app
     * @returns {SappACLResolver}
     * @memberof SappCreateOptions
     */
    createACLResolver?(app: Sapp): SappACLResolver;
    /**
     * 应用布局配置
     *
     * @memberof SappCreateOptions
     */
    layout?: SappLayoutOptions | ((app: Sapp) => SappLayoutOptions);
    /**
     * 应用启动传递到SappSDK的数据，参见SappConfig.resolveStartData
     *
     * @memberof SappCreateOptions
     */
    startData?: any | ((app: Sapp) => any);
    /**
     * 应用显示传递到SappSDK的数据，参见SappConfig.resolveStartShowData
     *
     * @memberof SappCreateOptions
     */
    startShowData?: any | ((app: Sapp) => any);
    /**
     * 配置主应用向从应用提供的服务
     *
     * @type {ServServiceConfig['services']}
     * @memberof SappCreateOptions
     */
    services?: ServServiceConfig['services'];
    /**
     * 配置主应用向从应用提供的引用型服务；引用型服务由Global Service Manager提供；
     *
     * @type {ServServiceReferPattern}
     * @memberof SappCreateOptions
     */
    serviceRefer?: ServServiceReferPattern;
    /**
     * start超时配置，参见SappConfig.startTimeout
     *
     * @type {number}
     * @memberof SappCreateOptions
     */
    startTimeout?: number;
    /**
     * 主从应用通信配对ID，参见SappConfig.useTerminalId
     *
     * @type {string}
     * @memberof SappCreateOptions
     */
    useTerminalId?: string;
}
/**
 * SappMGR 配置
 *
 * @export
 * @interface SappMGRConfig
 */
interface SappMGRConfig {
    /**
     * SappMGR对应使用的servkit；默认使用全局servkit
     *
     * @type {Servkit}
     * @memberof SappMGRConfig
     */
    servkit?: Servkit;
    /**
     * 通用的 Sapp Controler 构造函数
     *
     * @param {SappMGR} mgr
     * @param {Sapp} app
     * @returns {SappController}
     * @memberof SappMGRConfig
     */
    createAppController?(mgr: SappMGR, app: Sapp): SappController;
    /**
     * 通用的 Sapp Service ACL 权限管理构造函数
     *
     * @param {Sapp} app
     * @returns {SappACLResolver}
     * @memberof SappMGRConfig
     */
    createACLResolver?(app: Sapp): SappACLResolver;
    /**
     * SappInfo加载函数
     *
     * @param {SappMGR} mgr
     * @param {string} id
     * @returns {(Promise<SappInfo | undefined>)}
     * @memberof SappMGRConfig
     */
    loadAppInfo?(mgr: SappMGR, id: string): Promise<SappInfo | undefined>;
}
/**
 * 应用管理器，主要提供了：
 * 1：Sapp管理
 * 2：全局服务管理
 *
 * @export
 * @class SappMGR
 */
declare class SappMGR {
    protected infos: {
        [key: string]: SappInfo;
    };
    protected apps: {
        [key: string]: Sapp[];
    };
    protected config: SappMGRConfig;
    protected hostApp?: SappHostPage;
    private _hostAppStarted?;
    private _hostAppClosed?;
    /**
     * hostApp started deferred，可通过该deferred监测hostApp启动时机
     *
     * @readonly
     * @memberof SappMGR
     */
    get hostAppStarted(): Deferred<void>;
    /**
     * hostApp closed deferred，可通过该deferred监测hostApp关闭时机
     *
     * @readonly
     * @memberof SappMGR
     */
    get hostAppClosed(): Deferred<void>;
    constructor();
    setConfig(config: SappMGRConfig): this;
    getConfig(): SappMGRConfig;
    getServkit(): Servkit;
    /**
     * 获取全局服务，参见Sapp.getService
     *
     * @type {ServGlobalServiceManager['getService']}
     * @memberof SappMGR
     */
    getService: ServGlobalServiceManager['getService'];
    /**
     * 获取全局服务，参见Sapp.getServiceUnsafe
     *
     * @type {ServGlobalServiceManager['getServiceUnsafe']}
     * @memberof SappMGR
     */
    getServiceUnsafe: ServGlobalServiceManager['getServiceUnsafe'];
    /**
     * 获取全局服务，参见Sapp.service
     *
     * @type {ServGlobalServiceManager['service']}
     * @memberof SappMGR
     */
    service: ServGlobalServiceManager['service'];
    /**
     * 获取全局服务，参见Sapp.serviceExec
     *
     * @type {ServGlobalServiceManager['serviceExec']}
     * @memberof SappMGR
     */
    serviceExec: ServGlobalServiceManager['serviceExec'];
    /**
     * 添加服务到全局服务中，全局服务可以被任意从应用使用
     *
     * @type {ServGlobalServiceManager['addServices']}
     * @memberof SappMGR
     */
    addServices: ServGlobalServiceManager['addServices'];
    /**
     * 移除全局服务
     *
     * @type {ServGlobalServiceManager['remServices']}
     * @memberof SappMGR
     */
    remServices: ServGlobalServiceManager['remServices'];
    /**
     * 根据id获取Sapp实例
     *
     * @param {string} id
     * @returns
     * @memberof SappMGR
     */
    getApp(id: string): Sapp;
    /**
     * 根据id获取所有的Sapp实例
     *
     * @param {string} id
     * @returns
     * @memberof SappMGR
     */
    getApps(id: string): Sapp[];
    /**
     * 根据id获取SappInfo
     *
     * @param {string} id
     * @returns
     * @memberof SappMGR
     */
    getAppInfo(id: string): SappInfo;
    /**
     * 添加SappInfo到管理器中
     *
     * @param {SappInfo} info
     * @returns {(SappInfo | undefined)}
     * @memberof SappMGR
     */
    addAppInfo(info: SappInfo): SappInfo | undefined;
    /**
     * 根据id移除SappInfo
     *
     * @param {string} id
     * @returns
     * @memberof SappMGR
     */
    remAppInfo(id: string): SappInfo;
    /**
     * 根据id获取SappInfo，如果SappMGR.getAppInfo不能获取，则尝试通过SappConfig.loadAppInfo进行加载
     *
     * @param {string} id
     * @returns {(Promise<SappInfo | undefined>)}
     * @memberof SappMGR
     */
    loadAppInfo(id: string): Promise<SappInfo | undefined>;
    /**
     * 预加载一个应用，只有SappType.ASYNC_LOAD应用才能够预加载
     *
     * @param {(string | SappInfo)} id
     * @returns {Promise<boolean>}
     * @memberof SappMGR
     */
    preload(id: string | SappInfo): Promise<boolean>;
    /**
     * 创建host应用，host应用是host页面的抽象，可通过host应用与host页面进行交互通信；
     * host应用将在host页面中以IFrame方式嵌入。
     *
     * @param {SappHostCreateOptions} [options]
     * @returns SappHostPage
     * @memberof SappMGR
     */
    createHost(options?: SappHostCreateOptions): SappHostPage | undefined;
    /**
     * 获取host应用
     *
     * @returns {(SappHostPage | undefined)}
     * @memberof SappMGR
     */
    getHost(): SappHostPage | undefined;
    /**
     * 关闭host应用
     *
     * @returns
     * @memberof SappMGR
     */
    closeHost(): Promise<boolean> | undefined;
    /**
     * 返回是否在host页面环境
     *
     * @returns boolean
     * @memberof SappMGR
     */
    isInHostEnv(): boolean;
    /**
     * 返回host应用是否已经连接到host页面
     *
     * @returns
     * @memberof SappMGR
     */
    isHostConnected(): boolean | undefined;
    /**
     * 根据id或者info创建一个应用；默认应用会自动start，可通过options.dontStartOnCreate控制是否自动start应用
     *
     * @param {(string | SappInfo)} id
     * @param {SappCreateOptions} [options]
     * @returns {Promise<Sapp>}
     * @memberof SappMGR
     */
    create(id: string | SappInfo, options?: SappCreateOptions): Promise<Sapp>;
    /**
     * 根据id显示应用
     *
     * @param {string} id
     * @param {SappShowParams} [params]
     * @returns {Promise<Sapp>}
     * @memberof SappMGR
     */
    show(id: string, params?: SappShowParams$1): Promise<Sapp>;
    /**
     * 根据id隐藏应用
     *
     * @param {string} id
     * @param {SappHideParams} [params]
     * @returns {Promise<Sapp>}
     * @memberof SappMGR
     */
    hide(id: string, params?: SappHideParams$1): Promise<Sapp>;
    /**
     * 根据id关闭应用
     *
     * @param {string} id
     * @param {SappCloseResult} [result]
     * @returns {Promise<Sapp>}
     * @memberof SappMGR
     */
    close(id: string, result?: SappCloseResult): Promise<Sapp>;
    /**
     * 根据id创建或者显示应用；如果应用不存在则创建应用，如果应用已经存在则隐藏应用
     *
     * @param {string} id
     * @param {SappCreateOptions} [options]
     * @returns {Promise<Sapp>}
     * @memberof SappMGR
     */
    createOrShow(id: string, options?: SappCreateOptions): Promise<Sapp>;
    protected addApp(app: Sapp): boolean;
    protected remApp(app: Sapp): boolean;
    protected nextAppUuid(info: SappInfo, options?: SappCreateOptions): string;
    protected createApp(uuid: string, info: SappInfo, options: SappCreateOptions): Sapp;
    protected createAppController(app: Sapp, options: SappCreateOptions): SappController;
    protected createDefaultAppController(app: Sapp): SappController;
    /**
     * 创建SappMGR实例
     *
     * @static
     * @param {SappMGRConfig} [config={}]
     * @returns {SappMGR}
     * @memberof SappMGR
     */
    static create(config: SappMGRConfig): SappMGR;
}
/**
 * 全局SappMGR实例
 */
declare const sappMGR: SappMGR;

interface SappSDKMockConfig {
    hideOnStart?: boolean;
    services?: ServServiceConfig['services'];
    serviceRefer?: ServServiceReferPattern;
    beforeStart?(): Promise<void>;
    resolveStartData?(): Promise<any> | any;
    resolveStartShowData?(): Promise<any> | any;
    resolveServiceServerConfig?(): Promise<ServServiceServerConfig> | ServServiceServerConfig;
    resolveServiceClientConfig?(): Promise<ServServiceClientConfig> | ServServiceClientConfig;
    resolveAsyncLoadLayout?(): Promise<SappLayoutOptions> | SappLayoutOptions;
    afterStart?(): Promise<void>;
}
declare class SappSDKMock {
    static ENABLE_MARK: string;
    static isMockEnabled(): boolean;
    static tryAsynLoadBootstrap(appId: string): void;
    protected sdk: SappSDK;
    protected isStarted: boolean;
    protected config: SappSDKMockConfig;
    protected terminal: ServTerminal;
    protected mutex: AsyncMutex;
    protected showHideMutex: AsyncMutex;
    protected waitOnStart?: Deferred;
    constructor(sdk: SappSDK);
    setConfig(config: SappSDKMockConfig): this;
    getConfig(): SappSDKMockConfig;
    start(): Promise<void>;
    protected initTerminal(): Promise<void>;
    fixSlaveTerminalConfig(config: ServTerminalConfig): void;
    protected resolveStartData(): Promise<any>;
    protected resolveStartShowData(): Promise<any>;
    show(params?: SappShowParams$1): Promise<boolean>;
    hide(params?: SappHideParams$1): Promise<boolean>;
    protected _show: ((params?: SappShowParams$1 | undefined, byCreate?: boolean | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    protected _hide: ((params?: SappHideParams$1 | undefined, byClose?: boolean | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    close: ((result?: SappCloseResult | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    getService: ServServiceClient['getService'];
    getServiceUnsafe: ServServiceClient['getServiceUnsafe'];
    service: ServServiceClient['service'];
    serviceExec: ServServiceClient['serviceExec'];
    getServerService: ServServiceServer['getService'];
    getServerServiceUnsafe: ServServiceServer['getServiceUnsafe'];
    serverService: ServServiceServer['service'];
    serverServiceExec: ServServiceServer['serviceExec'];
    protected beforeStart(): Promise<void>;
    protected afterStart(): Promise<void>;
    protected onSessionBroken(): void;
    protected prepareForAsyncLoad(): Promise<void>;
}

/**
 * SappSDK启动参数
 */
interface SappSDKStartParams {
    uuid?: string;
}
/**
 * SappSDK生命周期事件
 *
 * @export
 * @enum {number}
 */
declare enum ESappSDKLifeCycleEvent {
    BEFORE_START = "BEFORE_START",
    ON_CREATE = "ON_CREATE",
    ON_SHOW = "ON_SHOW",
    ON_HIDE = "ON_HIDE",
    ON_CLOSE = "ON_CLOSE",
    AFTER_START = "AFTER_START"
}
/**
 * 对于SappType.ASYNC_LOAD应用的启动参数
 *
 * @export
 * @interface SappSDKAsyncLoadStartParams
 * @extends {SappSDKStartParams}
 */
interface SappSDKAsyncLoadStartParams extends SappSDKStartParams {
    /**
     * 应用容器元素
     *
     * @type {HTMLElement}
     * @memberof SappSDKAsyncLoadStartParams
     */
    container?: HTMLElement;
}
/**
 * SappType.ASYNC_LOAD应用boostrap声明参数
 *
 * @export
 * @interface SappSDKAsyncLoadDeclParams
 */
interface SappSDKAsyncLoadDeclParams {
    /**
     * 应用启动方法；在主应用Sapp.start中会被调用；
     * 对于SappType.ASYNC_LOAD应该显式的分为 加载 和 启动 两个阶段，否则将不能使用预加载功能；
     *
     * @memberof SappSDKAsyncLoadDeclParams
     */
    bootstrap: (sdk: SappAsyncLoadSDK) => void;
    /**
     * 应用退出方法；在主应用Sapp.close中会被调用；
     *
     * @memberof SappSDKAsyncLoadDeclParams
     */
    deBootstrap?: (sdk: SappAsyncLoadSDK) => void;
}
interface SappSDKAsyncLoadDeclContext {
    bootstrap: () => void;
    deBootstrap: () => void;
}
/**
 * SappSDK配置
 */
interface SappSDKConfig {
    /**
     * SappSDK底层Servkit，默认使用全局的servkit
     */
    servkit?: Servkit;
    /**
     * 通信的terminal id；SappSDK仍然采用的是ServTerminal作为双端通信，该双端通信基于一个id进行匹配
     *
     * @type {string}
     * @memberof SappSDKConfig
     */
    useTerminalId?: string;
    /**
     * SappSDK权限认证信息
     *
     * @memberof SappSDKConfig
     */
    authInfo?: SappAuthParams | ((sdk: SappSDK) => SappAuthParams | Promise<SappAuthParams>);
    /**
     * SappSDK.start() 前置回调
     * @param sdk
     */
    beforeStart?(sdk: SappSDK): Promise<void>;
    /**
     * SappSDK启动参数的构造回调；
     * 优先使用SappSDKStartOptions.params，其次SappSDKConfig.resolveStartParams，默认使用parseQueryParams；
     * parseQueryParams将会从window.location.href中解析query参数
     * @param sdk
     */
    resolveStartParams?(sdk: SappSDK): Promise<SappSDKStartParams> | SappSDKStartParams;
    /**
     * ServiceServerConfig的构造回调
     * @param sdk
     */
    resolveServiceServerConfig?(sdk: SappSDK): Promise<ServServiceServerConfig> | ServServiceServerConfig;
    /**
     * ServiceClientConfig的构造回调
     * @param sdk
     */
    resolveServiceClientConfig?(sdk: SappSDK): Promise<ServServiceClientConfig> | ServServiceClientConfig;
    /**
     * SessionConfig的构造回调
     * @param sdk
     */
    resolveSessionConfig?(sdk: SappSDK): Promise<ServSessionConfig> | ServSessionConfig;
    /**
     * 在SappSDK中使用ServTerminal作为服务通信的桥接，ServTerminalConfig会通过该回调做最终的config调整
     * @param sdk
     * @param config
     */
    resolveTerminalConfig?(sdk: SappSDK, config: ServTerminalConfig): Promise<ServTerminalConfig> | ServTerminalConfig | void;
    /**
     * SappSDK.start() 后置回调
     * @param sdk
     */
    afterStart?(sdk: SappSDK): Promise<void>;
    /**
     * 生命周期回调，应用创建时回调
     *
     * @param {SappSDK} sdk
     * @returns {Promise<void>}
     * @memberof SappSDKConfig
     */
    onCreate?(sdk: SappSDK, params: SappSDKStartParams, data?: any): Promise<void>;
    /**
     * 生命周期回调，应用显示时回调
     *
     * @param {SappSDK} sdk
     * @returns {Promise<SappOnShowResult | void>}
     * @memberof SappSDKConfig
     */
    onShow?(sdk: SappSDK, params: SappShowParams): Promise<SappOnShowResult | void> | void;
    /**
     * 生命周期回调，应用隐藏时回调
     *
     * @param {SappSDK} sdk
     * @returns {Promise<SappOnHideResult | void>}
     * @memberof SappSDKConfig
     */
    onHide?(sdk: SappSDK, params: SappHideParams): Promise<SappOnHideResult | void> | void;
    /**
     * 生命周期回调，应用关闭时回调
     *
     * @param {SappSDK} sdk
     * @returns {Promise<SappOnCloseResult | void>}
     * @memberof SappSDKConfig
     */
    onClose?(sdk: SappSDK): Promise<SappOnCloseResult | void> | void;
    /**
     * SappSDK的mock配置，通过该配置，SappSDK应用可脱离主应用调试开发；
     * 通过window.__$servkit.enableSappSDKMock()或者链接添加__SAPPSDK_MOCK_ENABLE__打开开关才能生效；
     *
     * @type {SappSDKMockConfig}
     * @memberof SappSDKConfig
     */
    mock?: SappSDKMockConfig;
    /**
     * 从应用向主应用提供的服务
     *
     * @type {ServServiceConfig['services']}
     * @memberof SappSDKConfig
     */
    services?: ServServiceConfig['services'];
    /**
     * 从应用向主应用提供的服务，通过引用全局服务进行提供；
     *
     * @type {ServServiceReferPattern}
     * @memberof SappSDKConfig
     */
    serviceRefer?: ServServiceReferPattern;
}
/**
 * SappSDK start参数项
 */
interface SappSDKStartOptions {
    params?: SappSDKStartParams | SappSDKConfig['resolveStartParams'];
}
/**
 * SappSDK是从应用与主应用交互的桥梁，也是从应用自身的抽象；
 * 主要提供了：
 * 1：自身生命周期管理
 * 2：与主应用的交互接口，获取服务API
 *
 * @export
 * @class SappSDK
 * @extends {EventEmitter}
 */
declare class SappSDK extends EventEmitter {
    /**
     * SDK是否已经初始化
     *
     * @type {boolean}
     * @memberof SappSDK
     */
    isStarted: boolean;
    /**
     * SDK start deffered Promise；在业务层面可以使用sappSDK.started去等待SDK的初始化（也可以直接使用SappSDK.start()这种形式）
     *
     * @type {Deferred}
     * @memberof SappSDK
     */
    started: Deferred;
    /**
     * 内部服务通信桥梁，建议不要直接使用
     *
     * @type {ServTerminal}
     * @memberof SappSDK
     */
    terminal: ServTerminal;
    /**
     * SDK mock
     *
     * @type {SappSDKMock}
     * @memberof SappSDK
     */
    sdkMock: SappSDKMock;
    protected config: SappSDKConfig;
    constructor();
    /**
     * SappSDK的全局配置，需要在start之前设定好
     *
     * @param {SappSDKConfig} config
     * @returns this
     * @memberof SappSDK
     */
    setConfig(config: SappSDKConfig): this;
    /**
     * 获取全局配置
     *
     * @returns
     * @memberof SappSDK
     */
    getConfig(): SappSDKConfig;
    /**
     * 获取SappSDK使用的servkit
     *
     * @returns
     * @memberof SappSDK
     */
    getServkit(): Servkit;
    /**
     * 启动SDK；具有防重入处理；会触发onCreate回调
     *
     * @param {SappSDKStartOptions} [options]
     * @returns {Promise<void>}
     * @memberof SappSDK
     */
    start: ((options?: SappSDKStartOptions | undefined) => Promise<void>) & {
        deferred: Deferred<void> | undefined;
    };
    /**
     * 显式，会触发onShow回调
     *
     * @param {ShowParams} [params]
     * @returns
     * @memberof SappSDK
     */
    show(params?: SappShowParams$1): Promise<boolean>;
    /**
     * 隐藏，会触发onHide回调
     *
     * @param {HideParams} [params]
     * @returns
     * @memberof SappSDK
     */
    hide(params?: SappHideParams$1): Promise<boolean>;
    close(): Promise<boolean>;
    /**
     * 获取主应用提供的Service，同步版本
     *
     * @type {ServServiceClient['getService']}
     * @memberof SappSDK
     *
     * @example
     * ``` ts
     * // 获取单个服务
     * const serv = app.getService(CommServiceDecl);
     * if (serv) {
     *     serv.func();
     * }
     *
     * or
     *
     * // 同时获取多个服务
     * const { serv } = app.getService({ serv: CommServiceDecl });
     * if (serv) {
     *     serv.func();
     * }
     * ```
     */
    getService: ServServiceClient['getService'];
    /**
     * 获取从应用提供的Service，与getService区别在于，返回值没有保证是否为undefined
     *
     * @type {ServServiceClient['getServiceUnsafe']}
     * @memberof SappSDK
     *
     * @example
     * ``` ts
     * const serv = app.getServiceUnsafe(CommServiceDecl);
     * serv.func(); // 没有 undefined 错误提示
     * ```
     */
    getServiceUnsafe: ServServiceClient['getServiceUnsafe'];
    /**
     * 获取从应用提供的Service，异步版本
     *
     * @type {ServServiceClient['service']}
     * @memberof SappSDK
     *
     * @example
     * ``` ts
     * const serv = await app.service(CommServiceDecl);
     * ```
     */
    service: ServServiceClient['service'];
    /**
     * 获取从应用提供的Service，回调版本
     *
     * @type {ServServiceClient['serviceExec']}
     * @memberof SappSDK
     *
     * @example
     * ``` ts
     * app.serviceExec(CommServiceDecl, (serv) => {
     *     serv.func();
     * });
     */
    serviceExec: ServServiceClient['serviceExec'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['getService']}
     * @memberof SappSDK
     */
    getServerService: ServServiceServer['getService'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['getServiceUnsafe']}
     * @memberof SappSDK
     */
    getServerServiceUnsafe: ServServiceServer['getServiceUnsafe'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['service']}
     * @memberof SappSDK
     */
    serverService: ServServiceServer['service'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['serviceExec']}
     * @memberof SappSDK
     */
    serverServiceExec: ServServiceServer['serviceExec'];
    protected beforeStart(options: SappSDKStartOptions): Promise<void>;
    protected afterStart(): Promise<void>;
    protected onStartFailed(): void;
    protected resolveStartParams(options: SappSDKStartOptions): Promise<SappSDKStartParams>;
    protected beforeInitTerminal(): Promise<void>;
    protected initTerminal(options: SappSDKStartOptions, params: SappSDKStartParams): Promise<void>;
    protected afterInitTerminal(): Promise<void>;
    protected initSDK(): Promise<void>;
    protected initSDKMock(): Promise<void>;
    protected onCreate(params: SappSDKStartParams, data: any): Promise<void>;
    protected onShow(params: SappShowParams): Promise<void | SappOnShowResult>;
    protected onHide(params: SappHideParams): Promise<void | SappOnHideResult>;
    protected onClose(): Promise<void | SappOnCloseResult>;
    /**
     * 获取应用类型
     *
     * @returns {ESappType}
     * @memberof SappSDK
     */
    getAppType(): ESappType;
    getDefaultStartParams(): SappSDKStartParams | undefined;
    /**
     * 项目SappMGR中声明一个SappType.ASYNC_LOADD应用；必须在从应用加载阶段声明
     *
     * @static
     * @param {string} appId
     * @param {SappSDKAsyncLoadDeclParams} params
     * @memberof SappSDK
     *
     * @example
     * ``` ts
     * SappSDK.declAsyncLoad('com.servkit.example', {
     *     bootstrap: (sdk) => {
     *         sdk.setConfig({
     *             onCreate: () => { ... },
     *             onClose: () => { ... },
     *         });
     *         sdk.start();
     *     },
     * };
     * ```
     */
    static declAsyncLoad(appId: string, params: SappSDKAsyncLoadDeclParams): void;
    destroy(): void;
}
/**
 * SappType.ASYNC_LOAD应用的SDK
 *
 * @export
 * @class SappAsyncLoadSDK
 * @extends {SappSDK}
 */
declare class SappAsyncLoadSDK extends SappSDK {
    protected appId: string;
    constructor(appId: string);
    getAppId(): string;
    getAppType(): ESappType;
    getDefaultStartParams(): SappSDKAsyncLoadStartParams | undefined;
}
/**
 * 全局SappSDK
 */
declare const sappSDK: SappSDK;

declare function putSharedParams(servkit: Servkit, key: string, params: any): void;
declare function getSharedParams<T = any>(servkit: Servkit, key: string): T | undefined;
declare function delSharedParams(servkit: Servkit, key: string): void;
declare function popSharedParams<T = any>(servkit: Servkit, key: string): T | undefined;
declare function putAsyncLoadStartParams(appId: string, params: SappSDKAsyncLoadStartParams): void;
declare function getAsyncLoadStartParams(appId: string): SappSDKAsyncLoadStartParams | undefined;
declare function delAsyncLoadStartParams(appId: string): void;
declare function putAsyncLoadDeclContext(appId: string, context: SappSDKAsyncLoadDeclContext): void;
declare function getAsyncLoadDeclContext(appId: string): SappSDKAsyncLoadDeclContext | undefined;
declare function delAsyncLoadDeclContext(appId: string): void;
/**
 * 注册全局对象，只在Async Load应用中可用
 *
 * @export
 * @param {*} val 全局对象
 * @param {string} name 全局对象名称
 * @param {string} [appId] 应用id
 * @returns
 */
declare function putAsyncLoadGlobal(name: string, val: any, appId?: string): void;
/**
 * 获取全局对象，只在Async Load应用中可用
 *
 * @export
 * @template T
 * @param {string} name
 * @param {string} [appId]
 * @returns
 */
declare function getAsyncLoadGlobal<T = any>(name: string, appId?: string): T | undefined;
/**
 * 删除全局对象，只在Async Load应用中可用
 *
 * @export
 * @param {string} name
 * @param {string} [appId]
 * @returns
 */
declare function delAsyncLoadGlobal(name: string, appId?: string): void;

declare enum EServIFrameShowPolicy {
    NULL = 0,
    HIDE = 1,
    SHOW = 2,
    SHOW_ON_ECHO = 3
}
interface ServIFrameWindowInfo {
    container: HTMLElement;
    element: HTMLIFrameElement;
    target: Window;
    origin: string;
}
interface ServIFrameCreatorConfig {
    url: string | (() => string);
    id?: string;
    showPolicy?: EServIFrameShowPolicy;
    postOrigin?: string;
    container?: HTMLElement;
    className?: string;
    style?: Partial<HTMLElement['style']>;
    show?: (element: HTMLIFrameElement, container?: HTMLElement) => void;
    hide?: (element: HTMLIFrameElement, container?: HTMLElement) => void;
    onCreateWindow?(info: ServIFrameWindowInfo): void;
    onDestroyWindow?(info: ServChannelWindow): void;
    onCreate?(info: ServChannelWindow): void;
    onEcho?(info: ServChannelWindow): void;
    onOpened?(info: ServChannelWindow): void;
    onDestroy?(info: ServChannelWindow): void;
    onOpenError?(): void;
    onClosed?(): void;
}
declare class IFrameUtil {
    static generateCreator(config: ServIFrameCreatorConfig): ServWindowChannelConfig['master'];
}

declare class SappPlainPage extends Sapp {
    start: ((options?: SappStartOptions | undefined) => Promise<void>) & {
        deferred: Deferred<void> | undefined;
    };
    show(params?: SappShowParams$1): Promise<boolean>;
    hide(params?: SappHideParams$1): Promise<boolean>;
    protected _show: ((params?: SappShowParams$1 | undefined, byCreate?: boolean | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    protected _hide: ((params?: SappHideParams$1 | undefined, byClose?: boolean | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    close: ((result?: SappCloseResult | undefined) => Promise<boolean>) & {
        deferred: Deferred<void> | undefined;
    };
    protected initTerminal(options: SappStartOptions): Promise<void>;
}

/**
 * SHOSTSDK生命周期事件
 *
 * @export
 * @enum {number}
 */
declare enum EShostSDKLifeCycleEvent {
    ON_CREATE = "ON_CREATE",
    ON_CLOSE = "ON_CLOSE"
}
interface ShostLayoutOptions {
    /**
     * 应用容器元素；如果是一个string，则是元素的选择器
     *
     * @type {HTMLElement}
     * @memberof SappLayoutOptions
     */
    container?: HTMLElement;
    /**
     * iframe节点class；只对ESappType.IFRAME有效
     *
     * @type {string}
     * @memberof SappLayoutOptions
     */
    className?: string;
    /**
     * iframe节点style；只对ESappType.IFRAME有效
     *
     * @type {string}
     * @memberof SappLayoutOptions
     */
    style?: Partial<HTMLElement['style']>;
    /**
     * 应用start回调，对于布局而言，可以在这里将容器元素真正的append到document上
     *
     * @memberof SappLayoutOptions
     */
    doStart?: ((sdk: ShostSDK) => void);
    /**
     * 应用close回调，对于布局而言，可以在这里将容器元素真正的从document移除
     *
     * @memberof SappLayoutOptions
     */
    doClose?: ((sdk: ShostSDK) => void);
}
/**
 * Host页面内嵌入的iframe信息
 *
 * @export
 * @interface ShostContentPageInfo
 */
interface ShostContentPageInfo {
    /**
     * 容器DOM节点
     *
     * @type {HTMLElement}
     * @memberof ShostContentPageInfo
     */
    container: HTMLElement;
    /**
     * IFrame DOM节点
     *
     * @type {HTMLIFrameElement}
     * @memberof ShostContentPageInfo
     */
    element: HTMLIFrameElement;
    /**
     * IFrame的布局信息
     *
     * @type {ShostLayoutOptions}
     * @memberof ShostContentPageInfo
     */
    layout?: ShostLayoutOptions;
}
/**
 * SHOSTSDK配置
 */
interface ShostSDKConfig {
    /**
     * SHOSTSDK底层Servkit，默认使用全局的servkit
     */
    servkit?: Servkit;
    /**
     * host页面提供的数据接口
     *
     * @memberof ShostSDKConfig
     */
    hostData?: any | ((params: any) => any | Promise<any>);
    /**
     * host页面提供的信息接口
     *
     * @memberof SHOSTSDKConfig
     */
    hostInfo?: SappHostInfo | ((sdk: ShostSDK) => SappHostInfo | Promise<SappHostInfo>);
    /**
     * IFrame布局配置
     *
     * @type {ShostLayoutOptions}
     * @memberof ShostSDKConfig
     */
    layout?: ShostLayoutOptions;
    /**
     * IFrame页面URL构造接口
     *
     * @memberof ShostSDKConfig
     */
    resolveContentPageUrl?: (options: ShostSDKStartOptions) => string;
    /**
     * 生命周期回调，应用创建时回调
     *
     * @param {SHOSTSDK} sdk
     * @returns {Promise<void>}
     * @memberof SHOSTSDKConfig
     */
    onCreate?(sdk: ShostSDK): Promise<void>;
    /**
     * 生命周期回调，应用关闭时回调
     *
     * @param {SHOSTSDK} sdk
     * @returns {Promise<SappOnCloseResult | void>}
     * @memberof SHOSTSDKConfig
     */
    onClose?(sdk: ShostSDK): Promise<SappOnCloseResult | void> | void;
    /**
     * 从应用向主应用提供的服务
     *
     * @type {ServServiceConfig['services']}
     * @memberof SHOSTSDKConfig
     */
    services?: ServServiceConfig['services'];
}
/**
 * SHOSTSDK start参数项
 */
interface ShostSDKStartOptions {
    layout?: ShostLayoutOptions;
}
/**
 * SHOSTSDK是从应用与主应用交互的桥梁，也是从应用自身的抽象；
 * 主要提供了：
 * 1：自身生命周期管理
 * 2：与主应用的交互接口，获取服务API
 *
 * @export
 * @class SHOSTSDK
 * @extends {EventEmitter}
 */
declare class ShostSDK extends EventEmitter {
    /**
     * SDK是否已经初始化
     *
     * @type {boolean}
     * @memberof SHOSTSDK
     */
    isStarted: boolean;
    /**
     * SDK start deffered Promise；在业务层面可以使用SHOSTSDK.started去等待SDK的初始化（也可以直接使用SHOSTSDK.start()这种形式）
     *
     * @type {Deferred}
     * @memberof SHOSTSDK
     */
    started: Deferred;
    /**
     * 内部服务通信桥梁，建议不要直接使用
     *
     * @type {ServTerminal}
     * @memberof SHOSTSDK
     */
    terminal: ServTerminal;
    protected contentInfo?: ShostContentPageInfo;
    protected mutex: AsyncMutex;
    protected config: ShostSDKConfig;
    constructor();
    /**
     * SHOSTSDK的全局配置，需要在start之前设定好
     *
     * @param {SHOSTSDKConfig} config
     * @returns this
     * @memberof SHOSTSDK
     */
    setConfig(config: ShostSDKConfig): this;
    /**
     * 获取全局配置
     *
     * @returns
     * @memberof SHOSTSDK
     */
    getConfig(): ShostSDKConfig;
    /**
     * 获取SHOSTSDK使用的servkit
     *
     * @returns
     * @memberof SHOSTSDK
     */
    getServkit(): Servkit;
    /**
     * 启动SDK；具有防重入处理；会触发onCreate回调；
     * 会创建IFrame页面；
     *
     * @param {SHOSTSDKStartOptions} [options]
     * @returns {Promise<void>}
     * @memberof SHOSTSDK
     */
    start: ((options?: ShostSDKStartOptions | undefined) => Promise<void>) & {
        /**
         * SDK是否已经初始化
         *
         * @type {boolean}
         * @memberof SHOSTSDK
         */
        deferred: Deferred<void> | undefined;
    };
    /**
     * 关闭SDK；具有防重入处理；会触发onCreate回调；
     * IFrame页面会触发onClose回调，并能够打断关闭操作。
     *
     * @memberof ShostSDK
     */
    close: (() => Promise<boolean>) & {
        /**
         * SDK是否已经初始化
         *
         * @type {boolean}
         * @memberof SHOSTSDK
         */
        deferred: Deferred<void> | undefined;
    };
    /**
     * 获取主应用提供的Service，同步版本
     *
     * @type {ServServiceClient['getService']}
     * @memberof SHOSTSDK
     *
     * @example
     * ``` ts
     * // 获取单个服务
     * const serv = app.getService(CommServiceDecl);
     * if (serv) {
     *     serv.func();
     * }
     *
     * or
     *
     * // 同时获取多个服务
     * const { serv } = app.getService({ serv: CommServiceDecl });
     * if (serv) {
     *     serv.func();
     * }
     * ```
     */
    getService: ServServiceClient['getService'];
    /**
     * 获取从应用提供的Service，与getService区别在于，返回值没有保证是否为undefined
     *
     * @type {ServServiceClient['getServiceUnsafe']}
     * @memberof SHOSTSDK
     *
     * @example
     * ``` ts
     * const serv = app.getServiceUnsafe(CommServiceDecl);
     * serv.func(); // 没有 undefined 错误提示
     * ```
     */
    getServiceUnsafe: ServServiceClient['getServiceUnsafe'];
    /**
     * 获取从应用提供的Service，异步版本
     *
     * @type {ServServiceClient['service']}
     * @memberof SHOSTSDK
     *
     * @example
     * ``` ts
     * const serv = await app.service(CommServiceDecl);
     * ```
     */
    service: ServServiceClient['service'];
    /**
     * 获取从应用提供的Service，回调版本
     *
     * @type {ServServiceClient['serviceExec']}
     * @memberof SHOSTSDK
     *
     * @example
     * ``` ts
     * app.serviceExec(CommServiceDecl, (serv) => {
     *     serv.func();
     * });
     */
    serviceExec: ServServiceClient['serviceExec'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['getService']}
     * @memberof SHOSTSDK
     */
    getServerService: ServServiceServer['getService'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['getServiceUnsafe']}
     * @memberof SHOSTSDK
     */
    getServerServiceUnsafe: ServServiceServer['getServiceUnsafe'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['service']}
     * @memberof SHOSTSDK
     */
    serverService: ServServiceServer['service'];
    /**
     * 获取从应用向主应用提供的服务
     *
     * @type {ServServiceServer['serviceExec']}
     * @memberof SHOSTSDK
     */
    serverServiceExec: ServServiceServer['serviceExec'];
    protected onStartFailed(): void;
    protected initTerminal(options: ShostSDKStartOptions): Promise<void>;
    protected releaseTerminal(): void;
    protected onCreate(): Promise<void>;
    protected onClose(): Promise<void | SappOnCloseResult>;
    protected createContentPage(options: ShostSDKStartOptions): ShostContentPageInfo;
    protected destroyContentPage(): void;
    protected resolveContentPageUrl(options: ShostSDKStartOptions): string;
}
/**
 * 全局SHOSTSDK
 */
declare const shostSDK: ShostSDK;

interface LayoutShowHide$2 {
    options: SappLayoutOptions;
    container?: HTMLElement;
    doStart?: ((app: Sapp) => void);
    doClose?: ((app: Sapp) => void);
    doShow?: ((app: Sapp) => void);
    doHide?: ((app: Sapp) => void);
    showClassName?: string;
    showStyle?: Partial<HTMLElement['style']>;
    hideClassName?: string;
    hideStyle?: Partial<HTMLElement['style']>;
    className?: string;
    style?: SappLayoutOptions['style'];
}
declare class SappDefaultIFrameController extends SappController {
    protected windowInfo: ServIFrameWindowInfo;
    protected layout: LayoutShowHide$2;
    doStart(): Promise<void>;
    doClose(result?: SappCloseResult): Promise<void>;
    doShow(): Promise<void>;
    doHide(): Promise<void>;
    protected doCloseAfterAspect(): void;
    protected setupLayout(options: SappLayoutOptions): void;
    protected resolveSessionChannelConfig(options: SappCreateOptions): ServSessionConfig['channel'];
    protected resolveQueryParams(options: SappCreateOptions): SappSDKStartParams;
}

interface LayoutShowHide$1 {
    options: SappLayoutOptions;
    doStart?: ((app: Sapp) => void);
    doClose?: ((app: Sapp) => void);
    doShow?: ((app: Sapp) => void);
    doHide?: ((app: Sapp) => void);
}
declare class SappDefaultHostPageController extends SappController {
    protected layout: LayoutShowHide$1;
    doStart(): Promise<void>;
    doClose(result?: SappCloseResult): Promise<void>;
    doShow(): Promise<void>;
    doHide(): Promise<void>;
    protected doCloseAfterAspect(): void;
    protected setupLayout(options: SappLayoutOptions): void;
    protected resolveSessionChannelConfig(options: SappCreateOptions): ServSessionConfig['channel'];
}

interface LayoutShowHide {
    options: SappLayoutOptions;
    container: HTMLElement;
    doStart?: ((app: Sapp) => void);
    doClose?: ((app: Sapp) => void);
    doShow?: ((app: Sapp) => void);
    doHide?: ((app: Sapp) => void);
    showClassName?: string;
    showStyle?: Partial<HTMLElement['style']>;
    hideClassName?: string;
    hideStyle?: Partial<HTMLElement['style']>;
}
declare class SappDefaultAsyncLoadController extends SappController {
    protected layout?: LayoutShowHide;
    doStart(): Promise<void>;
    doClose(result?: SappCloseResult): Promise<void>;
    doShow(): Promise<void>;
    doHide(): Promise<void>;
    protected doCloseAfterAspect(): void;
    protected setupLayout(options: SappLayoutOptions): void;
    protected resolveSessionChannelConfig(options: SappCreateOptions): ServSessionConfig['channel'];
    protected resolveSharedParams(options: SappCreateOptions): SappSDKAsyncLoadStartParams;
    protected generateLoadCreator(options: SappCreateOptions): {
        createLoader: (channel: any) => {
            load: () => Promise<void>;
        };
        destroyLoader: (loader: any, channel: any) => void;
    };
}

interface ServEventLoader {
    load(): Promise<void>;
}
interface ServEventLoaderChannelOpenOptions extends ServChannelOpenOptions {
    dontWaitSlaveEcho?: boolean;
}
interface ServEventLoaderChannelConfig extends ServEventChannelConfig {
    master?: {
        dontWaitEcho?: boolean;
        createLoader(channel: ServEventLoaderChannel): ServEventLoader;
        destroyLoader(loader: ServEventLoader, channel: ServEventLoaderChannel): void;
        onCreate?(loader: ServEventLoader, channel: ServEventLoaderChannel): void;
        onOpened?(loader: ServEventLoader, channel: ServEventLoaderChannel): void;
        onOpenError?(channel: ServEventLoaderChannel): void;
        onDestroy?(loader: ServEventLoader, channel: ServEventLoaderChannel): void;
        onClosed?(channel: ServEventLoaderChannel): void;
        onEcho?(loader: ServEventLoader, channel: ServEventLoaderChannel): void;
    };
    slave?: {};
}
declare class ServEventLoaderChannel extends ServEventChannel {
    protected loader: ServEventLoader;
    protected config: ServEventLoaderChannelConfig;
    protected doWaitSlaveCleanWork?: (() => void);
    protected tryWaitSlaveEcho?: (msg: ServChannelPackage) => void;
    open(options?: ServEventLoaderChannelOpenOptions): Promise<void>;
    close(): void;
    protected waitSlaveEcho(options: ServEventLoaderChannelOpenOptions): Promise<void>;
    recvChannelPackage(msg: ServChannelPackage): void;
    protected slaveEcho(): void;
}

interface LoadContext {
    loaded: Deferred;
    clean: () => void;
}
interface LoadHtmlContext extends LoadContext {
    scripts: HTMLScriptElement[];
    styles: HTMLStyleElement[];
}
interface LoadScriptContext extends LoadContext {
    script?: HTMLScriptElement;
}

interface ServScriptLoader extends ServEventLoader {
    context?: LoadScriptContext;
}
interface ServScriptLoaderCreatorConfig {
    url: string | (() => string);
    onCreateLoader?(loader: ServScriptLoader): void;
    onDestroyLoader?(loader: ServScriptLoader): void;
    onLoaderLoadSucceed?(loader: ServScriptLoader): void;
    onLoaderLoadFailed?(loader: ServScriptLoader): void;
    onCreate?(loader: ServScriptLoader): void;
    onOpened?(loader: ServScriptLoader): void;
    onOpenError?(): void;
    onDestroy?(loader: ServScriptLoader): void;
    onClosed?(): void;
    onEcho?(loader: ServScriptLoader): void;
    timeout?: number;
}
declare class ScriptUtil {
    static generateCreator(config: ServScriptLoaderCreatorConfig): ServEventLoaderChannelConfig['master'];
}

interface ServHtmlLoader extends ServEventLoader {
    context?: LoadHtmlContext;
}
interface ServHtmlLoaderCreatorConfig {
    html: string | (() => Promise<string> | string);
    onCreateLoader?(loader: ServHtmlLoader): void;
    onDestroyLoader?(loader: ServHtmlLoader): void;
    onLoaderLoadSucceed?(loader: ServHtmlLoader): void;
    onLoaderLoadFailed?(loader: ServHtmlLoader): void;
    onCreate?(loader: ServHtmlLoader): void;
    onOpened?(loader: ServHtmlLoader): void;
    onOpenError?(): void;
    onDestroy?(loader: ServHtmlLoader): void;
    onClosed?(): void;
    onEcho?(loader: ServHtmlLoader): void;
    timeout?: number;
}
declare class HTMLUtil {
    static generateCreator(config: ServHtmlLoaderCreatorConfig): ServEventLoaderChannelConfig['master'];
}

export { API_ERROR, API_SUCCEED, API_UNSUPPORT, AsyncMutex, AsyncMutexLock, AsyncMutexOptions, AsyncMutexUnlock, Deferred, DeferredOptions, DeferredUtil, EDeferredResult, ESappCreatePolicy, ESappLifePolicy, ESappSDKLifeCycleEvent, ESappType, EServChannel, EServIFrameShowPolicy, EServMessage, EServRPCEvent, EServServiceMessage, EServSessionStatus, EServTerminal, EShostSDKLifeCycleEvent, HTMLUtil, IFrameUtil, IServClientService, Sapp, SappACLResolver, SappAPICallContext, SappAsyncLoadSDK, SappAuthParams, SappCloseResult, SappConfig, SappController, SappCreateOptions, SappDefaultAsyncLoadController, SappDefaultHostPageController, SappDefaultIFrameController, SappHideParams$1 as SappHideParams, SappHostCreateOptions, SappHostOnCloseHandle, SappHostPage, SappInfo, SappLayoutOptions, SappMGR, SappMGRConfig, SappPlainPage, SappSDK, SappSDKAsyncLoadDeclContext, SappSDKAsyncLoadDeclParams, SappSDKAsyncLoadStartParams, SappSDKConfig, SappHideParams as SappSDKHideParams, SappSDKMock, SappSDKMockConfig, SappShowParams as SappSDKShowParams, SappSDKStartOptions, SappSDKStartParams, SappShowParams$1 as SappShowParams, SappStartOptions, SappTerminalExtData, ScriptUtil, ServACL, ServAPI, ServAPIArgs, ServAPICallContext, ServAPICallOptions, ServAPIMeta, ServAPIOptions, ServAPIRetn, ServAnnoDecl, ServAnnoImpl, ServApiTransformOptions, ServChanleWindowData, ServChannel, ServChannelConfig, ServChannelObjectPackage, ServChannelOpenOptions, ServChannelPackage, ServChannelWindow, ServContextedMessage, ServDeclOptions, ServEXT, ServEventChannel, ServEventChannelConfig, ServEventListener, ServEventUnListener, ServEventer, ServEventerManager, ServEventerMeta, ServEventerOnEmitListener, ServEventerOptions, ServGlobalServiceConfig, ServGlobalServiceManager, ServHtmlLoader, ServHtmlLoaderCreatorConfig, ServIFrameCreatorConfig, ServIFrameWindowInfo, ServImplOptions, ServMessage, ServMessageAddOptions, ServMessageChannel, ServMessageChannelConfig, ServMessageContextManager, ServMessageCreator, ServNotifyOptions, ServScriptLoader, ServScriptLoaderCreatorConfig, ServService, ServServiceAPIMessage, ServServiceAPIReturnMessage, ServServiceClient, ServServiceClientConfig, ServServiceConfig, ServServiceEventMessage, ServServiceGetVersionMessage, ServServiceGetVersionReturnMessage, ServServiceImplMeta, ServServiceManager, ServServiceMessage, ServServiceMessageCreator, ServServiceMeta, ServServiceOnEmitListener, ServServiceOptions, ServServiceRefer, ServServiceReferPattern, ServServiceReturnMessage, ServServiceServer, ServServiceServerACLResolver, ServServiceServerConfig, ServSession, ServSessionCallMessage, ServSessionCallMessageCreator, ServSessionCallOptions, ServSessionCallReturnMessage, ServSessionChecker, ServSessionCheckerStartOptions, ServSessionConfig, ServSessionListener, ServSessionOnRecvCallMessageListener, ServSessionOnRecvMessageListener, ServSessionOpenOptions, ServSessionPackage, ServTerminal, ServTerminalConfig, ServWindowChannel, ServWindowChannelConfig, ServWindowChannelOpenOptions, Servkit, ServkitConfig, ShostContentPageInfo, ShostLayoutOptions, ShostSDK, ShostSDKConfig, ShostSDKStartOptions, anno, aspect, aspectAfter, aspectBefore, delAsyncLoadDeclContext, delAsyncLoadGlobal, delAsyncLoadStartParams, delSharedParams, generateServQueryParams, getAsyncLoadDeclContext, getAsyncLoadGlobal, getAsyncLoadStartParams, getSharedParams, nextUUID, parseServQueryParams, popSharedParams, putAsyncLoadDeclContext, putAsyncLoadGlobal, putAsyncLoadStartParams, putSharedParams, replacePlaceholders, safeExec, sappMGR, sappSDK, servkit, shostSDK, wrapServQueryParams };