/// <reference path="../library/typings/cross-service.d.ts" />
/// <reference path="../library/typings/cross-server.d.ts" />
/// <reference path="../typings/private/foundation-data-common.d.ts" />
/// <reference types="node" />
/// <reference types="node" />
declare module "copyright" {
    export class FoundationServiceCommonCopyright {
        static toString(): string;
    }
}
declare module "foundation/service/common/base/ContextBindEnum" {
    export class ContextBindEnum {
        static OperatorAddress: string;
    }
}
declare module "foundation/service/common/base/SessionBindEnum" {
    export class SessionBindEnum {
    }
}
declare module "foundation/service/common/config/ServerConfig" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class ServerConfig extends InstanceObject {
        content: any;
    }
}
declare module "foundation/service/common/config/ServerConfigService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { ListenerAsyncThread } from 'cross/runtime/module/thread/ListenerAsyncThread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { ServerConfig } from "foundation/service/common/config/ServerConfig";
    export class ServerConfigService extends Service {
        protected _storagePath: string;
        protected _threadConfig: ListenerAsyncThread;
        protected _environmentService: EnvironmentService;
        protected _threadService: ThreadService;
        protected _cacheService: CacheConnectionService;
        constructor();
        initializeConfig(jconfig: any): void;
        loadConfigAsync(code: string): Promise<ResultObject<ServerConfig>>;
    }
}
declare module "foundation/service/common/database/FieldCompareEnum" {
    import { SearchTypeEnum } from 'cross/data/module/dataset/SearchTypeEnum';
    export class FieldCompareEnum extends SearchTypeEnum {
    }
}
declare module "foundation/service/common/database/FieldMeta" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class FieldMeta extends InstanceObject {
        name: string;
        label: string;
        dataName: string;
        fieldName: string;
        typeCd: string;
        typeSize: number;
        optionKey: boolean;
        optionEmpty: boolean;
        dataDefault: string;
        optionUnique: boolean;
        dataReference: string;
        dataParent: boolean;
        autoIncrement: boolean;
        optionFix: boolean;
        dataLength: string;
        optionValid: boolean;
        note: string;
        constructor(name?: string | Object, dataName?: string, typeCd?: string, optionKey?: boolean, optionEmpty?: boolean, dataDefault?: any, optionUnique?: boolean, dataReference?: string, dataParent?: boolean);
        loadOption(option: any): void;
        setProperty(name: string, jname: string, jconfig: any, type?: string): void;
        static build(config: any): FieldMeta;
    }
}
declare module "foundation/service/common/database/FieldCompare" {
    import { SearchObject } from 'cross/data/module/dataset/SearchObject';
    import { FieldCompareEnum } from "foundation/service/common/database/FieldCompareEnum";
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    export class FieldCompare extends SearchObject {
        field: FieldMeta;
        compareCd: FieldCompareEnum;
        value: any;
        loadJson(jconfig: any): void;
        saveJson(target?: any): any;
    }
}
declare module "foundation/service/common/database/FieldOrderEnum" {
    import { OrderTypeEnum } from 'cross/data/module/dataset/OrderTypeEnum';
    export class FieldOrderEnum extends OrderTypeEnum {
    }
}
declare module "foundation/service/common/database/FieldOrder" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    import { FieldOrderEnum } from "foundation/service/common/database/FieldOrderEnum";
    export class FieldOrder extends InstanceObject {
        field: FieldMeta;
        orderCd: FieldOrderEnum;
    }
}
declare module "foundation/service/common/database/util/DataQuery" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { SearchCondition } from 'cross/data/module/dataset/SearchCondition';
    import { FieldCompare } from "foundation/service/common/database/FieldCompare";
    import { FieldCompareEnum } from "foundation/service/common/database/FieldCompareEnum";
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    import { FieldOrder } from "foundation/service/common/database/FieldOrder";
    import { FieldOrderEnum } from "foundation/service/common/database/FieldOrderEnum";
    export class DataQuery extends InstanceObject {
        tableName: string;
        selectSql: string;
        compares: Types<FieldCompare>;
        searchCondition: SearchCondition;
        orders: Types<FieldOrder>;
        pageSize: number;
        page: number;
        constructor();
        addCompare(field: FieldMeta, compareCd: FieldCompareEnum, value: any): void;
        addOrder(field: FieldMeta, orderCd: FieldOrderEnum): void;
        limit(pageSize: number, page: number): DataQuery;
        private makeCompareStr;
        protected makeFilterSql(sql: StringBuffer): void;
        protected makeSearchConditionSql(search: SearchCondition): string;
        toFilterSql(): string;
        toString(): string;
        toStringWithCount(): string;
    }
}
declare module "foundation/service/common/database/util/DataSql" {
    import { DateTime } from 'cross/runtime/lang/DateTime';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    export class DataSql extends StringBuffer {
        appendNumber(value: number): void;
        appendString(value: string): void;
        appendDateTime(value: DateTime): void;
    }
}
declare module "foundation/service/common/database/DatasetMeta" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class DatasetMeta extends InstanceObject {
        fullName: string;
        spaceName: string;
        name: string;
        dataName: string;
        typeCd: string;
        constructor(spaceName: string, name: string, dataName: string, typeCd: string);
    }
}
declare module "foundation/service/common/database/HistoryTableMeta" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    export class HistoryTableMeta {
        static HISTORY_FIELDS: FieldMeta[];
        static getFieldMetaByDataName(name: string): FieldMeta;
        static getHistoryTableProps(): Types<any>;
    }
}
declare module "foundation/service/common/database/TableIndexMeta" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { StringArray } from 'cross/runtime/lang/StringArray';
    export class TableIndexMeta extends InstanceObject {
        name: string;
        typeName: string;
        optionUnique: boolean;
        optionNull: boolean;
        indexType: string;
        protected _fieldNames: StringArray;
        constructor(name?: string);
        get fieldNames(): StringArray;
        dispose(): void;
    }
}
declare module "foundation/service/common/database/TableMeta" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    import { TableIndexMeta } from "foundation/service/common/database/TableIndexMeta";
    export class TableMeta extends InstanceObject {
        databaseName: string;
        name: string;
        engineName: string;
        charsetName: string;
        createDate: string;
        updateDate: string;
        node: string;
        protected _fields: Types<FieldMeta>;
        protected _indexes: Types<TableIndexMeta>;
        constructor();
        get fields(): Types<FieldMeta>;
        get indexes(): Types<TableIndexMeta>;
        findFieldByDataName(dataName: string): FieldMeta;
        pushField(field: FieldMeta): void;
        makeFieldValue(meta: FieldMeta, value: any): string;
        findIndexByName(indexName: string): TableIndexMeta;
        pushIndex(indexMeta: TableIndexMeta): void;
        makeSelectSql(where?: string, orderBy?: string): string;
        makeInsertSql(row: any, check?: boolean): string;
        makeUpdateSql(row: any): string;
        makeDeleteSql(row: any): string;
        makeClearSql(): string;
    }
}
declare module "foundation/service/common/database/DatabaseMeta" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { TableMeta } from "foundation/service/common/database/TableMeta";
    export class DatabaseMeta extends InstanceObject {
        protected _tables: Types<TableMeta>;
        constructor();
        get tables(): Types<TableMeta>;
        pushTable(tbale: TableMeta): void;
    }
}
declare module "foundation/service/common/database/DataConnectionOptions" {
    export type DataConnectionOptions = {
        databaseName?: string;
        optionTransaction?: boolean;
        parameters?: any;
    };
}
declare module "foundation/service/common/database/DatabaseConstants" {
    export class DatabaseConstants {
        static StatisticsMinLimit: number;
    }
}
declare module "foundation/service/common/database/DataResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class DataResult extends ResultObject {
        affectedRows: number;
        total: number;
        pageSize: number;
        page: number;
        sql: string;
        sqlMessage: string;
        errorMessage: string;
        assign(result: DataResult): DataResult;
    }
}
declare module "foundation/service/common/database/ViewMeta" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    export class ViewMeta extends InstanceObject {
        databaseName: string;
        name: string;
        createDate: string;
        updateDate: string;
        node: string;
        protected _fields: Types<FieldMeta>;
        constructor();
        get fields(): Types<FieldMeta>;
        findFieldByDataName(dataName: string): FieldMeta;
        pushField(field: FieldMeta): void;
        makeFieldValue(meta: FieldMeta, value: any): string;
        makeSelectSql(where?: string, orderBy?: string): string;
        makeInsertSql(row: any, check?: boolean): string;
        makeUpdateSql(row: any): string;
        makeDeleteSql(row: any): string;
        makeClearSql(): string;
    }
}
declare module "foundation/service/common/database/mysql/MySqlDataConnection" {
    import * as libMysql from 'mysql';
    import * as libStream from 'stream';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataQuery } from "foundation/service/common/database/util/DataQuery";
    import { DatabaseMeta } from "foundation/service/common/database/DatabaseMeta";
    import { DataConnection, DataConnectionScriptType } from "foundation/service/common/database/DataConnection";
    import { DataConnectionOptions } from "foundation/service/common/database/DataConnectionOptions";
    import { DataResult } from "foundation/service/common/database/DataResult";
    import { TableMeta } from "foundation/service/common/database/TableMeta";
    import { ViewMeta } from "foundation/service/common/database/ViewMeta";
    export class MySqlDataConnection extends DataConnection {
        protected _sqlConnection: libMysql.PoolConnection;
        constructor();
        isValid(): boolean;
        link(sqlConection: any): void;
        beginAsync(options?: DataConnectionOptions): Promise<ResultObject>;
        selectDatabaseAsync(databaseName: string): Promise<DataResult>;
        changeAutocommitAsync(autocommit: boolean): Promise<DataResult>;
        fetchMetaAsync(): Promise<ResultObject<DatabaseMeta>>;
        existTableAsync(dataName: string, databaseName: string): Promise<ResultObject<string>>;
        fetchTableMetaAsync(tableName: string, databaseName?: string): Promise<ResultObject<TableMeta>>;
        fetchViewMetaAsync(tableName: string, databaseName?: string): Promise<ResultObject<ViewMeta>>;
        beginTransactionAsync(): Promise<DataResult>;
        commitAsync(): Promise<DataResult>;
        rollbackAsync(): Promise<DataResult>;
        streamQuery(script: DataConnectionScriptType): libStream.Readable;
        findAsync(script: DataConnectionScriptType, parameters?: any): Promise<DataResult>;
        findContextAsync(context: IContext, script: DataConnectionScriptType, parameters?: any): Promise<DataResult>;
        fetchAsync(script: DataConnectionScriptType, parameters?: any): Promise<DataResult>;
        fetchContextAsync(context: IContext, script: DataConnectionScriptType, parameters?: any): Promise<DataResult>;
        fetchPageAsync(query: DataQuery, parameters?: any): Promise<DataResult>;
        fetchPageContextAsync(context: IContext, query: DataQuery, parameters?: any): Promise<DataResult>;
        executeSqlAsync(script: DataConnectionScriptType, parameters?: any): Promise<DataResult>;
        executeContextSqlAsync(context: IContext, script: DataConnectionScriptType, parameters?: any): Promise<DataResult>;
        freeAsync(): Promise<DataResult>;
        dispose(): void;
    }
}
declare module "foundation/service/common/database/DataConnectionPool" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataConnection } from "foundation/service/common/database/DataConnection";
    import { DataConnectionOptions } from "foundation/service/common/database/DataConnectionOptions";
    export class DataConnectionPool extends InstanceObject {
        name: string;
        host: string;
        port: number;
        passport: string;
        password: string;
        database: string;
        limitCount: number;
        connectTimeout: number;
        acquireTimeout: number;
        timeout: number;
        allocCount: number;
        freeCount: number;
        protected _sqlPool: any;
        protected _spaceDatabaseMap: Dictionary<string>;
        get useCount(): number;
        loadConfig(jconfig: any, name?: string): void;
        getPoolCode(): string;
        getSpaces(): string[];
        setSpaceDatabase(spaceName: string, databaseName: string): void;
        getSpaceDatabase(spaceName: string): string;
        startup(): void;
        allocConnectionAsync(reference?: any, options?: DataConnectionOptions): Promise<DataConnection>;
        freeConnection(connection: DataConnection): void;
        testAsync(context: IContext): Promise<ResultObject>;
        shutdown(): void;
    }
}
declare module "foundation/service/common/database/DataConnection" {
    import * as libStream from 'stream';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataQuery } from "foundation/service/common/database/util/DataQuery";
    import { DataSql } from "foundation/service/common/database/util/DataSql";
    import { DatabaseMeta } from "foundation/service/common/database/DatabaseMeta";
    import { DataConnectionOptions } from "foundation/service/common/database/DataConnectionOptions";
    import { DataConnectionPool } from "foundation/service/common/database/DataConnectionPool";
    import { DataResult } from "foundation/service/common/database/DataResult";
    import { TableMeta } from "foundation/service/common/database/TableMeta";
    import { ViewMeta } from "foundation/service/common/database/ViewMeta";
    export type DataConnectionScriptType = string | DataSql;
    export class DataConnection extends InstanceObject {
        pool: DataConnectionPool;
        databaseName: string;
        referenceObject: any;
        optionTransaction: boolean;
        statusTransaction: boolean;
        constructor();
        isValid(): boolean;
        link(sqlConection: any): void;
        beginAsync(options?: DataConnectionOptions): Promise<ResultObject>;
        endAsync(): Promise<ResultObject>;
        makeSql(script: DataConnectionScriptType): string;
        selectDatabaseAsync(databaseName: string): Promise<DataResult>;
        fetchMetaAsync(): Promise<ResultObject<DatabaseMeta>>;
        existTableAsync(dataName: string, databaseName: string): Promise<ResultObject<string>>;
        fetchTableMetaAsync(tableName: string, databaseName?: string): Promise<ResultObject<TableMeta>>;
        fetchViewMetaAsync(tableName: string, databaseName?: string): Promise<ResultObject<ViewMeta>>;
        beginTransactionAsync(): Promise<DataResult>;
        commitAsync(): Promise<DataResult>;
        rollbackAsync(): Promise<DataResult>;
        streamQuery(script: DataConnectionScriptType): libStream.Readable;
        findAsync(script: DataConnectionScriptType, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        findContextAsync(context: IContext, script: DataConnectionScriptType, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        fetchAsync(script: DataConnectionScriptType, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        fetchContextAsync(context: IContext, script: DataConnectionScriptType, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        fetchPageAsync(query: DataQuery, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        fetchPageContextAsync(context: IContext, query: DataQuery, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        executeSqlAsync(script: DataConnectionScriptType, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        executeContextSqlAsync(context: IContext, script: DataConnectionScriptType, parameters?: any, onSuccess?: any, onError?: any): Promise<DataResult>;
        freeAsync(): Promise<DataResult>;
    }
}
declare module "foundation/service/common/database/IDataContext" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { DataConnection } from "foundation/service/common/database/DataConnection";
    import { DataResult } from "foundation/service/common/database/DataResult";
    export interface IDataContext extends IContext {
        makeGuid(): string;
        getUserId(): string;
        getUserName(): string;
        getPrefix(): string;
        getSuffix(): string;
        getBindValue(code: string): any;
        getDatabaseName(): string;
        getConnectionAsync(name?: string, reference?: any): Promise<DataConnection>;
        commitAsync(): Promise<DataResult>;
        commitFinishAsync(): Promise<DataResult>;
        rollbackAsync(): Promise<DataResult>;
        rollbackFinishAsync(): Promise<DataResult>;
        disposeAsync(): Promise<void>;
    }
}
declare module "foundation/service/common/database/util/DataUtil" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { DatasetMeta } from "foundation/service/common/database/DatasetMeta";
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    import { IDataContext } from "foundation/service/common/database/IDataContext";
    export class DataUtil {
        static DATE_FORMAT: string;
        static DATE_FORMAT_VALUE: string;
        static SYSTEM_FILEDS: Array<string>;
        static DEPLOY_CODE: string;
        protected static _environmentService: EnvironmentService;
        static getDeployCode(): string;
        static makeOperateInfo(context: IDataContext): any;
        static findKeyField(fields: Array<FieldMeta>): FieldMeta;
        static findFieldByName(fields: Array<FieldMeta>, name: string): FieldMeta;
        static makeCode(code: string): string;
        static makeOwnerCode(ownerName: string, name: string): string;
        static makeSqlFieldTypeCode(field: FieldMeta): string;
        static makeSqlFieldType(field: FieldMeta): string;
        static makeSqlTableAddField(databaseName: string, tableName: string, field: FieldMeta, isHistoryTable?: boolean): string;
        static getFieldProps(field: FieldMeta, isKeyValid?: boolean): any;
        static makeSqlTableFieldTypeChaned(databaseName: string, tableName: string, field: FieldMeta): string;
        static makeFieldDateStr(name: string, alias?: string): string;
        static makeFieldSqlStr(field: FieldMeta, tableName?: any): string;
        static makeFieldValue(meta: FieldMeta, value: any): any;
        static makeSqlFields(fields: Array<FieldMeta>): string;
        static makeSqlFind(dataset: DatasetMeta, fields: Array<FieldMeta>, parentDataset?: DatasetMeta, parentFields?: Array<FieldMeta>): string;
        static makeSqlSelect(dataset: DatasetMeta, fields: Array<FieldMeta>, parentDataset?: DatasetMeta, parentFields?: Array<FieldMeta>, prefix?: string, suffix?: string): string;
        static makeSqlInsert(dataset: DatasetMeta, fields: Array<FieldMeta>, prefix?: string, suffix?: string, isHistory?: boolean): string;
        static makeSqlUpdate(dataset: DatasetMeta, fields: Array<FieldMeta>, prefix?: string, suffix?: string): string;
        static makeSqlDelete(dataset: DatasetMeta, fields: Array<FieldMeta>, prefix?: string, suffix?: string): string;
        static makeSqlHistory(databaseName: string, dataset: DatasetMeta, fields: Array<FieldMeta>, prefix?: string, suffix?: string): string;
        static makeSqlClear(dataset: DatasetMeta, prefix?: string, suffix?: string): string;
        static makeSqlTableStatus(databaseName: string, tableName: string): string;
        static makeSqlTableEngine(databaseName: string, tableName: string, engineCode: string): string;
        static makeSqlIndexQuery(databaseName: string, tableName: string): string;
        static makeSqlIndexAdd(databaseName: string, tableName: string, indexName: string, indexType: string, fieldNames: string): string;
        static makeSqlIndexDelete(databaseName: string, tableName: string, indexName: string): string;
    }
}
declare module "foundation/service/common/database/DatasetResult" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataResult } from "foundation/service/common/database/DataResult";
    export class DatasetResult<T extends InstanceObject> extends InstanceObject {
        unitClass: any;
        units: Types<T>;
        total: number;
        pageSize: number;
        pageCount: number;
        page: number;
        constructor(rowClass?: any);
        get count(): number;
        get first(): T;
        get last(): T;
        get(index: number): T;
        search(name: string, value: any): T;
        searchToArray(name: string, value: any, ref?: Array<T>): T[];
        push(unit: T): void;
        loadUnit(result: DataResult): void;
        loadDataset(result: DataResult): void;
    }
}
declare module "foundation/service/common/database/DatasetUnit" {
    import { DateTime } from 'cross/runtime/lang/DateTime';
    import { DataUnit } from 'foundation/data/common/datalogic/DataUnit';
    export class DatasetUnit extends DataUnit {
        objectStatusCd: number;
        objectVersion: number;
        deployCode: string;
        createUserId: string;
        createUserName: string;
        protected _createDate: DateTime;
        updateUserId: string;
        updateUserName: string;
        protected _updateDate: DateTime;
        get createDate(): DateTime;
        get updateDate(): DateTime;
        loadJson(jconfig: any): void;
        loadData(jconfig: any): void;
        saveJson(jtarget?: any): any;
        saveData(jtarget?: any): any;
    }
}
declare module "foundation/service/common/database/DatasetLogic" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataLogic } from 'foundation/data/common/datalogic/DataLogic';
    import { DataQuery } from "foundation/service/common/database/util/DataQuery";
    import { DataSql } from "foundation/service/common/database/util/DataSql";
    import { DataResult } from "foundation/service/common/database/DataResult";
    import { DatasetMeta } from "foundation/service/common/database/DatasetMeta";
    import { DatasetResult } from "foundation/service/common/database/DatasetResult";
    import { DatasetUnit } from "foundation/service/common/database/DatasetUnit";
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    import { IDataContext } from "foundation/service/common/database/IDataContext";
    export class DatasetLogic<U extends DatasetUnit = any> extends DataLogic {
        static UNIT_CLASS: any;
        optionCache: boolean;
        meta: DatasetMeta;
        fieldMetas: Types<FieldMeta>;
        unitClass: any;
        protected _context: IDataContext;
        constructor(context: IDataContext, optionCache?: boolean);
        setContext(context: IDataContext): void;
        get datasetMeta(): DatasetMeta;
        get fieldsMeta(): Array<FieldMeta>;
        createUnit(): U;
        findAsync(id: string): Promise<any>;
        searchAsync(query: DataQuery): Promise<any>;
        contextGet(id: string): any;
        contextSet(id: string, value: any): void;
        contextDelete(id: string): void;
        contextClear(): void;
        fetchAsync(query: DataQuery): Promise<DatasetResult<any>>;
        executeSqlAsync(sql: DataSql): Promise<any>;
        insertAsync(unit: any, useOldId?: boolean): Promise<DataResult>;
        updateAsync(unit: any): Promise<DataResult>;
        deleteAsync(unit: any): Promise<DataResult>;
        clearAsync(): Promise<DataResult>;
    }
}
declare module "foundation/service/common/router/database/DatasetLogicService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogic } from "foundation/service/common/database/DatasetLogic";
    import { DatasetMeta } from "foundation/service/common/database/DatasetMeta";
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    import { IDataContext } from "foundation/service/common/database/IDataContext";
    export type DatasetLogicInfo = {
        name: string;
        clazz: any;
        meta: DatasetMeta;
        fieldsMeta: FieldMeta[];
    };
    export type DatasetReferenceInfo = {
        logicClass: any;
        field: FieldMeta;
    };
    export class DatasetLogicService extends Service {
        protected _logicInfos: Dictionary<DatasetLogicInfo>;
        protected _logicSpaces: Dictionary<DatasetLogicInfo>;
        get logics(): Dictionary<DatasetLogicInfo>;
        getInfo(name: string): DatasetLogicInfo;
        register(typeName: string, clazz: any): void;
        createLogic(context: IDataContext, name: string): DatasetLogic;
        createLogicInstance(name: string, context?: IDataContext): DatasetLogic;
        findReferenceLogics(logic: DatasetLogic): Array<DatasetReferenceInfo>;
    }
}
declare module "foundation/service/common/session/ServerSessionConstants" {
    export class ServerSessionConstants {
        static Config: string;
        static User: string;
        static Parameters: string;
        static TenantId: string;
        static ModuleLibraryId: string;
        static ModuleLibraryVersion: string;
        static ResourceLibraryId: string;
        static WarehouseId: string;
        static ModuleLibraryDatabaseId: string;
        static ResourceLibraryDatabaseId: string;
    }
}
declare module "foundation/service/common/session/ServerSession" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { FreeObject } from 'cross/runtime/lang/FreeObject';
    import { LoginTypeEnum } from 'cross/data/module/logic/login/LoginTypeEnum';
    export class ServerSession extends FreeObject {
        id: string;
        loginTypeCd: LoginTypeEnum;
        token: string;
        userId: string;
        userName: string;
        permissions: string[];
        createDate: string;
        updateDate: string;
        updateTick: number;
        protected _parameters: Dictionary<any>;
        constructor();
        get parameters(): Dictionary<any>;
        contains(name: any): boolean;
        get(name: any): any;
        set(name: any, value: any): void;
        loadParameters(jparameters: any): void;
        loadJson(jconfig: any): boolean;
        saveJson(): any;
        saveInfo(): any;
        update(): void;
        free(): void;
        disposeAsync(flag?: boolean): Promise<void>;
        dispose(): void;
    }
}
declare module "foundation/service/common/database/DataConnectionService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DataSql } from "foundation/service/common/database/util/DataSql";
    import { DataConnection } from "foundation/service/common/database/DataConnection";
    import { DataConnectionOptions } from "foundation/service/common/database/DataConnectionOptions";
    import { DataConnectionPool } from "foundation/service/common/database/DataConnectionPool";
    import { DataResult } from "foundation/service/common/database/DataResult";
    export class DataConnectionService extends Service {
        protected _defaultName: string;
        protected _globalEnable: boolean;
        protected _globalPassport: string;
        protected _globalPassword: string;
        protected _pools: Dictionary<DataConnectionPool>;
        protected _spacePools: Dictionary<DataConnectionPool>;
        get defaultName(): string;
        get pools(): Dictionary<DataConnectionPool>;
        initializeConfig(jconfig: any): void;
        appendDynamicPool(pool: DataConnectionPool): void;
        updateDynamicPool(spaceName: string, pool: DataConnectionPool): void;
        startup(): void;
        testAsync(context: IContext): Promise<ResultObject>;
        allocConnectionAsync(name?: string, reference?: any, options?: DataConnectionOptions): Promise<DataConnection>;
        executeSqlAsync(sql: string | DataSql, parameters?: any): Promise<DataResult>;
        shutdown(): void;
    }
}
declare module "foundation/service/common/database/DatasetCursor" {
    import * as libStream from 'stream';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataConnection } from "foundation/service/common/database/DataConnection";
    export class DatasetCursor extends InstanceObject {
        connection: DataConnection;
        sql: string;
        transform: libStream.Transform;
        protected _currentIdx: number;
        protected _total: number;
        protected _statusOpen: boolean;
        protected _statusNext: boolean;
        protected _currentData: any;
        protected _tranformCallback: any;
        protected _nextResolve: any;
        protected _optionCount: boolean;
        constructor();
        get current(): any;
        get currentIndex(): any;
        get total(): any;
        onTransform: (data: any, encoding: any, callback: any) => void;
        openAsync(): Promise<void>;
        onFinish: () => void;
        nextAsync(): Promise<any>;
        close(): void;
    }
}
declare module "foundation/service/common/database/DataContext" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { StringArray } from 'cross/runtime/lang/StringArray';
    import { IMessageContext } from 'cross/data/module/message/IMessageContext';
    import { SessionContext } from 'foundation/core/module/logic/SessionContext';
    import { DatasetLogicService } from "foundation/service/common/router/database/DatasetLogicService";
    import { ServerSession } from "foundation/service/common/session/ServerSession";
    import { DataQuery } from "foundation/service/common/database/util/DataQuery";
    import { DataConnection } from "foundation/service/common/database/DataConnection";
    import { DataResult } from "foundation/service/common/database/DataResult";
    import { DatasetLogic } from "foundation/service/common/database/DatasetLogic";
    import { DatasetResult } from "foundation/service/common/database/DatasetResult";
    import { DatasetUnit } from "foundation/service/common/database/DatasetUnit";
    import { IDataContext } from "foundation/service/common/database/IDataContext";
    export class DataContext extends SessionContext implements IDataContext, IMessageContext {
        session: ServerSession;
        userId: string;
        userName: string;
        prefix: string;
        suffix: string;
        databaseName: string;
        optionTransaction: boolean;
        protected _automatic: boolean;
        protected _optionCache: boolean;
        protected _options: Dictionary<any>;
        protected _sessionParameters: Dictionary<any>;
        protected _activeConnection: DataConnection;
        protected _databaseNames: StringArray;
        protected _connections: Dictionary<DataConnection>;
        protected _datasetLogicService: DatasetLogicService;
        constructor(parent?: IContext);
        set automatic(v: boolean);
        get automatic(): boolean;
        makeGuid(): string;
        isLogin(): boolean;
        getSessionId(): string;
        getToken(): string;
        setUserId(userId: string): void;
        getUserId(): string;
        setUserName(userName: string): void;
        getUserName(): string;
        linkSession(session: ServerSession): void;
        setPrefix(prefix: string): void;
        getPrefix(): string;
        setSuffix(suffix: string): void;
        getSuffix(): string;
        getBindValue(code: string): any;
        getDatabaseName(): string;
        setDatabaseName(databaseName: string): void;
        pushDatabaseName(databaseName?: string): void;
        popDatabaseName(): string;
        protected setConnectionTransaction(connection: DataConnection): void;
        getConnectionAsync(name?: string, reference?: any): Promise<DataConnection>;
        linkConnection(connection: any): void;
        commitAsync(): Promise<DataResult>;
        commitFinishAsync(): Promise<DataResult>;
        rollbackAsync(): Promise<DataResult>;
        rollbackFinishAsync(): Promise<DataResult>;
        setOptionCache(optionCache: boolean): void;
        getOptionCache(): boolean;
        optionGet(code: string): any;
        optionSet(code: string, value: any): void;
        sessionGet(code: string): any;
        sessionSet(code: string, value: any): void;
        getDatasetByNameAsync<U extends DatasetUnit>(dataName: string, query?: DataQuery, force?: boolean): Promise<DatasetResult<U>>;
        getDatasetAsync<U extends DatasetUnit>(logic: DatasetLogic, query?: DataQuery, force?: boolean): Promise<DatasetResult<U>>;
        private getDatasetByTypeAsync;
        private getDatasetByCursorAsync;
        disposeAsync(): Promise<void>;
        dispose(): void;
    }
}
declare module "foundation/service/common/router/thread/LogicInvokeAsyncThread" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { AsyncThread } from 'cross/runtime/module/thread/AsyncThread';
    export type LogicInvokeAsyncThreadOptions = {
        dataConnectionOption?: boolean;
    };
    export class LogicInvokeAsyncThread extends AsyncThread {
        owner: any;
        callback: Function;
        options: any;
        protected _contextService: ContextService;
        constructor(owner: any, callback: Function, interval?: number, options?: LogicInvokeAsyncThreadOptions);
        onProcessAsync(): Promise<ResultObject>;
        dispose(): void;
    }
}
declare module "foundation/service/common/config/ServerConfigUpdateService" {
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    export class ServerConfigUpdateService extends Service {
        protected _threadService: ThreadService;
        onActive(): void;
        private updateLocalizationAsync;
    }
}
declare module "foundation/service/common/content/ContentPictureUtil" {
    export class ContentPictureUtil {
    }
}
declare module "foundation/service/common/content/convert/PictureConverter" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class PictureConverter extends InstanceObject {
        fileName: string;
        operationCd: string;
        cmdCd: string;
        paramCd: string;
        inputPath: string;
        outputPath: string;
        processAsync(...parameters: Array<any>): Promise<ResultObject>;
        processResizeAsync(inputFileName: string, outputFileName: string, outputSize: string, quality?: number): Promise<ResultObject>;
        processFileResizeAsync(inputFileName: string, outputPath: string, sizes: number[], quality?: number): Promise<ResultObject>;
        processPathResizeAsync(inputPath: string, outputPath: string, sizes: number[], quality?: number): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/content/convert/PicturePvrConverter" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class PicturePvrConverter extends InstanceObject {
        fileName: string;
        cmdCd: string;
        paramCd: string;
        inputPath: string;
        outputPath: string;
        processAsync(parameters: Array<any>): Promise<ResultObject>;
        processConvertAsync(inputFileName: string, outputFileName: string, type: string, q: string): Promise<ResultObject>;
        processPathAsync(inputPath: string, outputPath: string, type: string, q: string, sufName: string, format?: RegExp): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/content/convert/ContentConvertService" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { PictureConverter } from "foundation/service/common/content/convert/PictureConverter";
    import { PicturePvrConverter } from "foundation/service/common/content/convert/PicturePvrConverter";
    export class ContentConvertService extends Service {
        converterPath: string;
        protected _environmentService: EnvironmentService;
        initializeConfig(jconfig: any): void;
        createPictureProcessor(): PictureConverter;
        createPicturePvrProcessor(): PicturePvrConverter;
    }
}
declare module "foundation/service/common/content/convert/ResourceModelConverter" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ResourceModelConverter extends InstanceObject {
        fileName: string;
        operationCd: string;
        cmdCd: string;
        paramCd: string;
        inputPath: string;
        outputPath: string;
        processAsync(...parameters: Array<any>): Promise<ResultObject>;
        processConvertAsync(inputPath: string, outputPath: string): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/content/ZipResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ZipResult extends ResultObject {
        fileCount: number;
        fileSize: number;
        fileData: any;
        constructor();
        isEmpty(): boolean;
    }
}
declare module "foundation/service/common/content/ZipUtil" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ZipResult } from "foundation/service/common/content/ZipResult";
    export class FileMessage {
        size: any;
        name: any;
        path: string;
    }
    export class ZipUtil extends InstanceObject {
        static compressFileAsync(sourceFileName: string, targetFileName: string): Promise<ZipResult>;
        static compressPathAsync(context: IContext, sourcePath: string, targetFileName: string): Promise<ZipResult>;
        static readFile(path: string, filesList: any): void;
        static decompressFileAsync(sourceFileName: string, targetFileName: string): Promise<ZipResult>;
        private static innerDecompressProcess;
        static decompressPathAsync(sourceFileName: string, targetPath: string): Promise<ZipResult>;
        static decompressPath2Async(sourceFileName: string, targetPath: string): Promise<ZipResult>;
        static decompressBuffer(zipData: any, targetFileName: string): Promise<ZipResult>;
        static compressDatasAsync(files: {
            path: string;
            data: Buffer;
        }[], options?: any): Promise<ZipResult>;
        static getZipPathAsync(sourceFileName: string): Promise<ZipResult>;
    }
}
declare module "foundation/service/common/database/DatasetOperateEnum" {
    export class DatasetOperateEnum {
        static GET: number;
        static INSERT: number;
        static UPDATE: number;
        static DELETE: number;
    }
}
declare module "foundation/service/common/database/FieldTypeEnum" {
    export class FieldTypeEnum {
        static STRING: string;
        static INTEGER: string;
        static FLOAT: string;
        static DATETIME: string;
    }
}
declare module "foundation/service/common/database/mysql/MySqlUtil" {
    export class MySqlUtil {
        static DATE_FORMAT: string;
    }
}
declare module "foundation/service/common/database/util/DataCondition" {
    import { SearchCondition } from 'cross/data/module/dataset/SearchCondition';
    import { FieldCompareEnum } from "foundation/service/common/database/FieldCompareEnum";
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    export class DataCondition extends SearchCondition {
        addCompare(field: FieldMeta, compareCd: FieldCompareEnum, value: any): void;
    }
}
declare module "foundation/service/common/datetime/ServerDatetimeService" {
    import { DateTimeService } from 'cross/runtime/module/date/DateTimeService';
    import { InvokeThread } from 'cross/runtime/module/thread/InvokeThread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { DataConnectionService } from "foundation/service/common/database/DataConnectionService";
    export class ServerDatetimeService extends Service {
        protected _invokeThread: InvokeThread;
        protected _threadService: ThreadService;
        protected _dataConnectionService: DataConnectionService;
        protected _dateTimeService: DateTimeService;
        onActive(): void;
        updateDateTimeAsync(): Promise<void>;
        onRefreshDateTime(): void;
        onDeactive(): void;
    }
}
declare module "foundation/service/common/framework/ClientApplication" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BaseApplication } from 'cross/system/framework/BaseApplication';
    export class ClientApplication extends BaseApplication {
        version: string;
        loggerParameters: boolean;
        constructor();
        processAsync(args: any): Promise<ResultObject>;
        shutdown(): void;
        static get instance(): ClientApplication;
    }
}
declare module "foundation/service/common/framework/ProcessApplicationParameters" {
    export type ProcessApplicationParameters = {
        createServer?: boolean;
        port?: number;
    };
}
declare module "foundation/service/common/hardware/HardwareUtil" {
    export class HardwareUtil {
        static get platform(): string;
        static get platformVersion(): string;
        static get hostName(): string;
        static get arch(): string;
        static get userName(): string;
        static get nodeVersion(): string;
        static get nodeEngine(): string;
        static get processMemory(): any;
        static memoryTotal(): number;
        static memoryFree(): number;
        protected static innerCpuAverage(cpu: any): any;
        static cpuLoad(): number;
        static getRamRss(): number;
        static getCpuSpeed(): number;
        static getCpuInfo(jtarget?: any): any;
        static getStatisticsInfo(): any;
        static getInfo(): any;
    }
}
declare module "foundation/service/common/oss/OssCacheService" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    export class OssCacheService extends Service {
        cacheEnable: boolean;
        cachePath: string;
        protected _environmentService: EnvironmentService;
        constructor();
        mockFileName(fielName: string): string;
        unmockFileName(fielName: string): void;
    }
}
declare module "foundation/service/common/oss/OssContentOptions" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class OssContentOptions extends InstanceObject {
        recurse: boolean;
        filter: any;
        history: boolean;
        constructor();
    }
}
declare module "foundation/service/common/oss/OssOptions" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class OssOptions extends InstanceObject {
        endpoint: string;
        region: string;
        accessKeyId: string;
        accessKeySecret: string;
        bucket: string;
        localPath: string;
        readTimeout: number;
        writeTimeout: number;
        secure: boolean;
    }
}
declare module "foundation/service/common/oss/OssResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class OssResult extends ResultObject {
        optionRetry: boolean;
        count: number;
        size: number;
        heads: any;
        constructor();
        isEmpty(): boolean;
        isExists(): boolean;
        assign(result: OssResult): any;
        free(): void;
    }
}
declare module "foundation/service/common/oss/OssConnection" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Stream } from 'stream';
    import { OssContentOptions } from "foundation/service/common/oss/OssContentOptions";
    import { OssOptions } from "foundation/service/common/oss/OssOptions";
    import { OssResult } from "foundation/service/common/oss/OssResult";
    export class OssConnection extends Dispatcher {
        options: OssOptions;
        optionFast: boolean;
        fastExcludes: Types<string>;
        private versionRegExp;
        constructor();
        setup(options: OssOptions): void;
        getBucketInfoAsync(name: string): Promise<OssResult>;
        existsPathAsync(context: IContext, remotePath: string): Promise<OssResult>;
        existsObjectAsync(context: IContext, remotePath: string): Promise<OssResult>;
        listAsync(context: IContext, remotePath: string): Promise<OssResult>;
        listFileAsync(context: IContext, remotePath: string): Promise<OssResult>;
        downloadStringAsync(context: IContext, remoteName: string, charset?: string): Promise<OssResult>;
        downloadObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadJsonObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadFileAsync(context: IContext, remoteName: string, fileName: string): Promise<OssResult>;
        downloadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadStringAsync(context: IContext, remoteName: string, data: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadStreamAsync(context: IContext, remoteName: string, data: Stream | Uint8Array, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        downloadBufferAsync(context: IContext, remoteFileName: string, options?: any): Promise<OssResult>;
        uploadObjectAsync(context: IContext, remoteName: string, data: any, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadJsonObjectAsync(context: IContext, remoteName: string, data: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadFileAsync(context: IContext, remoteName: string, fileName: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadPathByZipAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        copyAsync(context: IContext, remoteSourceName: string, remoteTargetName: string): Promise<OssResult>;
        deleteAsync(context: IContext, remoteName: string): Promise<OssResult>;
        deletePathAsync(context: IContext, remotePath: string): Promise<OssResult>;
        freeAsync(): Promise<any>;
    }
}
declare module "foundation/service/common/oss/OssContentTypeEnum" {
    export class OssContentTypeEnum {
        static Unknown: string;
        static Folder: string;
        static Object: string;
    }
}
declare module "foundation/service/common/oss/OssContent" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { OssContentTypeEnum } from "foundation/service/common/oss/OssContentTypeEnum";
    export class OssContent extends InstanceObject {
        typeCd: OssContentTypeEnum;
        name: string;
        path: string;
        heads: any;
        content: any;
        size: number;
    }
}
declare module "foundation/service/common/oss/OssUtil" {
    export class OssUtil {
        static makeFileName(path: string): string;
        static makePath(path: string): string;
        static getPathName(path: string): string;
        static getPath(path: string): string;
        static getObjectName(path: string): string;
        static format(path: string): string;
        static join(path1: string, path2: string): string;
        static joins(...paths: Array<string>): string;
    }
}
declare module "foundation/service/common/oss/OssFileConnection" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { OssConnection } from "foundation/service/common/oss/OssConnection";
    import { OssContentOptions } from "foundation/service/common/oss/OssContentOptions";
    import { OssOptions } from "foundation/service/common/oss/OssOptions";
    import { OssResult } from "foundation/service/common/oss/OssResult";
    export class OssFileConnection extends OssConnection {
        rootDir: string;
        setup(options: OssOptions): void;
        existsPathAsync(context: IContext, remotePath: string): Promise<OssResult>;
        existsObjectAsync(context: IContext, remotePath: string): Promise<OssResult>;
        listAsync(context: IContext, remotePath: string): Promise<OssResult>;
        listFileAsync(context: IContext, remotePath: string): Promise<OssResult>;
        downloadObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadFileAsync(context: IContext, remoteName: string, fileName: string): Promise<OssResult>;
        downloadPathAsync(context: IContext, remotePath: string, path: string): Promise<OssResult>;
        uploadObjectAsync(context: IContext, remoteName: string, data: any, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadJsonObjectAsync(context: IContext, remoteName: string, jdata: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadFileAsync(context: IContext, remoteName: string, fileName: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadPathByZipAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        copyAsync(context: IContext, remoteSourceName: string, remoteTargetName: string): Promise<OssResult>;
        deleteAsync(context: IContext, ossFileName: string): Promise<OssResult>;
        deletePathAsync(context: IContext, path: string): Promise<OssResult>;
    }
}
declare module "foundation/service/common/oss/OssConstants" {
    export class OssConstants {
        static StatisticsMinLimit: number;
    }
}
declare module "foundation/service/common/oss/OssNetConnection" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Stream } from 'stream';
    import { OssCacheService } from "foundation/service/common/oss/OssCacheService";
    import { OssConnection } from "foundation/service/common/oss/OssConnection";
    import { OssContentOptions } from "foundation/service/common/oss/OssContentOptions";
    import { OssOptions } from "foundation/service/common/oss/OssOptions";
    import { OssResult } from "foundation/service/common/oss/OssResult";
    export class OssNetConnection extends OssConnection {
        readDataOptions: any;
        writeDataOptions: any;
        protected _client: any;
        protected _environmentService: EnvironmentService;
        protected _cacheService: OssCacheService;
        setup(options: OssOptions): void;
        existsPathAsync(context: IContext, remotePath: string): Promise<OssResult>;
        existsObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        listAsync(context: IContext, remotePath: string): Promise<OssResult>;
        listFileAsync(context: IContext, remotePath: string): Promise<OssResult>;
        downloadStringAsync(context: IContext, remoteName: string, charset?: string): Promise<OssResult>;
        downloadObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadJsonObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        getStream(remoteFileName: string, targetFileName: string, options?: any): Promise<OssResult>;
        downloadBufferAsync(context: IContext, remoteFileName: string, options?: any): Promise<OssResult>;
        downloadFileAsync(context: IContext, remoteName: string, fileName: string): Promise<OssResult>;
        downloadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadStringAsync(context: IContext, remoteName: string, data: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadStreamAsync(context: IContext, remoteName: string, data: Stream | Uint8Array, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadObjectAsync(context: IContext, remoteName: string, data: any, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadJsonObjectAsync(context: IContext, remoteName: string, jdata: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadFileAsync(context: IContext, remoteName: string, fileName: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadPathByZipAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        copyAsync(context: IContext, remoteSourceName: string, remoteTargetName: string): Promise<OssResult>;
        deleteAsync(context: IContext, remoteName: string): Promise<OssResult>;
        deletePathAsync(context: IContext, remotePath: string): Promise<OssResult>;
    }
}
declare module "foundation/service/common/oss/OssNetConnectionWrapper" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Stream } from 'stream';
    import { OssContentOptions } from "foundation/service/common/oss/OssContentOptions";
    import { OssNetConnection } from "foundation/service/common/oss/OssNetConnection";
    import { OssOptions } from "foundation/service/common/oss/OssOptions";
    import { OssResult } from "foundation/service/common/oss/OssResult";
    export class OssNetConnectionWrapper extends OssNetConnection {
        opts: any;
        protected _ossNetConnection: OssNetConnection;
        constructor();
        setup(options: OssOptions): void;
        downloadStringAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadJsonObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadFileAsync(context: IContext, remoteName: string, fileName: string): Promise<OssResult>;
        downloadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadStreamAsync(context: IContext, remoteName: string, data: Stream | Uint8Array, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadObjectAsync(context: IContext, remoteName: string, data: any, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadJsonObjectAsync(context: IContext, remoteName: string, jdata: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadFileAsync(context: IContext, remoteName: string, fileName: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        existsObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
    }
}
declare module "foundation/service/common/oss/OssConnectionPool" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { OssConnection } from "foundation/service/common/oss/OssConnection";
    import { OssOptions } from "foundation/service/common/oss/OssOptions";
    export class OssConnectionPool extends InstanceObject {
        name: string;
        modeCd: string;
        options: OssOptions;
        protected _connections: Types<OssConnection>;
        allocCount: number;
        freeCount: number;
        constructor();
        get useCount(): number;
        loadConfig(jconfig: any): void;
        allocConnectionAsync(isTimeout?: boolean): Promise<OssConnection>;
        testAsync(context: IContext): Promise<ResultObject>;
        onFreeConnection(sender: ListenerContext, event: EventObject): void;
        freeConnectionAsync(connection: OssConnection): Promise<ResultEnum>;
        shutdown(): void;
    }
}
declare module "foundation/service/common/oss/OssConnectionService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { Stream } from 'stream';
    import { OssCacheService } from "foundation/service/common/oss/OssCacheService";
    import { OssConnection } from "foundation/service/common/oss/OssConnection";
    import { OssConnectionPool } from "foundation/service/common/oss/OssConnectionPool";
    import { OssContentOptions } from "foundation/service/common/oss/OssContentOptions";
    import { OssResult } from "foundation/service/common/oss/OssResult";
    export class OssConnectionService extends Service {
        protected _defaultName: string;
        protected _cacheEnable: boolean;
        protected _cachePath: string;
        protected _pools: Dictionary<OssConnectionPool>;
        protected _environmentService: EnvironmentService;
        protected _cacheService: OssCacheService;
        get defaultName(): string;
        get pools(): Dictionary<OssConnectionPool>;
        initializeConfig(jconfig: any): void;
        statusUpdate(): void;
        testAsync(context: IContext): Promise<ResultObject>;
        allocConnectionAsync(name?: string, isTimeout?: boolean): Promise<OssConnection>;
        listAsync(context: IContext, remotePath: string): Promise<OssResult>;
        downloadStringAsync(context: IContext, remoteName: string, charset?: string): Promise<OssResult>;
        downloadObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadJsonObjectAsync(context: IContext, remoteName: string): Promise<OssResult>;
        downloadFileAsync(context: IContext, remoteName: string, fileName: string): Promise<OssResult>;
        downloadBufferAsync(context: IContext, remoteName: string, options?: any): Promise<OssResult>;
        downloadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadStringAsync(context: IContext, remoteName: string, data: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadStreamAsync(context: IContext, remoteName: string, data: Stream | Uint8Array, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadObjectAsync(context: IContext, remoteName: string, data: any, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadJsonObjectAsync(context: IContext, remoteName: string, jdata: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadFileAsync(context: IContext, remoteName: string, fileName: string, mime?: any, meta?: any, headers?: any): Promise<OssResult>;
        uploadPathAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        uploadPathByZipAsync(context: IContext, remotePath: string, path: string, options?: OssContentOptions): Promise<OssResult>;
        copyAsync(context: IContext, remoteSourceName: string, remoteTargetName: string): Promise<OssResult>;
        deleteAsync(context: IContext, remoteName: string): Promise<OssResult>;
        existsPathAsync(context: IContext, remotePath: string): Promise<OssResult>;
        existsObjectAsync(context: IContext, remotePath: string): Promise<OssResult>;
        deletePathAsync(context: IContext, remotePath: string): Promise<OssResult>;
        shutdown(): void;
    }
}
declare module "foundation/service/common/router/database/LibraryTypeEnum" {
    export enum LibraryTypeEnum {
        All = "all",
        Module = "module",
        Resource = "resource"
    }
}
declare module "foundation/service/common/router/database/ServerWarehouseService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { ServiceJsonConnection } from 'cross/system/module/net/ServiceJsonConnection';
    export class ServerWarehouseService extends Service {
        url: string;
        database: any;
        private _dataSpaces;
        private _baseDbConfigure;
        protected _serviceJsonConnection: ServiceJsonConnection;
        protected _environmentService: EnvironmentService;
        protected _jsonService: JsonService;
        constructor();
        initializeConfig(jconfig: any): void;
        makeUrl(tenantId: string): string;
        getWarehouseIdAsync(tenantId: string): Promise<ResultObject>;
        getWarehouseDatabaseIdsAsync(context: IContext, moduleLibraryId: string, resourceLibraryId: string): Promise<any>;
        getBaseDbId(type: string): string;
        getDataSpaces(type: string): Array<string>;
        getDatabaseName(config: string, code: string): string;
    }
}
declare module "foundation/service/common/login/LoginTypeEnum" {
    export class LoginTypeEnum {
        static Center: string;
        static Platform: string;
    }
}
declare module "foundation/service/common/login/ServerLoginService" {
    import { Service } from 'cross/runtime/module/Service';
    export class ServerLoginService extends Service {
        type: string;
        initializeConfig(jconfig: any): void;
        isPlatformMode(): boolean;
    }
}
declare module "foundation/service/common/session/ServerSessionUtil" {
    export class ServerSessionUtil {
        static makeSessionId(): string;
        static makeRequestId(request: any): string;
        static findRequestSessionId(request: any): string;
    }
}
declare module "foundation/service/common/session/ServerSessionService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { CacheDeviceService } from 'cross/core/device/cache/CacheDeviceService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { LogicSessionService } from 'cross/data/module/logic/session/LogicSessionService';
    import { ServiceJsonConnection } from 'cross/system/module/net/ServiceJsonConnection';
    import { ServerWarehouseService } from "foundation/service/common/router/database/ServerWarehouseService";
    import { ServerLoginService } from "foundation/service/common/login/ServerLoginService";
    export class ServerSessionService extends Service {
        type: string;
        typeConfigure: any;
        cookieConfigure: any;
        sessionInterval: number;
        protected _url: string;
        protected _store: any;
        protected _environmentService: EnvironmentService;
        protected _jsonService: JsonService;
        protected _serviceJsonConnection: ServiceJsonConnection;
        protected _cacheDeviceService: CacheDeviceService;
        protected _serverLoginService: ServerLoginService;
        protected _serverWarehouseService: ServerWarehouseService;
        protected _sessionService: LogicSessionService;
        initializeConfig(jconfig: any): void;
        makeSessionId: (request: any) => string;
        startupAsync(handle: any): Promise<ResultObject>;
        protected makeSessionUrl(sessionId: string): string;
        loadSessionAsync(sessionStore: any, sessionId: string): Promise<ResultObject>;
        loadSessionByIdAsync(sessionId: string): Promise<ResultObject>;
        testAsync(context: IContext): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/framework/ServerApplicationStatusEnum" {
    export class ServerApplicationStatusEnum {
        static Process: string;
        static Stop: string;
    }
}
declare module "foundation/service/common/framework/ServerApplicationService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ListenerAsyncThread } from 'cross/runtime/module/thread/ListenerAsyncThread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { ServerApplicationStatusEnum } from "foundation/service/common/framework/ServerApplicationStatusEnum";
    export type ServerApplicationInfo = {
        process_id: number;
        status_cd: ServerApplicationStatusEnum;
        hardware: any;
    };
    export class ServerApplicationService extends Service {
        identityCode: string;
        processId: number;
        optionReportStatus: boolean;
        protected _statusFirst: boolean;
        protected _thread: ListenerAsyncThread;
        protected _threadConsole: ThreadService;
        protected _cacheService: CacheConnectionService;
        constructor();
        onSetup(args?: any): void;
        checkAsync(context?: IContext): Promise<ResultObject>;
        onProcessAsync(): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/framework/ProcessApplication" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { ApplicationParameters } from 'cross/runtime/framework/ApplicationParameters';
    import { BaseApplication } from 'cross/system/framework/BaseApplication';
    import { ProcessApplicationParameters } from "foundation/service/common/framework/ProcessApplicationParameters";
    export class ProcessApplication extends BaseApplication {
        projectName: string;
        moduleName: string;
        moduleVersion: string;
        parameterModeCd: string;
        processParameters: ProcessApplicationParameters;
        port: number;
        pathMock: string;
        pathContent: string;
        pathView: string;
        pathHtml: string;
        pathTemp: string;
        pathWork: string;
        protected _loggerFile: any;
        protected _loggerTrace: any;
        protected _contextService: ContextService;
        constructor();
        onSetup(settings: any): void;
        makeRootPath(path: string): string;
        doLogger(jlogger: any, output?: boolean): void;
        onLogger(sender: ListenerContext, event: EventObject): void;
        protected onDomainException: (error: any) => void;
        openAsync(context?: IContext, parameters?: ProcessApplicationParameters): Promise<ResultObject>;
        readyAsync(context?: IContext): Promise<ResultObject>;
        loadParametersAsync(parameters: ApplicationParameters): Promise<ResultObject>;
        startupAsync(args?: Array<string>, isProcess?: boolean): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/router/message/ServiceMessage" {
    import { IResult } from 'cross/runtime/lang/IResult';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MessageObject } from 'cross/data/module/message/MessageObject';
    import { LogicResultEnum } from 'foundation/data/common/logic/LogicResultEnum';
    export class ServiceMessage extends MessageObject {
        resultCd: ResultEnum;
        result: LogicResultEnum;
        code: string;
        messageType: string;
        content: any;
        error: Error;
        stack: string;
        constructor();
        success(content?: any): void;
        loadJson(jconfig: any, context?: any): void;
        saveJson(target?: any): any;
        addResult(result: IResult): void;
    }
}
declare module "foundation/service/common/router/RouterSettings" {
    export type RouterSettings = {
        optionWorker?: boolean;
        optionFile?: boolean;
        optionLogger?: boolean;
        optionSession?: boolean;
        optionLogin?: boolean;
        optionTransaction?: boolean;
        optionPipe?: boolean;
        optionCache?: boolean;
        cacheTimeout?: number;
    };
}
declare module "foundation/service/common/router/RouterSettingUtil" {
    import { RouterSettings } from "foundation/service/common/router/RouterSettings";
    export class RouterSettingUtil {
        static make(options?: RouterSettings): RouterSettings;
    }
}
declare module "foundation/service/common/router/Router" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { RouterSettings } from "foundation/service/common/router/RouterSettings";
    export class Router extends InstanceObject {
        private static Logger;
        parent: Router;
        name: string;
        uri: string;
        handleRouter: any;
        constructor(parent?: Router);
        register(): void;
        protected generateInvoker(method: string, path: string, callback: Function, options?: RouterSettings): any;
        registerGet(path: string, callback: Function, options?: RouterSettings): void;
        registerPut(path: string, callback: Function, options?: RouterSettings): void;
        registerDelete(path: string, callback: Function, options?: RouterSettings): void;
        registerPost(path: string, callback: Function, options?: RouterSettings): void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/RouteUtil" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ServiceMessage } from "foundation/service/common/router/message/ServiceMessage";
    export class RouteUtil {
        static getIp(request: any): string;
        static sendText(request: any, response: any, text: string): void;
        static sendBinary(request: any, response: any, buffer: Uint8Array): void;
        static sendMessage(request: any, response: any, message: ServiceMessage, parameters?: any): void;
        static sendContextMessage(context: IContext, request: any, response: any, message: ServiceMessage, parameters?: any): void;
        static sendJsonString(request: any, response: any, text: string): void;
        static sendJsonText(request: any, response: any, jconfig: any): void;
        static sendJsonObject(request: any, response: any, jconfig: any): void;
        static sendContextJsonObject(context: IContext, request: any, response: any, jconfig: any): void;
        static sendJsonFile(request: any, response: any, fileName: string): void;
        static sendFile(request: any, response: any, fileName: string): void;
        static sendFileText(request: any, response: any, fileName: string): void;
        static sendFileContent(request: any, response: any, content: any): void;
        static sendException(request: any, response: any, error: any): void;
        static sendContextException(context: IContext, request: any, response: any, error: any): void;
        static getExceptionMessageText(error: any): string;
        static sendInvalidCall(request: any, response: any): void;
    }
}
declare module "foundation/service/common/router/RouterErrorDispatcher" {
    import { Router } from "foundation/service/common/router/Router";
    export class RouterErrorDispatcher extends Router {
        onError404(request: Request, response: Response): void;
        onError500(error: Error, request: any, response: any, next: any): void;
        makeRouter(app: any): void;
    }
}
declare module "foundation/service/common/router/RouterDeclareInfo" {
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    export class RouterDeclareInfo extends BaseObject {
        optionValid: boolean;
        optionRepeat: boolean;
        name: string;
        uri: string;
        levelCd: any;
        level: number;
        type: any;
        protected _instance: any;
        getInstance(): any;
    }
}
declare module "foundation/service/common/router/RouterService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { Service } from 'cross/runtime/module/Service';
    import { RouterDeclareInfo } from "foundation/service/common/router/RouterDeclareInfo";
    export class RouterService extends Service {
        version: string;
        date: string;
        protected _declares: Types<RouterDeclareInfo>;
        protected _declareNames: Dictionary<RouterDeclareInfo>;
        protected _declareUris: Dictionary<RouterDeclareInfo>;
        protected _contextService: ContextService;
        get declares(): Types<RouterDeclareInfo>;
        findDeclareByClazz(clazz: any): RouterDeclareInfo;
        registerDeclare(declare: RouterDeclareInfo): void;
        update(): void;
        createContextAsync(request: any, response: any): Promise<IContext>;
        onReceiveAsync(context: any, request: any, response: any): Promise<any>;
        onSendAsync(context: any, request: any, response: any): Promise<any>;
        onErrorAsync(context: any, request: any, response: any): Promise<any>;
        onReceive(request: any, response: any): void;
        onSend(request: any, response: any): void;
    }
}
declare module "foundation/service/common/framework/ServerApplicationParameters" {
    import { ProcessApplicationParameters } from "foundation/service/common/framework/ProcessApplicationParameters";
    export type ServerApplicationParameters = ProcessApplicationParameters & {};
}
declare module "foundation/service/common/framework/ServerConstants" {
    export class ServerConstants {
        static JsonLimitBytes: number;
    }
}
declare module "foundation/service/common/framework/ServerApplication" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ApplicationParameters } from 'cross/runtime/framework/ApplicationParameters';
    import { CacheService } from 'cross/core/module/cache/CacheService';
    import { RouterService } from "foundation/service/common/router/RouterService";
    import { ProcessApplication } from "foundation/service/common/framework/ProcessApplication";
    import { ServerApplicationParameters } from "foundation/service/common/framework/ServerApplicationParameters";
    export class ServerApplication extends ProcessApplication {
        optionListen: boolean;
        threadCount: number;
        express: any;
        server: any;
        serverIo: any;
        protected _cacheService: CacheService;
        protected _routerService: RouterService;
        constructor();
        onSetup(settings: any): void;
        loadParametersAsync(parameters: ApplicationParameters): Promise<ResultObject>;
        onFilter(request: any, response: any, next: any): void;
        onTimeout: (request: any, response: any, next: any) => void;
        mockFileName(fielName: string): string;
        makeRouter(app: any): void;
        openAsync(context?: IContext, parameters?: ServerApplicationParameters): Promise<ResultObject>;
        protected onServerError: (error: any) => never;
        protected onListening: (event: any) => void;
        protected onWebSocketConnection: (socket: any) => void;
        startupAsync(args?: Array<string>, isProcess?: boolean): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/process/ProcessObjectResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ProcessObjectResult extends ResultObject {
        processId: string;
        free(): void;
    }
}
declare module "foundation/service/common/process/message/ExceptionInsertResponse" {
    import { StructureObject } from 'cross/runtime/framework/base/StructureObject';
    import { MessageDescription } from 'cross/data/module/message/MessageDescription';
    import { MessageResponse } from 'cross/data/module/message/MessageResponse';
    export class ExceptionInsertResponseVo extends StructureObject {
        exceptionId: string;
        constructor();
    }
    export class ExceptionInsertResponse extends MessageResponse {
        static CLASS_DESCRIPTION: MessageDescription;
        protected _data: ExceptionInsertResponseVo;
        constructor();
        get data(): ExceptionInsertResponseVo;
    }
}
declare module "foundation/service/common/process/message/ExceptionInsertRequest" {
    import { StructureObject } from 'cross/runtime/framework/base/StructureObject';
    import { IMessageContext } from 'cross/data/module/message/IMessageContext';
    import { MessageDescription } from 'cross/data/module/message/MessageDescription';
    import { MessageRequest } from 'cross/data/module/message/MessageRequest';
    import { ExceptionInsertResponse } from "foundation/service/common/process/message/ExceptionInsertResponse";
    export class ExceptionInsertRequestVo extends StructureObject {
        host: string;
        info: any;
        port: string;
        type: any;
        constructor();
    }
    export class ExceptionInsertRequest extends MessageRequest {
        static CLASS_DESCRIPTION: MessageDescription;
        protected _data: ExceptionInsertRequestVo;
        constructor();
        get data(): ExceptionInsertRequestVo;
        sendAsync(context?: IMessageContext): Promise<ExceptionInsertResponse>;
    }
}
declare module "foundation/service/common/process/ServiceExceptionService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { StatisticsService } from 'cross/runtime/module/statistics/StatisticsService';
    import { Service } from 'cross/runtime/module/Service';
    export class ServiceExceptionService extends Service {
        protected _optionLogger: boolean;
        optionPack: boolean;
        protected _workPath: string;
        protected _nodePath: string;
        protected _processFileName: string;
        protected _optionFileName: string;
        protected _resultFileName: string;
        protected _resultContentFileName: string;
        protected _statisticsFileName: string;
        protected _loggerFileName: string;
        protected _environmentService: EnvironmentService;
        protected _statisticsService: StatisticsService;
        constructor();
        initializeConfig(jconfig: any): void;
        exceptionInsertAsync(content: any): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/process/ServiceProcessStatisticsEnum" {
    export class ServiceProcessStatisticsEnum {
        static Process: string;
    }
}
declare module "foundation/service/common/process/ServiceProcessTypeEnum" {
    export class ServiceProcessTypeEnum {
        static Invoke: string;
        static AsyncInvoke: string;
        static DataAsyncInvoke: string;
        static Router: string;
    }
}
declare module "foundation/service/common/process/ServiceProcessService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { StatisticsService } from 'cross/runtime/module/statistics/StatisticsService';
    import { Service } from 'cross/runtime/module/Service';
    import { ProcessObjectResult } from "foundation/service/common/process/ProcessObjectResult";
    import { ServiceExceptionService } from "foundation/service/common/process/ServiceExceptionService";
    import { ServiceProcessTypeEnum } from "foundation/service/common/process/ServiceProcessTypeEnum";
    export type ProcessRunnerDeclareInfo = {
        code: string;
        owner: any;
        method: Function;
        timeout?: number;
        isPushId?: boolean;
    };
    export class ServiceProcessService extends Service {
        protected _optionLogger: boolean;
        optionPack: boolean;
        protected _declares: Types<ProcessRunnerDeclareInfo>;
        protected _workPath: string;
        protected _nodePath: string;
        protected _processFileName: string;
        protected _optionFileName: string;
        protected _resultFileName: string;
        protected _resultContentFileName: string;
        protected _statisticsFileName: string;
        protected _loggerFileName: string;
        protected _environmentService: EnvironmentService;
        protected _contextService: ContextService;
        protected _statisticsService: StatisticsService;
        protected _serviceExceptionService: ServiceExceptionService;
        constructor();
        get workPath(): string;
        get nodePath(): string;
        get processFileName(): string;
        get resultFileName(): string;
        initializeConfig(jconfig: any): void;
        findDeclareByCode(code: string): ProcessRunnerDeclareInfo;
        registerDeclare(code: string, method: any, owner: any, timeout?: number, isPushId?: boolean): void;
        timeoutProcess(processId: string, timeout?: number): void;
        timeoutProcessAsync(processId: string, timeout?: number): Promise<ResultObject>;
        processAsync(processType: ServiceProcessTypeEnum, code: string, args: any[], isPushId?: boolean): Promise<ProcessObjectResult>;
        processRunnerAsync(declare: ProcessRunnerDeclareInfo, args: any[], useData: boolean): Promise<ResultObject>;
        onProcessAsync(processId: string): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/framework/ServerUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ProcessArgs } from 'cross/system/base/process/ProcessArgs';
    export class ServerUtil {
        static trackStartup(code: string, args: ProcessArgs): void;
        static trackShutdown(code: string): void;
        static getRootPath(): string;
        static nativeStartupAsync(): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/framework/ServerProcessApplication" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { StatisticsService } from 'cross/runtime/module/statistics/StatisticsService';
    import { ProcessApplication } from "foundation/service/common/framework/ProcessApplication";
    import { ProcessApplicationParameters } from "foundation/service/common/framework/ProcessApplicationParameters";
    export class ServerProcessApplication extends ProcessApplication {
        protected _statisticsService: StatisticsService;
        constructor();
        openAsync(context?: IContext, parameters?: ProcessApplicationParameters): Promise<ResultObject>;
        startupAsync(args?: Array<string>, isProcess?: boolean): Promise<ResultObject>;
        startupTimeoutAsync(timeout: number): Promise<ResultObject>;
        processAsync(context?: IContext): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/framework/ServerRootContext" {
    import { GlobalRootContext } from 'cross/runtime/module/context/GlobalRootContext';
    export class ServerRootContext extends GlobalRootContext {
        constructor();
    }
}
declare module "foundation/service/common/framework/ServerWorkerApplication" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ApplicationParameters } from 'cross/runtime/framework/ApplicationParameters';
    import { ProcessApplication } from "foundation/service/common/framework/ProcessApplication";
    import { ProcessApplicationParameters } from "foundation/service/common/framework/ProcessApplicationParameters";
    export class ServerWorkerApplication extends ProcessApplication {
        constructor();
        loadParametersAsync(parameters: ApplicationParameters): Promise<ResultObject>;
        openAsync(context?: IContext, parameters?: ProcessApplicationParameters): Promise<ResultObject>;
        startupAsync(args?: Array<string>, isProcess?: boolean): Promise<ResultObject>;
        processAsync(): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "foundation/service/common/lock/ServiceLockService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { GlobalLockService } from 'cross/system/device/lock/GlobalLockService';
    export class ServiceLockService extends Service {
        protected _globalLockService: GlobalLockService;
        lockAsync(context: ContextObject, key: string, lockOption?: any, timeout?: number): Promise<ResultObject<any>>;
    }
}
declare module "foundation/service/common/logic/LogicContext" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { DataConnection } from "foundation/service/common/database/DataConnection";
    import { DataContext } from "foundation/service/common/database/DataContext";
    import { DataResult } from "foundation/service/common/database/DataResult";
    export class LogicContext extends DataContext {
        name: string;
        protected _vaild: boolean;
        protected _dataConnection: DataConnection;
        constructor(dataConnection: DataConnection, parent?: IContext);
        getConnectionAsync(name?: string): Promise<DataConnection>;
        commitAsync(): Promise<DataResult>;
        rollbackAsync(): Promise<DataResult>;
        disposeAsync(): Promise<void>;
    }
}
declare module "foundation/service/common/logic/DataLogicService" {
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { Service } from 'cross/runtime/module/Service';
    import { DataConnectionService } from "foundation/service/common/database/DataConnectionService";
    import { LogicContext } from "foundation/service/common/logic/LogicContext";
    export class DataLogicService extends Service {
        allocCount: number;
        freeCount: number;
        protected _contextService: ContextService;
        protected _dataConnectionService: DataConnectionService;
        constructor();
        useCount(): number;
        onSetup(jconfig: any): void;
        onActive(): void;
        allocContextAsync(name?: string): Promise<LogicContext>;
        freeContextAsync(context?: LogicContext): Promise<void>;
        dispose(): void;
    }
}
declare module "foundation/service/common/messagequeue/ConsumerConnection" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ConsumerConnection extends Dispatcher {
        name: string;
        protected _isConnected: boolean;
        get isConnected(): boolean;
        runAsync: (callBackAsync: Function, result: ResultObject, p1?: any, p2?: any, p3?: any, p4?: any) => Promise<void>;
    }
}
declare module "foundation/service/common/messagequeue/ServerMessageQueueCompressionEnum" {
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class ServerMessageQueueCompressionEnum extends EnumerationObject {
        static NONE: string;
        static ZSTD: string;
        static GZIP: string;
        static LZ4: string;
        static Snappy: string;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaCompressionEnum" {
    import { ServerMessageQueueCompressionEnum } from "foundation/service/common/messagequeue/ServerMessageQueueCompressionEnum";
    import { CompressionTypes } from 'kafkajs';
    export class KafkaCompressionEnum extends ServerMessageQueueCompressionEnum {
        static getCompressionType(code: string): CompressionTypes;
    }
}
declare module "foundation/service/common/messagequeue/ProducerConnection" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ProducerConnection extends Dispatcher {
        name: string;
        options: any;
        protected _isConnected: boolean;
        get isConnected(): boolean;
        sendAsync(messages: Array<any>, topic: string): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/messagequeue/ServerMessageQueueConnection" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ConsumerConnection } from "foundation/service/common/messagequeue/ConsumerConnection";
    import { ProducerConnection } from "foundation/service/common/messagequeue/ProducerConnection";
    export class ServerMessageQueueConnection extends Dispatcher {
        getProducer(name?: string): ProducerConnection;
        getConsumer(name?: string): ConsumerConnection;
        sendAsync(messages: Array<any>, topic: string, name?: string): Promise<ResultObject>;
        receiveAsync(callBackAsync: Function, result: ResultObject, batch: boolean, name?: string, p1?: any, p2?: any, p3?: any, p4?: any): Promise<void>;
        shutDownAsync(component: any): Promise<void>;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaConsumerOptions" {
    import * as kafka from 'kafkajs';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class KafkaConsumerOptions extends InstanceObject {
        client: kafka.Kafka;
        clientId: string;
        topics: Array<string>;
        groupId: string;
        autoCommit: boolean;
        fromBeginning: boolean;
        name: string;
        rebalanceTimeout: number;
        heartbeatInterval: number;
        sessionTimeout: number;
        serviceName: string;
        retry: kafka.RetryOptions;
        healthInterval: number;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaRebalanceEnum" {
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class KafkaRebalanceEnum extends EnumerationObject {
        static EMPTY: string;
        static DEAD: string;
        static PREPARINGREBALANCE: string;
        static COMPLETINGREBALANCE: string;
        static STABEL: string;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaConsumerConnection" {
    import * as kafka from 'kafkajs';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { ConsumerConnection } from "foundation/service/common/messagequeue/ConsumerConnection";
    import { KafkaConsumerOptions } from "foundation/service/common/messagequeue/kafka/KafkaConsumerOptions";
    export class KafkaConsumerConnection extends ConsumerConnection {
        protected _client: kafka.Kafka;
        options: KafkaConsumerOptions;
        protected _consumer: kafka.Consumer;
        private _thread;
        protected _threadService: ThreadService;
        setup(options: KafkaConsumerOptions): void;
        get consumer(): kafka.Consumer;
        connectionAsync(): Promise<void>;
        subscribeAsync(subscribeInfo: any): Promise<void>;
        checkConsumerHealthStatusAsync(): Promise<ResultObject>;
        runAsync: (callBackAsync: Function, result: ResultObject, p1?: any, p2?: any, p3?: any, p4?: any) => Promise<void>;
        runBacthAsync: (callBackAsync: Function, result: ResultObject, p1?: any, p2?: any, p3?: any, p4?: any) => Promise<void>;
        commitOffsetsAsync(topicPartitions: Array<any>): Promise<void>;
        seek(topic: string, partition: number, offset: string): void;
        disconnectAsync(): Promise<void>;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaOptions" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class KafkaOptions extends InstanceObject {
        brokers: Array<string>;
        producers: Array<any>;
        consumers: Array<any>;
        defaultName: string;
        healthInterval: number;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaProducerOptions" {
    import * as kafka from 'kafkajs';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class kafkaProducerOptions extends InstanceObject {
        client: kafka.Kafka;
        topics: Array<string>;
        acks?: number;
        timeout?: number;
        name: string;
        compression?: string;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaProducerConnection" {
    import * as kafka from 'kafkajs';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ProducerConnection } from "foundation/service/common/messagequeue/ProducerConnection";
    import { kafkaProducerOptions } from "foundation/service/common/messagequeue/kafka/KafkaProducerOptions";
    export class KafkaProducerConnection extends ProducerConnection {
        protected _client: kafka.Kafka;
        protected _producer: kafka.Producer;
        setup(options: kafkaProducerOptions): void;
        get producer(): kafka.Producer;
        connectionAsync(): Promise<void>;
        sendAsync(messages: Array<any>, topic: string): Promise<ResultObject<Array<kafka.RecordMetadata>>>;
        disconnectAsync(): Promise<void>;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaConnection" {
    import * as kafka from 'kafkajs';
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { ServerMessageQueueConnection } from "foundation/service/common/messagequeue/ServerMessageQueueConnection";
    import { KafkaConsumerConnection } from "foundation/service/common/messagequeue/kafka/KafkaConsumerConnection";
    import { KafkaConsumerOptions } from "foundation/service/common/messagequeue/kafka/KafkaConsumerOptions";
    import { KafkaOptions } from "foundation/service/common/messagequeue/kafka/KafkaOptions";
    import { KafkaProducerConnection } from "foundation/service/common/messagequeue/kafka/KafkaProducerConnection";
    export class KafkaConnection extends ServerMessageQueueConnection {
        _options: KafkaOptions;
        protected _client: kafka.Kafka;
        protected _consumerPool: Dictionary<KafkaConsumerConnection>;
        protected _producerPool: Dictionary<KafkaProducerConnection>;
        protected _consumerOptionsPool: Dictionary<KafkaConsumerOptions>;
        private _admin;
        protected _defaultName: string;
        private _host;
        private _port;
        protected _environmentService: EnvironmentService;
        protected _threadService: ThreadService;
        constructor();
        get client(): kafka.Kafka;
        set options(v: KafkaOptions);
        get consumerPool(): Dictionary<KafkaConsumerConnection>;
        get producerPool(): Dictionary<KafkaProducerConnection>;
        get admin(): kafka.Admin;
        setup(): void;
        connectAdminAsync(): Promise<void>;
        disconnectAdminAsync(): Promise<void>;
        listTopicsAsync(): Promise<ResultObject>;
        createTopicsAsync(topicInfos: any, validateOnly?: boolean, waitForLeaders?: boolean, timeout?: number): Promise<void>;
        deleteTopicsAsync(topics: Array<string>, timeout?: number): Promise<ResultObject>;
        getProducer(name?: string): KafkaProducerConnection;
        getConsumer(name?: string): KafkaConsumerConnection;
        sendAsync(messages: any[], topic: string, name?: string): Promise<ResultObject<any>>;
        receiveAsync(callBackAsync: Function, result: ResultObject, batch: boolean, name?: string, p1?: any, p2?: any, p3?: any, p4?: any): Promise<void>;
        shutDownAsync(component: any): Promise<void>;
    }
}
declare module "foundation/service/common/messagequeue/ServerMessageQueueConnectionPool" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ServerMessageQueueConnection } from "foundation/service/common/messagequeue/ServerMessageQueueConnection";
    export class ServerMessageQueueConnectionPool extends InstanceObject {
        protected _name: string;
        get name(): string;
        allocAsync(): Promise<ResultObject<ServerMessageQueueConnection>>;
        testAsync(): Promise<ResultObject>;
        free(connection: ServerMessageQueueConnection): void;
        loadConfig(jconfig: any): void;
        shutdownAsync(): Promise<void>;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaConnectionPool" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ObjectPool } from 'cross/runtime/lang/ObjectPool';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ServerMessageQueueConnectionPool } from "foundation/service/common/messagequeue/ServerMessageQueueConnectionPool";
    import { KafkaConnection } from "foundation/service/common/messagequeue/kafka/KafkaConnection";
    import { KafkaOptions } from "foundation/service/common/messagequeue/kafka/KafkaOptions";
    export class KafkaConnectionPool extends ServerMessageQueueConnectionPool {
        protected _options: KafkaOptions;
        protected _pool: ObjectPool<KafkaConnection>;
        protected _connections: Types<KafkaConnection>;
        constructor();
        get pool(): ObjectPool<KafkaConnection>;
        loadConfig(jconfig: any): void;
        allocAsync(): Promise<ResultObject<KafkaConnection>>;
        free(connection: KafkaConnection): void;
        shutDownAsync(): Promise<void>;
    }
}
declare module "foundation/service/common/messagequeue/kafka/KafkaMessageData" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class KafkaMessageData extends InstanceObject {
        key: any;
        value: any;
        partiton: any;
        timestamp: number;
        headers: any;
    }
}
declare module "foundation/service/common/messagequeue/ServerMessageQueueService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { ServerMessageQueueConnectionPool } from "foundation/service/common/messagequeue/ServerMessageQueueConnectionPool";
    export class ServerMessageQueueService extends Service {
        protected _defaultName: string;
        protected _pools: Dictionary<ServerMessageQueueConnectionPool>;
        get defaultName(): string;
        get pools(): Dictionary<ServerMessageQueueConnectionPool>;
        initializeConfig(jconfig: any): void;
        getPool(name?: string): ServerMessageQueueConnectionPool;
        sendAsync(messages: any[], topic: string, poolName?: string, producerName?: string): Promise<ResultObject>;
        receiveAsync(callBackAsync: Function, result: ResultObject, batch?: boolean, poolName?: string, consumerName?: string, p1?: any, p2?: any, p3?: any, p4?: any): Promise<void>;
        getTopicsAsync(poolName?: string, producerName?: string): Promise<ResultObject>;
        shutdownAsync(): Promise<void>;
    }
}
declare module "foundation/service/common/oss/OssAssetUtil" {
    export class OssAssetUtil {
        static format(text: string): string;
        static formatPathUnitString(text: string): string;
        static join(...parameters: Array<any>): string;
        static makePath(...parameters: Array<any>): string;
    }
}
declare module "foundation/service/common/oss/OssTest" {
    export class OssTest {
        protected _syncClient: any;
        protected _asyncClient: any;
        constructor();
        syncUpload(to: string, from: string): boolean;
        syncDownLoad(from: string): any;
        asyncUpload(to: string, from: string, onDone: Function, onErr: Function): void;
        asyncDownLoad(from: string, onDone: Function, onErr: Function): void;
    }
}
declare module "foundation/service/common/process/message/ExceptionCleanResponse" {
    import { StructureObject } from 'cross/runtime/framework/base/StructureObject';
    import { MessageDescription } from 'cross/data/module/message/MessageDescription';
    import { MessageResponse } from 'cross/data/module/message/MessageResponse';
    export class ExceptionCleanResponseVo extends StructureObject {
        constructor();
    }
    export class ExceptionCleanResponse extends MessageResponse {
        static CLASS_DESCRIPTION: MessageDescription;
        protected _data: ExceptionCleanResponseVo;
        constructor();
        get data(): ExceptionCleanResponseVo;
    }
}
declare module "foundation/service/common/process/message/ExceptionCleanRequest" {
    import { StructureObject } from 'cross/runtime/framework/base/StructureObject';
    import { IMessageContext } from 'cross/data/module/message/IMessageContext';
    import { MessageDescription } from 'cross/data/module/message/MessageDescription';
    import { MessageRequest } from 'cross/data/module/message/MessageRequest';
    import { ExceptionCleanResponse } from "foundation/service/common/process/message/ExceptionCleanResponse";
    export class ExceptionCleanRequestVo extends StructureObject {
        constructor();
    }
    export class ExceptionCleanRequest extends MessageRequest {
        static CLASS_DESCRIPTION: MessageDescription;
        protected _data: ExceptionCleanRequestVo;
        constructor();
        get data(): ExceptionCleanRequestVo;
        sendAsync(context?: IMessageContext): Promise<ExceptionCleanResponse>;
    }
}
declare module "foundation/service/common/process/ProcessRunnerDeclare" {
    export function ProcessRunnerDeclare(code: string, timeout?: number, isPushId?: boolean): (target: any, methodName: string, descriptor: PropertyDescriptor) => void;
}
declare module "foundation/service/common/router/AsyncRouter" {
    import { Router } from "foundation/service/common/router/Router";
    import { RouterService } from "foundation/service/common/router/RouterService";
    import { RouterSettings } from "foundation/service/common/router/RouterSettings";
    export type AsyncRouterCallback = (request: any, response: any, context?: any) => any;
    export class AsyncRouter extends Router {
        private static AsyncRouterLogger;
        protected _routerService: RouterService;
        protected generateInvokerAsync(path: string, method: string, callback: AsyncRouterCallback, options: RouterSettings): any;
        registerGetAsync(path: string, callback: AsyncRouterCallback, options?: RouterSettings): void;
        registerPutAsync(path: string, callback: AsyncRouterCallback, options?: RouterSettings): void;
        registerDeleteAsync(path: string, callback: AsyncRouterCallback, options?: RouterSettings): void;
        registerPostAsync(path: string, callback: AsyncRouterCallback, options?: RouterSettings): void;
    }
}
declare module "foundation/service/common/router/base/UploadFile" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class UploadFile extends InstanceObject {
        name: string;
        mimeCd: string;
        encoding: string;
        destination: string;
        originalName: string;
        fileName: string;
        path: string;
        size: number;
    }
}
declare module "foundation/service/common/router/command/ServiceCommand" {
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ServiceCommand extends BaseObject {
        code: string;
        type: any;
        options: any;
        processAsync(context: IContext, parameters?: any[]): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/router/command/ServiceCommandService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { ServiceCommand } from "foundation/service/common/router/command/ServiceCommand";
    export class ServiceCommandService extends Service {
        protected _commands: Dictionary<ServiceCommand>;
        get commands(): Dictionary<ServiceCommand>;
        registeDeclare(command: ServiceCommand): void;
        getDeclare(code: string): ServiceCommand;
        processAsync(context: IContext, code: string, parameters?: any[]): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/router/command/ServiceCommandDeclare" {
    export function ServiceCommandDeclare(code: string, options?: any): (type: any) => void;
}
declare module "foundation/service/common/router/DataAsyncResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ServiceMessage } from "foundation/service/common/router/message/ServiceMessage";
    export class DataAsyncResult extends ResultObject<ServiceMessage> {
    }
}
declare module "foundation/service/common/router/message/MessageProcessor" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { MessageDescription } from 'cross/data/module/message/MessageDescription';
    export class MessageProcessor extends InstanceObject {
        processName: any;
        request: MessageDescription;
        response: MessageDescription;
        callback: Function;
        invoker: Function;
        processCount: number;
        processSuccessCount: number;
        processFailureCount: number;
        processReceiveBytes: number;
        processSendBytes: number;
        processSpanTotal: number;
        processSpanMin: number;
        processSpanMax: number;
        options: any;
        router: any;
        constructor(processName: string, request: MessageDescription, response: MessageDescription, callback: Function, options?: any);
        get optionFile(): boolean;
        get path(): string;
        dispose(): void;
    }
}
declare module "foundation/service/common/router/message/MessageRouterService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageProcessor } from "foundation/service/common/router/message/MessageProcessor";
    export class MessageRouterService extends Service {
        protected _uploadPath: string;
        protected _validateOption: boolean;
        processors: Dictionary<MessageProcessor>;
        protected _environmentService: EnvironmentService;
        constructor();
        get uploadPath(): string;
        get validateOption(): boolean;
        initializeConfig(jconfig: any): void;
        statusUpdate(): void;
        find(name: string): MessageProcessor;
        register(processor: MessageProcessor, owner?: any): void;
    }
}
declare module "foundation/service/common/router/RouterContext" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IMessageContext } from 'cross/data/module/message/IMessageContext';
    import { DataConnection } from "foundation/service/common/database/DataConnection";
    import { DataConnectionService } from "foundation/service/common/database/DataConnectionService";
    import { DataContext } from "foundation/service/common/database/DataContext";
    import { UploadFile } from "foundation/service/common/router/base/UploadFile";
    import { ServerWarehouseService } from "foundation/service/common/router/database/ServerWarehouseService";
    export class RouterContext extends DataContext implements IMessageContext {
        request: any;
        response: any;
        protected _files: Types<UploadFile>;
        protected _frees: Types<any>;
        protected _connectionService: DataConnectionService;
        protected _serverWarehouseService: ServerWarehouseService;
        constructor(parent?: IContext);
        get serverWarehouseService(): ServerWarehouseService;
        getBindValue(code: string): any;
        watch(resource: any): any;
        get files(): Types<UploadFile>;
        findFile(name: string): UploadFile;
        link(request: any, response: any): any;
        optionGet(code: string): any;
        optionSet(code: string, value: any): void;
        sessionGet(name: string): any;
        sessionSet(name: string, value: any): boolean;
        sessionUpdate(): void;
        sessionClear(): void;
        protected getConnectionFromServiceAsync(connectionName: string, reference?: any): Promise<DataConnection>;
        getConnectionAsync(name?: string, reference?: any): Promise<DataConnection>;
        protected getLibraryConnectionAsync(name: string, sessionConstant: string, reference?: any): Promise<DataConnection>;
        private getDynamicConnectionAsync;
        dispose(flag?: boolean): void;
        disposeAsync(flag?: boolean): Promise<void>;
    }
}
declare module "foundation/service/common/router/SessionRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ServerSession } from "foundation/service/common/session/ServerSession";
    import { ServerSessionService } from "foundation/service/common/session/ServerSessionService";
    import { Router } from "foundation/service/common/router/Router";
    export class SessionRouter extends Router {
        protected _sessionService: ServerSessionService;
        getSessionAsync(request: any): Promise<ResultObject<ServerSession>>;
    }
}
declare module "foundation/service/common/router/DataAsyncRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { RouterSettings } from "foundation/service/common/router/RouterSettings";
    import { SessionRouter } from "foundation/service/common/router/SessionRouter";
    export class DataAsyncRouter extends SessionRouter {
        private static DataAsyncLogger;
        private static _multer;
        protected _environmentService: EnvironmentService;
        static get multerLibrary(): any;
        protected generateAsyncInvoker(path: string, method: string, callback: any, options: RouterSettings): any;
        registerAsyncGet(path: string, callback: Function, options?: RouterSettings): void;
        registerAsyncPut(path: string, callback: Function, options?: RouterSettings): void;
        registerAsyncDelete(path: string, callback: Function, options?: RouterSettings): void;
        registerAsyncPost(path: string, callback: Function, options?: RouterSettings): void;
    }
}
declare module "foundation/service/common/router/database/DatasetControllerOptions" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class DatasetControllerOptions extends InstanceObject {
        parameters: any;
    }
}
declare module "foundation/service/common/router/database/DatasetControllerResult" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class DatasetControllerResult extends ResultObject {
        referLogicName: string;
        keyName: string;
        keyValue: string;
        free(): void;
    }
    export type DatasetControllerResultType = ResultEnum | ResultObject;
}
declare module "foundation/service/common/router/database/DatasetControllerResultUtil" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class DatasetControllerResultUtil {
        static appendFailureResult(targetResult: ResultObject, resultObj: ResultObject | ResultEnum): boolean;
    }
}
declare module "foundation/service/common/router/database/DatasetController" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataQuery } from "foundation/service/common/database/util/DataQuery";
    import { DataResult } from "foundation/service/common/database/DataResult";
    import { DatasetLogic } from "foundation/service/common/database/DatasetLogic";
    import { DatasetResult } from "foundation/service/common/database/DatasetResult";
    import { DatasetUnit } from "foundation/service/common/database/DatasetUnit";
    import { FieldMeta } from "foundation/service/common/database/FieldMeta";
    import { IDataContext } from "foundation/service/common/database/IDataContext";
    import { RouterContext } from "foundation/service/common/router/RouterContext";
    import { DatasetControllerOptions } from "foundation/service/common/router/database/DatasetControllerOptions";
    import { DatasetControllerResult } from "foundation/service/common/router/database/DatasetControllerResult";
    import { DatasetLogicService } from "foundation/service/common/router/database/DatasetLogicService";
    export abstract class DatasetController<L extends DatasetLogic<any> = any, U extends InstanceObject = any> extends InstanceObject {
        protected _datasetLogicService: DatasetLogicService;
        createLogic(context: IDataContext): L;
        protected innerTrimValue(logic: DatasetLogic, data: any): boolean;
        protected getUniqueArrayAsync(logic: DatasetLogic, data: DatasetUnit): Promise<Array<string>>;
        protected validateUniqueAsync(logic: DatasetLogic, data: DatasetUnit): Promise<DatasetControllerResult>;
        protected validateForginKeyAsync(context: RouterContext, logic: DatasetLogic, data: DatasetUnit): Promise<DatasetControllerResult>;
        protected validateReferenceKeyAsync(context: RouterContext, logic: DatasetLogic, data: DatasetUnit): Promise<DatasetControllerResult>;
        findFieldMeta(name: string): FieldMeta;
        findAsync(context: IDataContext, id: string): Promise<U>;
        getAsync(context: IDataContext, id: string): Promise<U>;
        searchAsync(context: IDataContext, query: DataQuery): Promise<U>;
        fetchAsync(context: IDataContext, query: DataQuery): Promise<DatasetResult<U>>;
        protected abstract onPrepareAsync(context: RouterContext, dto: U, options: DatasetControllerOptions): Promise<any>;
        prepareAsync(context: RouterContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        protected abstract onInsertBeforeAsync(context: RouterContext, dto: U, options: DatasetControllerOptions): Promise<any>;
        protected abstract onInsertAfterAsync(context: RouterContext, dto: U, options: DatasetControllerOptions): Promise<any>;
        insertDataAsync(context: RouterContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        protected abstract onDuplicateBeforeAsync(context: RouterContext, dto: U, options: DatasetControllerOptions): Promise<any>;
        protected abstract onDuplicateAfterAsync(context: RouterContext, dto: U, options: DatasetControllerOptions): Promise<any>;
        duplicateDataAsync(context: RouterContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        protected abstract onUpdateBeforeAsync(context: RouterContext, oldDto: U, newDto: U, options: DatasetControllerOptions): Promise<any>;
        protected abstract onUpdateAfterAsync(context: RouterContext, dto: U, options: DatasetControllerOptions): Promise<any>;
        updateDataAsync(context: RouterContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        protected abstract onDeleteBeforeAsync(context: RouterContext, oldDto: U, newDto: U, options: DatasetControllerOptions): Promise<any>;
        protected abstract onDeleteAfterAsync(context: RouterContext, unit: U, options: DatasetControllerOptions): Promise<any>;
        deleteDataAsync(context: RouterContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        clearDataAsync(context: RouterContext, options?: DatasetControllerOptions): Promise<DataResult>;
    }
}
declare module "foundation/service/common/router/database/DatasetControllerContext" {
    import { RouterContext } from "foundation/service/common/router/RouterContext";
    export class DatasetControllerContext extends RouterContext {
    }
}
declare module "foundation/service/common/router/database/DatasetControllerService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetController } from "foundation/service/common/router/database/DatasetController";
    export class DatasetControllerInfo {
        name: string;
        clazz: any;
        instance: any;
    }
    export class DatasetControllerService extends Service {
        protected _controllerInfos: Dictionary<DatasetControllerInfo>;
        findController(name: string): DatasetControllerInfo;
        findControllerByClass(clazz: any): DatasetController;
        get controllers(): Dictionary<DatasetControllerInfo>;
        register(typeName: string, clazz: any): void;
        get(name: string): DatasetController;
    }
}
declare module "foundation/service/common/router/database/DatasetControllerDeclare" {
    export function DatasetControllerDeclare(...typeNames: string[]): (target: any) => void;
}
declare module "foundation/service/common/router/database/DatasetControllerDto" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export abstract class DatasetControllerDto extends InstanceObject {
        abstract loadJson(jconfig: any): void;
        abstract saveJson(jtarget?: any): any;
    }
}
declare module "foundation/service/common/router/database/DatasetControllerLinker" {
    export function DatasetControllerLinker(clazz: Function): (target: any, name: any) => any;
}
declare module "foundation/service/common/router/database/DatasetControllerRouter" {
    import { RouterSettings } from "foundation/service/common/router/RouterSettings";
    import { SessionRouter } from "foundation/service/common/router/SessionRouter";
    export class DatasetControllerRouter extends SessionRouter {
        private static DatasetControllerLogger;
        private static _multer;
        static get multerLibrary(): any;
        protected generateAsyncInvoker(path: string, method: string, callback: any, options: RouterSettings): any;
        registerAsyncGet(path: string, callback: Function, options?: RouterSettings): void;
        registerAsyncPut(path: string, callback: Function, options?: RouterSettings): void;
        registerAsyncDelete(path: string, callback: Function, options?: RouterSettings): void;
        registerAsyncPost(path: string, callback: Function, options?: RouterSettings): void;
    }
}
declare module "foundation/service/common/router/database/DatasetLogicDeclare" {
    export function DatasetLogicDeclare(...typeNames: Array<string>): (target: any) => void;
}
declare module "foundation/service/common/router/database/DatasetParentController" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataQuery } from "foundation/service/common/database/util/DataQuery";
    import { DataResult } from "foundation/service/common/database/DataResult";
    import { DatasetLogic } from "foundation/service/common/database/DatasetLogic";
    import { DatasetResult } from "foundation/service/common/database/DatasetResult";
    import { IDataContext } from "foundation/service/common/database/IDataContext";
    import { DatasetController } from "foundation/service/common/router/database/DatasetController";
    import { DatasetControllerContext } from "foundation/service/common/router/database/DatasetControllerContext";
    import { DatasetControllerOptions } from "foundation/service/common/router/database/DatasetControllerOptions";
    export abstract class DatasetParentController<L extends DatasetLogic<any> = any, U extends InstanceObject = any> extends DatasetController<L, U> {
        parentController: DatasetController;
        parentField: string;
        insertDataAsync(context: DatasetControllerContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        updateDataAsync(context: DatasetControllerContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        deleteDataAsync(context: DatasetControllerContext, data: any, options?: DatasetControllerOptions): Promise<DataResult>;
        fetchAsync(context: IDataContext, query: DataQuery): Promise<DatasetResult<U>>;
    }
}
declare module "foundation/service/common/router/message/MessageEnum" {
    export class MessageEnum {
        static Success: string;
        static InvalidInput: string;
        static InvalidParameter: string;
        static InvalidProcess: string;
        static getMessage(code: string): string;
    }
}
declare module "foundation/service/common/router/message/MessageRouterContext" {
    import { RouterContext } from "foundation/service/common/router/RouterContext";
    import { MessageProcessor } from "foundation/service/common/router/message/MessageProcessor";
    export class MessageRouterContext extends RouterContext {
        optionSuccess: boolean;
        optionDispatch: boolean;
        messageHost: string;
        messagePort: number;
        allowStatusCodes: Array<any>;
        processor: MessageProcessor;
        linkProcessor(processor: MessageProcessor, request: any, response: any): any;
        dispose(flag?: boolean): void;
        disposeAsync(flag?: boolean): Promise<void>;
    }
}
declare module "foundation/service/common/worker/ServiceWorkerPoolService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { InvokeThread } from 'cross/runtime/module/thread/InvokeThread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { ServiceWorkerProxy } from 'cross/system/module/worker/ServiceWorkerProxy';
    class ServiceTimeWorkerProxy extends ServiceWorkerProxy {
        processTime: Date;
        handleTimeout: Function;
    }
    export class ServiceWorkerPoolService extends Service {
        _poolCount: number;
        protected _thread: InvokeThread;
        protected _interval: number;
        protected _timeout: number;
        _runningWorkers: Types<ServiceWorkerProxy>;
        _waitingWorkers: Types<ServiceWorkerProxy>;
        _startingWorkers: Types<ServiceWorkerProxy>;
        protected _threadService: ThreadService;
        constructor();
        initializeConfig(jconfig: any): void;
        initAsync(context?: IContext): Promise<void>;
        invokeAsync(type: string, code: string, parameters: any): Promise<ResultObject>;
        protected getWorkerAsync(): Promise<ResultObject<ServiceTimeWorkerProxy>>;
        protected addNewWorkerAsync(wait: boolean): Promise<ResultObject>;
        protected createWorkerAsync(): Promise<ResultObject<ServiceTimeWorkerProxy>>;
        private onWorkerTimeoutCheck;
        private workerTerminate;
        dispose(): void;
    }
}
declare module "foundation/service/common/worker/ServiceWorkerService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { WorkerMessage } from 'cross/core/device/worker/WorkerMessage';
    import { MessageRouterService } from "foundation/service/common/router/message/MessageRouterService";
    import { DataLogicService } from "foundation/service/common/logic/DataLogicService";
    import { ServiceWorkerPoolService } from "foundation/service/common/worker/ServiceWorkerPoolService";
    export type WorkerRunnerDeclareInfo = {
        code: string;
        owner: any;
        method: Function;
        timeout?: number;
    };
    export class ServiceWorkerService extends Service {
        protected _declares: Types<WorkerRunnerDeclareInfo>;
        protected _handleParent: any;
        protected _routerService: MessageRouterService;
        protected _serviceWorkerPoolService: ServiceWorkerPoolService;
        protected _dataLogicService: DataLogicService;
        constructor();
        initializeConfig(jconfig: any): void;
        findDeclareByCode(code: string): WorkerRunnerDeclareInfo;
        registerDeclare(code: string, method: any, owner: any, timeout?: number): void;
        invokeAsync(type: string, code: string, parameters: any): Promise<ResultObject>;
        startup(): void;
        onInvokeAsync(code: string, parameters: any): Promise<ResultObject<WorkerMessage>>;
        processRunnerAsync(declare: WorkerRunnerDeclareInfo, args: any[], createContext?: boolean): Promise<ResultObject>;
        onRouterAsync(code: string, parameters: any): Promise<ResultObject<WorkerMessage>>;
        handleMessage: (event: any) => Promise<void>;
        sendMessage(message: WorkerMessage): void;
    }
}
declare module "foundation/service/common/router/message/MessageValidateUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageDescription } from 'cross/data/module/message/MessageDescription';
    export class MessageValidateUtil {
        static validate(request: any, messageDescription: MessageDescription): ResultObject;
    }
}
declare module "foundation/service/common/router/message/ServiceMessageUtil" {
    import { MessageResultEnum } from 'cross/data/module/message/MessageResultEnum';
    export class ServiceMessageUtil {
        static encodeJsonToString(data: any, key: string): string;
        static decodeJsonFromString(encryptContent: string, key: string): any;
        static makeMessage(messageCd: MessageResultEnum, code: string, message?: string, ...params: Array<string>): any;
        static copyHumpFields(target: any, source: any): void;
    }
}
declare module "foundation/service/common/router/message/MessageRouter" {
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { DateTimeService } from 'cross/runtime/module/date/DateTimeService';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { ServiceLockService } from "foundation/service/common/lock/ServiceLockService";
    import { ServiceWorkerService } from "foundation/service/common/worker/ServiceWorkerService";
    import { RouterSettings } from "foundation/service/common/router/RouterSettings";
    import { SessionRouter } from "foundation/service/common/router/SessionRouter";
    import { MessageProcessor } from "foundation/service/common/router/message/MessageProcessor";
    import { MessageRouterService } from "foundation/service/common/router/message/MessageRouterService";
    export class MessageRouter extends SessionRouter {
        private static MessageRouterLogger;
        private static _multer;
        processCode: string;
        protected _environmentService: EnvironmentService;
        protected _contextService: ContextService;
        protected _routerService: MessageRouterService;
        protected _workerService: ServiceWorkerService;
        protected _serviceLockService: ServiceLockService;
        protected _dateTimeService: DateTimeService;
        static get multerLibrary(): any;
        protected generateAsyncInvoker(method: string, processor: MessageProcessor, options: RouterSettings): any;
        protected generateWorkerInvoker(method: string, processor: MessageProcessor, options: RouterSettings): any;
        registerAsyncGet(processor: MessageProcessor, options?: RouterSettings): void;
        registerAsyncPut(processor: MessageProcessor, options?: RouterSettings): void;
        registerAsyncDelete(processor: MessageProcessor, options?: RouterSettings): void;
        registerAsyncPost(processor: MessageProcessor, options?: RouterSettings): void;
        registerProcessor(method: string, name: string, requestClass: any, responseClass: any, callback: any, options?: RouterSettings): void;
    }
}
declare module "foundation/service/common/router/message/ServiceMessageContext" {
    import { MessageContext } from 'cross/data/module/message/MessageContext';
    export class ServiceMessageContext extends MessageContext {
    }
}
declare module "foundation/service/common/router/ProcessAsyncResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ServiceMessage } from "foundation/service/common/router/message/ServiceMessage";
    export class ProcessAsyncResult extends ResultObject<ServiceMessage> {
    }
}
declare module "foundation/service/common/router/ProcessAsyncRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { ProcessAsyncResult } from "foundation/service/common/router/ProcessAsyncResult";
    import { Router } from "foundation/service/common/router/Router";
    import { RouterService } from "foundation/service/common/router/RouterService";
    import { RouterSettings } from "foundation/service/common/router/RouterSettings";
    export type AsyncProcessRouterCallback = (context: IContext, request: any, response: any) => Promise<ProcessAsyncResult>;
    export class ProcessAsyncRouter extends Router {
        private static AsyncProcessRouterLogger;
        protected _environmentService: EnvironmentService;
        protected _routerService: RouterService;
        protected generateInvokerAsync(path: string, method: string, callback: AsyncProcessRouterCallback, options: RouterSettings): any;
        registerGetAsync(path: string, callback: AsyncProcessRouterCallback, options?: RouterSettings): void;
        registerPutAsync(path: string, callback: AsyncProcessRouterCallback, options?: RouterSettings): void;
        registerDeleteAsync(path: string, callback: AsyncProcessRouterCallback, options?: RouterSettings): void;
        registerPostAsync(path: string, callback: AsyncProcessRouterCallback, options?: RouterSettings): void;
    }
}
declare module "foundation/service/common/router/RouterLevelEnum" {
    export class RouterLevelEnum {
        static Internal: number;
        static System: number;
        static Service: number;
        static Logic: number;
        static Test: number;
        static Debug: number;
    }
}
declare module "foundation/service/common/router/RouterDeclare" {
    import { RouterLevelEnum } from "foundation/service/common/router/RouterLevelEnum";
    export type RouterDeclareOptions = {
        optionRepeat?: boolean;
        level?: number;
    };
    export function RouterDeclare(name: string, uri: string, levelCd: RouterLevelEnum, options?: RouterDeclareOptions): (target: any) => void;
}
declare module "foundation/service/common/router/RouterDispatcher" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Router } from "foundation/service/common/router/Router";
    import { RouterService } from "foundation/service/common/router/RouterService";
    export class RouterDispatcher extends Router {
        protected _environmentService: EnvironmentService;
        protected _routerService: RouterService;
        onGetStatus: (request: any, response: any) => void;
        makeLogicRouter(app: any): void;
        makeRouter(app: any): void;
    }
}
declare module "foundation/service/common/router/ServiceRouter" {
    import { Router } from "foundation/service/common/router/Router";
    export class ServiceRouter extends Router {
        private static ServiceRouterLogger;
        register(): void;
        protected generateAsyncInvoker(method: string, path: string, callback: Function): any;
        registerAsyncGet(path: string, callback: Function): void;
        registerAsyncPut(path: string, callback: Function): void;
        registerAsyncDelete(path: string, callback: Function): void;
        registerAsyncPost(path: string, callback: Function): void;
    }
}
declare module "foundation/service/common/router/system/CommandRouter" {
    import { ServiceCommandService } from "foundation/service/common/router/command/ServiceCommandService";
    import { Router } from "foundation/service/common/router/Router";
    export class CommandRouter extends Router {
        protected _serviceCommandService: ServiceCommandService;
        onPostAsync(request: any, response: any): Promise<void>;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/DatabaseRouter" {
    import { Router } from "foundation/service/common/router/Router";
    export class DatabaseRouter extends Router {
        onGet(request: any, response: any): void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/DateRouter" {
    import { DateTimeService } from 'cross/runtime/module/date/DateTimeService';
    import { Router } from "foundation/service/common/router/Router";
    export class DateRouter extends Router {
        protected _dateTimeService: DateTimeService;
        onGetSystemDate(request: any, response: any): void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/InfoRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Router } from "foundation/service/common/router/Router";
    import { RouterService } from "foundation/service/common/router/RouterService";
    export class InfoRouter extends Router {
        protected _environmentService: EnvironmentService;
        protected _routerService: RouterService;
        onGetVersion: (request: any, response: any) => void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/LoggerRouter" {
    import { LoggerCacheService } from 'cross/system/module/logger/LoggerCacheService';
    import { Router } from "foundation/service/common/router/Router";
    export class LoggerRouter extends Router {
        protected _loggerCacheService: LoggerCacheService;
        onSearchPost(request: any, response: any): void;
        onInsertPost(request: any, response: any): void;
        onTraceLog(request: any, response: any): void;
        onGetLog(request: any, response: any): void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/MessageInfoRouter" {
    import { Router } from "foundation/service/common/router/Router";
    export class MessageInfoRouter extends Router {
        onGet(request: any, response: any): void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/MockOssRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { OssCacheService } from "foundation/service/common/oss/OssCacheService";
    import { OssConnectionService } from "foundation/service/common/oss/OssConnectionService";
    import { ProcessAsyncResult } from "foundation/service/common/router/ProcessAsyncResult";
    import { ProcessAsyncRouter } from "foundation/service/common/router/ProcessAsyncRouter";
    export class MockOssRouter extends ProcessAsyncRouter {
        protected _cacheService: OssCacheService;
        protected _ossService: OssConnectionService;
        onGetAsync(context: IContext, request: any, response: any): Promise<ProcessAsyncResult>;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/MockRouter" {
    import { Router } from "foundation/service/common/router/Router";
    export class MockRouter extends Router {
        onGetAll(request: any, response: any): void;
        onPostAll(request: any, response: any): void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/OssRouter" {
    import { Router } from "foundation/service/common/router/Router";
    export class OssRouter extends Router {
        onGet(request: any, response: any): void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/StatusRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Router } from "foundation/service/common/router/Router";
    export class StatusRouter extends Router {
        protected _environmentService: EnvironmentService;
        onGet: (request: any, response: any) => void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/system/TestRouter" {
    import { Router } from "foundation/service/common/router/Router";
    export class TestRouter extends Router {
        onGetException: (request: any, response: any) => void;
        getRouter(): any;
    }
}
declare module "foundation/service/common/router/thread/LogicAsyncInvoker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { DataLogicService } from "foundation/service/common/logic/DataLogicService";
    export class LogicAsyncInvoker extends InstanceObject {
        owner: any;
        callbackAsync: Function;
        connectionName: string;
        optionTransaction: boolean;
        protected _dataLogicService: DataLogicService;
        protected _contextService: ContextService;
        constructor(owner: any, callbackAsync: Function, connectionName?: string, optionTransaction?: boolean);
        processAsync(p1?: any, p2?: any, p3?: any, p4?: any): Promise<ResultObject<any>>;
        dispose(): void;
    }
}
declare module "foundation/service/common/session/ServerSessionV4Service" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { CacheDeviceService } from 'cross/core/device/cache/CacheDeviceService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { LogicSessionService } from 'cross/data/module/logic/session/LogicSessionService';
    import { ServiceJsonConnection } from 'cross/system/module/net/ServiceJsonConnection';
    import { ServerWarehouseService } from "foundation/service/common/router/database/ServerWarehouseService";
    import { ServerLoginService } from "foundation/service/common/login/ServerLoginService";
    export class ServerSessionV4Service extends Service {
        type: string;
        typeConfigure: any;
        cookieConfigure: any;
        sessionInterval: number;
        protected _url: string;
        protected _store: any;
        protected _environmentService: EnvironmentService;
        protected _jsonService: JsonService;
        protected _serviceJsonConnection: ServiceJsonConnection;
        protected _cacheDeviceService: CacheDeviceService;
        protected _serverLoginService: ServerLoginService;
        protected _serverWarehouseService: ServerWarehouseService;
        protected _sessionService: LogicSessionService;
        constructor();
        initializeConfig(jconfig: any): void;
        makeSessionId: (request: any) => string;
        startupAsync(handle: any): Promise<ResultObject>;
        testAsync(): Promise<ResultObject>;
        protected makeSessionUrl(sessionId: string): string;
        loadSessionAsync(sessionStore: any, sessionId: string): Promise<ResultObject>;
        loadSessionByIdAsync(sessionId: string): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/statistics/StatisticsMessageEventEnum" {
    export class StatisticsMessageEventCodeEnum {
        static RENDER_SCENE: string;
        static CREATE_RENDER_TASK_EVENT: string;
        static CREATE_BATCH_ON_MESSAGE_EVENT: string;
        static BATCH_INIT_FINISH_EVENT: string;
        static CREATE_TASK_MESSAGE_EVENT: string;
        static CREATE_TASK_ON_MESSAGE_EVENT: string;
        static CREATE_TASK_MESSAGE_FAILURE_EVENT: string;
        static TASK_INIT_FINISH_EVENT: string;
        static CONVERT_SCHEME_EVENT: string;
        static CENTER_GET_TASK_MESSAGE_EVENT: string;
        static PROCESS_TASK_START_EVENT: string;
        static CENTER_GET_TASK_MESSAGE_FAILURE_EVENT: string;
        static PROCESS_RENDER_TASK_LOAD_SCHEME_DOCUMENT_START_EVENT: string;
        static PROCESS_RENDER_TASK_LOAD_SCHEME_DOCUMENT_FINISH_EVENT: string;
        static PROCESS_RENDER_TASK_LOAD_SCHEME_DOCUMENT_FAILURE_EVENT: string;
        static PROCESS_RENDER_TASK_WRITE_SCHEME_DOCUMENT_START_EVENT: string;
        static PROCESS_RENDER_TASK_WRITE_SCHEME_DOCUMENT_FINISH_EVENT: string;
        static PROCESS_RENDER_TASK_WRITE_SCHEME_DOCUMENT_FAILURE_EVENT: string;
        static PROCESS_RENDER_TASK_COMPUTE_SCHEME_START_EVENT: string;
        static PROCESS_RENDER_TASK_COMPUTE_SCHEME_FINISH_EVENT: string;
        static PROCESS_RENDER_TASK_COMPUTE_SCHEME_FAILURE_EVENT: string;
        static PROCESS_RENDER_TASK_CONVERT_SCHEME_START_EVENT: string;
        static PROCESS_RENDER_TASK_CONVERT_SCHEME_FINISH_EVENT: string;
        static PROCESS_RENDER_TASK_CONVERT_SCHEME_FAILURE_EVENT: string;
        static PROCESS_RENDER_TASK_SUBTASK_INIT_FINISH_EVENT: string;
        static PROCESS_RENDER_TASK_WRITE_SCENE_FILE_START_EVENT: string;
        static PROCESS_RENDER_TASK_WRITE_SCENE_FILE_FINISH_EVENT: string;
        static PROCESS_RENDER_TASK_WRITE_SCENE_FILE_FAILURE_EVENT: string;
        static PROCESS_TASK_FINISH_EVENT: string;
        static PROCESS_TASK_CHILD_PROCESS_CLOSE_FAILURE: string;
        static CENTER_GET_SUBTASK_MESSAGE_EVENT: string;
        static PROCESS_SUBTASK_START_EVENT: string;
        static CENTER_GET_SUBTASK_MESSAGE_FAILURE_EVENT: string;
        static PROCESS_RENDER_SUBTASK_READ_CONFIG_START_EVENT: string;
        static PROCESS_RENDER_SUBTASK_READ_CONFIG_FINISH_EVENT: string;
        static PROCESS_RENDER_SUBTASK_READ_CONFIG_FAILURE_EVENT: string;
        static PROCESS_RENDER_SUBTASK_CREATE_UNREAL_TASK_MESSAGE_EVENT: string;
        static PROCESS_RENDER_SUBTASK_CREATE_UNREAL_TASK_MESSAGE_FAILURE_EVENT: string;
        static GET_UNREAL_RENDER_RESULT: string;
        static PROCESS_RENDER_SUBTASK_GET_UNREAL_TASK_STATUS_MESSAGE_EVENT: string;
        static PROCESS_RENDER_SUBTASK_GET_UNREAL_TASK_STATUS_MESSAGE_FAILURE_EVENT: string;
        static PROCESS_RENDER_SUBTASK_UNREAL_TASK_FINISH_EVENT: string;
        static PROCESS_RENDER_SUBTASK_UPLOAD_RESULT_START_EVENT: string;
        static PROCESS_RENDER_SUBTASK_UPLOAD_RESULT_FINISH_EVENT: string;
        static PROCESS_RENDER_SUBTASK_UPLOAD_RESULT_FAILURE_EVENT: string;
        static PROCESS_RENDER_SUBTASK_SET_STATUS_COMPLETE_MESSAGE_EVENT: string;
        static SUBTASK_SET_STATUS_COMPLETE_ON_MESSAGE_EVENT: string;
        static CENTER_GET_RESULT_MESSAGE_EVENT: string;
        static PROCESS_RENDER_SUBTASK_CHILD_PROCESS_CLOSE_FAILURE: string;
        static GET_BATCH_ON_MESSAGE_EVENT: string;
        static UPLOAD_BATCH_RESULT_START_EVENT: string;
        static UPLOAD_BATCH_RESULT_FINISH_EVENT: string;
        static UPLOAD_BATCH_RESULT_FAILURE_EVENT: string;
        static PROCESS_SUBTASK_FINISH_EVENT: string;
        static TASK_LOST_EVENT: string;
        static COMPUTE_SCHEME: string;
        static PROCESS_CALCULATE_SCHEME_ON_MESSAGE: string;
        static PROCESS_CALCULATE_SCHEME_CREATE_EVENT_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_CREATE_EVENT_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_LOAD: string;
        static PROCESS_CALCULATE_SCHEME_EVENT_PROCESS_START: string;
        static PROCESS_CALCULATE_SCHEME_LOAD_SYSTEM_START: string;
        static PROCESS_CALCULATE_SCHEME_LOAD_SYSTEM_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_LOAD_SYSTEM_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_LOAD_SCHEME_START: string;
        static PROCESS_CALCULATE_SCHEME_LOAD_SCHEME_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_LOAD_SCHEME_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_PRELOAD_START: string;
        static PROCESS_CALCULATE_SCHEME_PRELOAD_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_PRELOAD_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_SAVE_STRUCTURE_START: string;
        static PROCESS_CALCULATE_SCHEME_SAVE_STRUCTURE_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_SAVE_STRUCTURE_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_SCHEME_START: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_SCHEME_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_SCHEME_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_BOM_START: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_BOM_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_BOM_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_IPD_START: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_IPD_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_IPD_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_DRAWING_START: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_DRAWING_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_DRAWING_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_REPORT_START: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_REPORT_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_COMPUTE_REPORT_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_UPLOAD_START: string;
        static PROCESS_CALCULATE_SCHEME_UPLOAD_FINISH: string;
        static PROCESS_CALCULATE_SCHEME_UPLOAD_FAILURE: string;
        static PROCESS_CALCULATE_SCHEME_EVENT_COMPLETE: string;
        static PROCESS_CALCULATE_SCHEME_EVENT_CHILD_PROCESS_CLOSE_FAILURE: string;
        static RESOURCE_CONVERT: string;
        static PROCESS_CONVERT_RESOURCE_CREATE_EVENT_START: string;
        static PROCESS_CONVERT_RESOURCE_CREATE_EVENT_FINISH: string;
        static PROCESS_CONVERT_RESOURCE_CREATE_EVENT_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_EVENT_START: string;
        static PROCESS_CONVERT_RESOURCE_GET_LIBRARY_CONNECTION_START: string;
        static PROCESS_CONVERT_RESOURCE_GET_LIBRARY_CONNECTION_FINISH: string;
        static PROCESS_CONVERT_RESOURCE_GET_LIBRARY_CONNECTION_FAILURE: string;
        static LOAD_TEMP_RESOURCE_DOCUMENT_START: string;
        static LOAD_TEMP_RESOURCE_DOCUMENT_FAILURE: string;
        static LOAD_TEMP_RESOURCE_DOCUMENT_FINISH: string;
        static PROCESS_CONVERT_RESOURCE_LOAD_RESOURCE_START: string;
        static PROCESS_CONVERT_RESOURCE_LOAD_RESOURCE_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_LOAD_RESOURCE_FINISH: string;
        static CONVERT_RESOURCE_FILE_START: string;
        static PROCESS_CONVERT_RESOURCE_MAKE_PREVIEW_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_UPLOAD_PREVIEW_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_MAKE_STORAGE_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_PACKAGE_RESOURCE_FAILURE: string;
        static CONVERT_RESOURCE_FILE_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_MAKE_IMAGE_FAILURE: string;
        static CONVERT_RESOURCE_FILE_FINISH: string;
        static PROCESS_CONVERT_RESOURCE_MAKE_CROSS_START: string;
        static PROCESS_CONVERT_RESOURCE_UPLOAD_CROSS_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_UPLOAD_STORAGE_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_UPLOAD_ASSET_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_UPLOAD_RENDER_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_UPLOAD_ASSET_FINISH: string;
        static PROCESS_CONVERT_RESOURCE_CHILD_PROCESS_CLOSE_FAILURE: string;
        static PROCESS_CONVERT_RESOURCE_EVENT_FINISH: string;
        static SCHEME_SAVE: string;
        static SAVE_SCHEME_DOCUMENT_START: string;
        static SAVE_SCHEME_DOCUMENT_FAILURE: string;
        static SAVE_SCHEME_DOCUMENT_FINISH: string;
        private static _nameMap;
        private static _tree;
        private static _nodeMap;
        static buildNodeMap(node?: any, nodeEventCode?: string): void;
        static getEventName(eventCode: string): string;
        static getEventStackString(eventCode: string): string;
    }
}
declare module "foundation/service/common/statistics/StatisticsMessageEventTypeEnum" {
    export class StatisticsMessageEventTypeEnum {
        static DISPATCH: string;
        static EXCEPTION: string;
        static NORMAL: string;
        static IO: string;
        static COMPUTE: string;
    }
}
declare module "foundation/service/common/statistics/StatisticsMessageService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { JsonService } from 'cross/core/module/json/JsonService';
    export class StatisticsMessageService extends Service {
        private _projectName;
        private _host;
        private _port;
        private _env;
        private _statisticsApiPath;
        static CONTEXT_ADDITION_CODE: string;
        protected _jsonService: JsonService;
        protected _environmentService: EnvironmentService;
        initializeConfig(jconfig: any): void;
        private getProjectName;
        private getEnv;
        private getHost;
        private getPort;
        forwardClientStatisticsEventMessageAsync(context: ContextObject, info: any): Promise<ResultObject>;
        sendStatisticsEventMessageAsync(context: ContextObject, eventCode: string, typeCd: string, linkId: string, options?: any, statisticsId?: string): Promise<ResultObject>;
        private static getCpu;
        private static getRamRss;
        private static cpuIAverage;
    }
}
declare module "foundation/service/common/statistics/StatisticsMessageUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class StatisticsMessageUtil {
        static CONTEXT_ADDITION_CODE: string;
        static sendStatisticsEventMessageAsync(context: ContextObject, eventCode: string, typeCd: string, linkId: string, options?: any, statisticsId?: string): Promise<ResultObject>;
        static getStatisticsMessageIdByContext(context: ContextObject): string;
        static initContextStatisticsMessageId(context: ContextObject, id?: string): string;
    }
}
declare module "foundation/service/common/storage/StorageDataDeclareInfo" {
    export type StorageDataDeclareInfo = {
        typeName: string;
        type: any;
    };
}
declare module "foundation/service/common/storage/StorageDataOptions" {
    import { CacheOptions } from 'cross/service/module/cache/CacheOptions';
    export class StorageDataOptions extends CacheOptions {
        username: string;
        password: string;
        database: string;
        ttl: number;
        collectionNames: Array<string>;
    }
}
declare module "foundation/service/common/storage/StorageDataType" {
    export enum StorageDataType {
        Json = "json",
        String = "string",
        Buffer = "buffer"
    }
}
declare module "foundation/service/common/storage/StorageDataParameters" {
    import { StorageDataType } from "foundation/service/common/storage/StorageDataType";
    export type StorageDataParameters = {
        contentCd?: StorageDataType;
        createDate?: Date;
        optionExpired?: boolean;
    };
}
declare module "foundation/service/common/storage/StorageDataResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageStateType } from 'foundation/data/common/storage/mongo/MongoStorageStateType';
    export class StorageDataResult extends ResultObject {
        count: number;
        size: number;
        objectId: string;
        contentState: MongoStorageStateType;
        createDate: Date;
        isExpired: boolean;
        constructor();
        loadJson(jconfig: any): any;
        saveJson(target?: any): any;
        isExists(): boolean;
    }
}
declare module "foundation/service/common/storage/StorageDataConnection" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { StorageDataOptions } from "foundation/service/common/storage/StorageDataOptions";
    import { StorageDataParameters } from "foundation/service/common/storage/StorageDataParameters";
    import { StorageDataResult } from "foundation/service/common/storage/StorageDataResult";
    import { StorageDataType } from "foundation/service/common/storage/StorageDataType";
    export class StorageDataConnection extends Dispatcher {
        options: StorageDataOptions;
        constructor();
        setupAsync(): Promise<ResultObject>;
        protected formatCollectionName(collectionName: string): string;
        getCollectionsAsync(): Promise<ResultObject<Array<any>>>;
        createCollectionsAsync(options: StorageDataOptions): Promise<ResultObject>;
        findAsync(collectionName: string, limit?: number, filter?: {}): Promise<ResultObject<Array<any>>>;
        getAsync(collectionName: string, path: string, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        insertAsync(collectionName: string, path: string, data: any, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        setAsync(collectionName: string, path: string, data: any, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        updateOneAsync(collectionName: string, document: any): Promise<StorageDataResult>;
        protected saveAsync(parameters: MongoStorageUploadParameters, contentType: StorageDataType, size: number): Promise<StorageDataResult>;
        protected loadAsync(parameters: MongoStorageDownloadParameters, type: StorageDataType): Promise<StorageDataResult>;
        uploadJsonAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadJsonAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        uploadStringAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadStringAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        uploadBufferAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadBufferAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        clearAsync(collectionNames: Array<string>): Promise<ResultObject>;
        freeAsync(): Promise<void>;
        shutdown(): void;
    }
}
declare module "foundation/service/common/storage/StorageDataConnectionPool" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { StorageDataConnection } from "foundation/service/common/storage/StorageDataConnection";
    import { StorageDataOptions } from "foundation/service/common/storage/StorageDataOptions";
    export class StorageDataConnectionPool extends InstanceObject {
        name: string;
        storageCd: string;
        storageType: any;
        options: StorageDataOptions;
        allocCount: number;
        freeCount: number;
        protected _connections: Types<StorageDataConnection>;
        protected _environmentService: EnvironmentService;
        constructor();
        loadConfig(jconfig: any): void;
        private getDatabase;
        testAsync(context: IContext): Promise<ResultObject>;
        allocConnectionAsync(): Promise<StorageDataConnection>;
        onFreeConnection(sender: ListenerContext, event: EventObject): void;
        get useCount(): number;
        shutdown(): void;
    }
}
declare module "foundation/service/common/storage/StorageDataService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { Collection } from 'mongodb';
    import { StorageDataConnection } from "foundation/service/common/storage/StorageDataConnection";
    import { StorageDataConnectionPool } from "foundation/service/common/storage/StorageDataConnectionPool";
    import { StorageDataDeclareInfo } from "foundation/service/common/storage/StorageDataDeclareInfo";
    import { StorageDataParameters } from "foundation/service/common/storage/StorageDataParameters";
    import { StorageDataResult } from "foundation/service/common/storage/StorageDataResult";
    export class StorageDataService extends Service {
        protected _defaultName: string;
        protected _declares: Dictionary<StorageDataDeclareInfo>;
        protected _pools: Dictionary<StorageDataConnectionPool>;
        get pools(): Dictionary<StorageDataConnectionPool>;
        registerDeclare(declare: StorageDataDeclareInfo): void;
        initializeConfig(jconfig: any): void;
        testAsync(context: IContext): Promise<ResultObject>;
        allocConnectionAsync(connectionName?: string): Promise<StorageDataConnection>;
        collectionsAsync(): Promise<ResultObject<Array<Collection>>>;
        collectionsByNameAsync(connectionName: string): Promise<ResultObject<Array<Collection>>>;
        findAsync(connectionName: string, collectionName: string, limit?: number, filter?: any): Promise<ResultObject<Array<any>>>;
        getAsync(connectionName: string, collectionName: string, path: string, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        insertAsync(connectionName: string, collectionName: string, path: string, data: any, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        setAsync(connectionName: string, collectionName: string, path: string, data: any, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        updateAsync(connectionName: string, collectionName: string, document: any): Promise<ResultObject<Array<any>>>;
        uploadJsonAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadJsonAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        uploadStringAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadStringAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        uploadBufferAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadBufferAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        clearAsync(connectionName: string, collectionNames: Array<string>): Promise<ResultObject>;
        shutdown(): void;
    }
}
declare module "foundation/service/common/storage/StorageDataConnectionDeclare" {
    export function StorageDataConnectionDeclare(typeName: string): (target: any) => void;
}
declare module "foundation/service/common/storage/mongodb/MongodbDataConnection" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { StorageDataConnection } from "foundation/service/common/storage/StorageDataConnection";
    import { StorageDataOptions } from "foundation/service/common/storage/StorageDataOptions";
    import { StorageDataResult } from "foundation/service/common/storage/StorageDataResult";
    import { StorageDataType } from "foundation/service/common/storage/StorageDataType";
    import { Collection, Db, MongoClient, IndexSpecification, CreateIndexesOptions } from 'mongodb';
    export type MongodbDataConnectionCollection = {
        handle: Collection;
        index: Array<string>;
    };
    export type MongodbDataConnectionCollectionIndex = {
        indexSpec: IndexSpecification;
        options: CreateIndexesOptions;
    };
    export class MongodbDataConnection extends StorageDataConnection {
        protected _client: MongoClient;
        protected _db: Db;
        private _collections;
        private _idxMap;
        constructor();
        setupAsync(): Promise<ResultObject>;
        private getClientOptions;
        createCollectionsAsync(options: StorageDataOptions): Promise<ResultObject>;
        private createCollectionAsync;
        private getIndexesOptions;
        private createIndexesAsync;
        protected getCollection(collectionName: string): MongodbDataConnectionCollection;
        private formatUrl;
        protected formatCollectionName(collectionName: string): string;
        getCollectionsAsync(): Promise<ResultObject<Array<Collection>>>;
        findAsync(collectionName: string, limit?: number, filter?: {}): Promise<ResultObject<Array<any>>>;
        updateOneAsync(collectionName: string, document: any): Promise<StorageDataResult>;
        protected saveAsync(parameters: MongoStorageUploadParameters, contentType: StorageDataType, size: number): Promise<StorageDataResult>;
        protected loadAsync(parameters: MongoStorageDownloadParameters, type: StorageDataType): Promise<StorageDataResult>;
        uploadJsonAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadJsonAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        uploadStringAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadStringAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        uploadBufferAsync(parameters: MongoStorageUploadParameters): Promise<StorageDataResult>;
        downloadBufferAsync(parameters: MongoStorageDownloadParameters): Promise<StorageDataResult>;
        clearAsync(collectionNames: Array<string>): Promise<ResultObject>;
        freeAsync(): Promise<void>;
        shutdown(): void;
    }
}
declare module "foundation/service/common/storage/StorageDataDocument" {
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    import { MongoStorageStateType } from 'foundation/data/common/storage/mongo/MongoStorageStateType';
    export class StorageDataDocument extends BaseObject {
        connectionName: string;
        collectionName: string;
        path: string;
        load(config: any): void;
        saveContent(state: MongoStorageStateType): void;
        save(): any;
    }
}
declare module "foundation/service/common/storage/mongodb/MongodbDataDocument" {
    import { MongoStorageStateType } from 'foundation/data/common/storage/mongo/MongoStorageStateType';
    import { StorageDataDocument } from "foundation/service/common/storage/StorageDataDocument";
    import { StorageDataType } from "foundation/service/common/storage/StorageDataType";
    export class MongodbDataDocument extends StorageDataDocument {
        id: string;
        contentType: StorageDataType;
        content: any;
        length: number;
        createDate: Date;
        uploadDate: Date;
        loadContent(content: any): any;
        load(config: any): void;
        saveContent(state: MongoStorageStateType): void;
        save(): any;
    }
}
declare module "foundation/service/common/storage/mongodb/bson/MongodbBsonDocument" {
    import { MongoStorageOptions } from 'foundation/data/common/storage/mongo/MongoStorageOptions';
    import { MongoStorageStateType } from 'foundation/data/common/storage/mongo/MongoStorageStateType';
    import { StorageDataType } from "foundation/service/common/storage/StorageDataType";
    import { MongodbDataDocument } from "foundation/service/common/storage/mongodb/MongodbDataDocument";
    import { ObjectId } from 'mongodb';
    export type MongoBSONContent = {
        _id: ObjectId;
        contentType: StorageDataType;
        path: string;
        length: number;
        content: any;
        uploadDate: Date;
    };
    export class MongodbBsonDocument extends MongodbDataDocument {
        static create(path: string, type: StorageDataType, state: MongoStorageStateType, size: number, options?: MongoStorageOptions, content?: any): MongodbBsonDocument;
        loadContent(content: any): any;
    }
}
declare module "foundation/service/common/storage/mongodb/bson/MongodbBsonConnection" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { StorageDataParameters } from "foundation/service/common/storage/StorageDataParameters";
    import { StorageDataResult } from "foundation/service/common/storage/StorageDataResult";
    import { StorageDataType } from "foundation/service/common/storage/StorageDataType";
    import { MongodbDataConnection } from "foundation/service/common/storage/mongodb/MongodbDataConnection";
    import { Collection } from 'mongodb';
    import { MongodbBsonDocument } from "foundation/service/common/storage/mongodb/bson/MongodbBsonDocument";
    export class MongodbBsonConnection extends MongodbDataConnection {
        getCollectionsAsync(): Promise<ResultObject<Array<Collection>>>;
        clearCollectionsAsync(collections: Array<Collection>): Promise<ResultObject>;
        private clearCollectionAsync;
        findAsync(collectionName: string, limit?: number, filter?: {}): Promise<ResultObject<Array<MongodbBsonDocument>>>;
        private checkTimeSpan;
        insertAsync(collectionName: string, path: string, data: any, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        setAsync(collectionName: string, path: string, data: any, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        getAsync(collectionName: string, path: string, parameters?: StorageDataParameters): Promise<StorageDataResult>;
        updateOneAsync(collectionName: string, document: MongodbBsonDocument): Promise<StorageDataResult>;
        protected saveAsync(parameters: MongoStorageUploadParameters, contentType: StorageDataType, size: number): Promise<StorageDataResult>;
        protected loadAsync(parameters: MongoStorageDownloadParameters, type: StorageDataType): Promise<StorageDataResult>;
        clearAsync(collectionNames?: Array<string>): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/storage/mongodb/event/MongoTransferEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { MongodbDataDocument } from "foundation/service/common/storage/mongodb/MongodbDataDocument";
    import { Collection } from 'mongodb';
    export class MongoTransferEvent extends EventObject {
        collection: Collection;
        document: MongodbDataDocument;
        setup(collection: Collection, document: MongodbDataDocument): void;
        free(): void;
    }
}
declare module "foundation/service/common/storage/mongodb/event/MongoTransferEventEnum" {
    export class MongoTransferEventEnum {
        static MongoSaved: string;
        static OssUpload: string;
    }
}
declare module "foundation/service/common/storage/mongodb/MongodbDocumentMeta" {
    import { MongoStorageOptions } from 'foundation/data/common/storage/mongo/MongoStorageOptions';
    import { MongoStorageStateType } from 'foundation/data/common/storage/mongo/MongoStorageStateType';
    export class MongodbDocumentMeta {
        state: MongoStorageStateType;
        options: MongoStorageOptions;
        static create(path: string, state: MongoStorageStateType, options?: MongoStorageOptions): MongodbDocumentMeta;
        save(): any;
        load(config: any): void;
    }
}
declare module "foundation/service/common/storage/mongodb/gridfs/MongodbGridfsDocument" {
    import { MongodbDataDocument } from "foundation/service/common/storage/mongodb/MongodbDataDocument";
    import { MongodbDocumentMeta } from "foundation/service/common/storage/mongodb/MongodbDocumentMeta";
    import { ObjectId } from 'mongodb';
    export type MongoGridFSContent = {
        chunkSize: number;
        contentType: string;
        path: string;
        length: number;
        metadata: MongodbDocumentMeta;
        _id?: ObjectId;
        uploadDate?: Date;
    };
    export class MongodbGridfsDocument extends MongodbDataDocument {
        chunkSize: number;
        static create(content: MongoGridFSContent, buffer: Buffer): MongodbGridfsDocument;
    }
}
declare module "foundation/service/common/storage/mongodb/gridfs/MongodbGridfsConnection" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { StorageDataResult } from "foundation/service/common/storage/StorageDataResult";
    import { StorageDataType } from "foundation/service/common/storage/StorageDataType";
    import { MongodbDataConnection } from "foundation/service/common/storage/mongodb/MongodbDataConnection";
    import { Collection } from 'mongodb';
    import { MongodbGridfsDocument } from "foundation/service/common/storage/mongodb/gridfs/MongodbGridfsDocument";
    export class MongodbGridfsConnection extends MongodbDataConnection {
        private static readonly CHUNK_SIZE_BYTES;
        protected formatCollectionName(collectionName: string): string;
        protected formatBucketName(collectionName: string): string;
        getCollectionsAsync(): Promise<ResultObject<Array<Collection>>>;
        findAsync(collectionName: string, limit?: number, filter?: {}): Promise<ResultObject<Array<MongodbGridfsDocument>>>;
        updateOneAsync(collectionName: string, document: MongodbGridfsDocument): Promise<StorageDataResult>;
        protected saveAsync(parameters: MongoStorageUploadParameters, contentType: StorageDataType, size: number): Promise<StorageDataResult>;
        protected loadAsync(parameters: MongoStorageDownloadParameters, type: StorageDataType): Promise<StorageDataResult>;
        private streamToBufferAsync;
    }
}
declare module "foundation/service/common/storage/mongodb/MongoStorageTransferService" {
    import * as Stream from 'stream';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageDataService } from 'foundation/data/common/storage/mongo/MongoStorageDataService';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    export class MongoStorageTransferService extends MongoStorageDataService {
        uploadJsonObjectAsync(context: IContext, parameters: MongoStorageUploadParameters | Array<MongoStorageUploadParameters>): Promise<ResultObject>;
        uploadObjectAsync(context: IContext, parameters: MongoStorageUploadParameters): Promise<ResultObject>;
        uploadBufferAsync(context: IContext, parameters: MongoStorageUploadParameters): Promise<ResultObject>;
        uploadStringAsync(context: IContext, parameters: MongoStorageUploadParameters | Array<MongoStorageUploadParameters>): Promise<ResultObject>;
        uploadContentAsync(context: IContext, parameters: MongoStorageUploadParameters | Array<MongoStorageUploadParameters>): Promise<ResultObject>;
        uploadStreamAsync(context: IContext, parameters: MongoStorageUploadParameters): Promise<ResultObject>;
        downloadStreamAsync(context: IContext, parameters: MongoStorageDownloadParameters): Promise<ResultObject<Stream.PassThrough>>;
        uploadFileAsync(context: IContext, parameters: MongoStorageUploadParameters): Promise<ResultObject>;
        downloadFileAsync(context: IContext, parameters: MongoStorageDownloadParameters): Promise<ResultObject>;
        private sendUploadRequestAsync;
        private getUploadParameters;
    }
}
declare module "foundation/service/common/template/TemplateBuilder" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class TemplateBuilder extends InstanceObject {
        name: string;
        source: string;
        util: any;
        constructor();
        render(content: any, options?: any): string;
    }
}
declare module "foundation/service/common/test/TestContext" {
    export class TestContext {
        name: string;
    }
}
declare module "foundation/service/common/test/TestMethodContext" {
    export class TestMethodContext {
        owner: any;
        name: string;
        methodName: string;
        result: boolean;
        padding: number;
        constructor();
        check(result: boolean, message: string, ...parameters: Array<any>): void;
    }
}
declare module "foundation/service/common/test/TestObject" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { TestContext } from "foundation/service/common/test/TestContext";
    export class TestObject {
        processAsync(context: TestContext): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/test/TestService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    export class TestDeclareInfo {
        name: string;
        type: any;
    }
    export class TestService extends Service {
        protected _declares: Types<TestDeclareInfo>;
        protected _environmentService: EnvironmentService;
        constructor();
        registerDeclare(info: TestDeclareInfo): void;
        processAsync(): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/test/TestDeclare" {
    export function TestDeclare(name?: string): (type: any) => void;
}
declare module "foundation/service/common/version/svn/SvnCmd" {
    export class SvnCmd {
        nativeCommand: string;
        password: string;
        username: string;
        root: string;
        queues: any;
        isRuning: boolean;
        debug: boolean;
        cwd: string;
        constructor(config: any);
        run(): void;
        pushQueue(cmds: any): boolean;
    }
}
declare module "foundation/service/common/version/svn/Svn" {
    import { SvnCmd } from "foundation/service/common/version/svn/SvnCmd";
    export class Svn extends SvnCmd {
        repoName: string;
        repoPath: string;
        constructor(jconfig: any);
        checkout(callback: any): void;
        commit(args: any, callback: any): boolean;
        info(): void;
        list(): void;
        switch(branches: any, callback: any): boolean;
        update(callback: any): void;
        cleanup(): void;
        command(opts: any): boolean;
        parseArgs(arr: any): any;
    }
}
declare module "foundation/service/common/version/VersionResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class VersionResult extends ResultObject {
        version: string;
    }
}
declare module "foundation/service/common/version/svn/VersionSvnQueue" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class VersionSvnQueue extends InstanceObject {
        command: string;
        path: string;
        optionAccount: boolean;
        optionXml: boolean;
        parameters: Types<string>;
        options: any;
        resolveHandle: any;
        rejectHandle: any;
        constructor();
        addParameter(value: string): void;
        resolve(result: any): void;
        dispose(): void;
    }
}
declare module "foundation/service/common/version/svn/VersionSvnConnection" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ProcessResult } from 'cross/system/base/process/ProcessResult';
    import { VersionResult } from "foundation/service/common/version/VersionResult";
    import { VersionSvnQueue } from "foundation/service/common/version/svn/VersionSvnQueue";
    export class VersionSvnConnection extends InstanceObject {
        name: string;
        passport: string;
        password: string;
        path: string;
        charset: string;
        version: number;
        protected _queues: Types<VersionSvnQueue>;
        protected _processing: boolean;
        constructor();
        loadConfig(jconfig: any): void;
        findVersion(lines: Types<string>): string;
        processQueueAsync(queue: VersionSvnQueue): Promise<ProcessResult>;
        executeQueueAsync(queue: VersionSvnQueue): Promise<ProcessResult>;
        processAsync(): Promise<ResultEnum>;
        infoAsync(path: string): Promise<VersionResult>;
        listAsync(path: string): Promise<VersionResult>;
        checkoutAsync(path: string): Promise<VersionResult>;
        addAsync(path: string, fileName: string): Promise<VersionResult>;
        updateAsync(path: string, force?: boolean): Promise<VersionResult>;
        deleteAsync(path: string, fileName: string): Promise<VersionResult>;
        commitAsync(path: string, message: string): Promise<VersionResult>;
        switchAsync(path: string, branch: string): Promise<VersionResult>;
        cleanupAsync(path: string): Promise<VersionResult>;
    }
}
declare module "foundation/service/common/version/svn/VersionSvnService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { InvokeThread } from 'cross/runtime/module/thread/InvokeThread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { VersionSvnConnection } from "foundation/service/common/version/svn/VersionSvnConnection";
    export class VersionSvnService extends Service {
        protected _processing: boolean;
        protected _connections: Dictionary<VersionSvnConnection>;
        protected _invokeInterval: number;
        protected _invokeThread: InvokeThread;
        protected _threadService: ThreadService;
        constructor();
        getConnection(name: string): VersionSvnConnection;
        initializeConfig(jconfig: any): void;
        onRefreshConnectionsAsync(): Promise<ResultObject>;
        onActive(): void;
    }
}
declare module "foundation/service/common/worker/IServiceWorkerInvoke" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export interface IServiceWorkerInvoke {
        processAsync(parameters?: any): Promise<ResultObject>;
    }
}
declare module "foundation/service/common/worker/ServiceWorkerInvoker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ServiceWorkerInvoker extends InstanceObject {
        invokeAsync(type: string, code: string, parameters: any): Promise<ResultObject<any>>;
    }
}
declare module "foundation/service/common/worker/WorkerRunnerDeclare" {
    export function WorkerRunnerDeclare(code: string, timeout?: number): (target: any, methodName: string, descriptor: PropertyDescriptor) => void;
}