/// <reference path="../library/typings/cross-runtime.d.ts" />
/// <reference path="../library/typings/cross-system.d.ts" />
/// <reference path="../library/typings/cross-service.d.ts" />
/// <reference path="../typings/private/foundation-data-common.d.ts" />
/// <reference path="../typings/private/foundation-service-common.d.ts" />
/// <reference path="../typings/private/sk-data-logic.d.ts" />
/// <reference path="../typings/private/sk-data-family.d.ts" />
/// <reference path="../typings/private/sk-data-resource.d.ts" />
/// <reference path="../typings/private/sk-data-scheme.d.ts" />
/// <reference path="../typings/private/sk-data-calculate.d.ts" />
/// <reference path="../typings/private/sk-data-convert.d.ts" />
/// <reference path="../typings/private/sk-data-warehouse.d.ts" />
/// <reference path="../typings/private/sk-rule-process.d.ts" />
/// <reference path="../typings/private/sk-service-data-logic.d.ts" />
/// <reference path="../typings/private/sk-service-data-declare.d.ts" />
declare module "copyright" {
    export class ServiceLogicCopyright {
        static toString(): string;
    }
}
declare module "sk/service/logic/article/ArticlePdfResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ArticlePdfResult extends ResultObject {
        name: string;
        path: string;
    }
}
declare module "sk/service/logic/article/ArticleService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { InvokeThread } from 'cross/runtime/module/thread/InvokeThread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { ArticlePdfResult } from "sk/service/logic/article/ArticlePdfResult";
    export type ArticleFolderInfo = {
        name: string;
        path?: string;
        start?: string;
        children?: Array<ArticleFolderInfo>;
    };
    export class ArticleService extends Service {
        versionName: string;
        path: string;
        contentPath: string;
        private _dirTree;
        private _classTree;
        private _home;
        protected _thread: InvokeThread;
        protected _environmentService: EnvironmentService;
        protected _threadConsole: ThreadService;
        constructor();
        get home(): any;
        get dirTree(): any;
        initializeConfig(jconfig: any): void;
        statusUpdate(): void;
        getTreeNode(moduleName: string): any;
        getFileContent(path: string): string;
        makeRelativePath(path: string): string;
        getArticleStartFile(path: string): string;
        refreshPathFiles(path: string, folders: Array<ArticleFolderInfo>): void;
        getArticleName(file: string): string;
        getPdfFileAsync(mdPath: string): Promise<ArticlePdfResult>;
        chekcoutAsync(): Promise<ResultEnum>;
        updateAsync(): Promise<ResultEnum>;
        commitAsync(fileName: string): Promise<ResultEnum>;
        saveFileAsync(source: string, content: any): Promise<ResultEnum>;
        refresh(): void;
        writeNodeToClassTree(node: any, moduleName: string): void;
        loopClassTree(children: any, moduleName?: string): void;
        refreshClassTree(): void;
        onProcessAsync(): Promise<void>;
        reloadAsync(): Promise<void>;
        startAsync(context?: IContext): Promise<ResultObject>;
        onActive(): void;
        onDeactive(): void;
    }
}
declare module "sk/service/logic/article/ArticleRouter" {
    import { AsyncRouter } from 'foundation/service/common/router/AsyncRouter';
    import { ArticleService } from "sk/service/logic/article/ArticleService";
    export class ArticleRouter extends AsyncRouter {
        protected _articleService: ArticleService;
        constructor();
        onGetDirTreeAsync: (request: any, response: any) => Promise<void>;
        onGetArticleAsync: (request: any, response: any) => Promise<void>;
        onGetPdfAsync: (request: any, response: any) => Promise<void>;
        onSaveArticleAsync: (request: any, response: any) => Promise<void>;
        onReloadAsync: (request: any, response: any) => Promise<void>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/article/TypedocService" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    export class TypedocService extends Service {
        classTree: any;
        protected _environmentService: EnvironmentService;
        constructor();
        getClassTree(): any;
        onActive(): void;
        getTreeNode(moduleName: string): any;
        writeNodeToClassTree(path: string, node: any, moduleName: string): void;
        loopClassTree(path: string, children: any, moduleName?: string): void;
        initDirClassTree(path: string): void;
        initClassTree(): void;
        deactive(): void;
    }
}
declare module "sk/service/logic/auth/router/OperModuleRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OperModuleDeleteRequest } from 'sk/data/logic/auth/message/OperModuleDeleteRequest';
    import { OperModuleDeleteResponse } from 'sk/data/logic/auth/message/OperModuleDeleteResponse';
    import { OperModuleFetchRequest } from 'sk/data/logic/auth/message/OperModuleFetchRequest';
    import { OperModuleFetchResponse } from 'sk/data/logic/auth/message/OperModuleFetchResponse';
    import { OperModuleImportDeclareRequest } from 'sk/data/logic/auth/message/OperModuleImportDeclareRequest';
    import { OperModuleImportDeclareResponse } from 'sk/data/logic/auth/message/OperModuleImportDeclareResponse';
    import { OperModulePageRequest } from 'sk/data/logic/auth/message/OperModulePageRequest';
    import { OperModulePageResponse } from 'sk/data/logic/auth/message/OperModulePageResponse';
    import { OperModuleTreeRequest } from 'sk/data/logic/auth/message/OperModuleTreeRequest';
    import { OperModuleTreeResponse } from 'sk/data/logic/auth/message/OperModuleTreeResponse';
    import { OperModuleController } from 'sk/service/data/logic/auth/controller/OperModuleController';
    import { OperModuleTypeController } from 'sk/service/data/logic/auth/controller/OperModuleTypeController';
    import { RoleModuleActController } from 'sk/service/data/logic/auth/controller/RoleModuleActController';
    export class OperModuleRouter extends MessageRouter {
        processCode: string;
        protected _operModuleController: OperModuleController;
        protected _operModuleTypeController: OperModuleTypeController;
        protected _roleModuleActController: RoleModuleActController;
        protected _environmentService: EnvironmentService;
        protected _jsonService: JsonService;
        private makeOperModuleTreeResponseData;
        private buildOperModuleTreeResponseItemsVo;
        private makeOperModuleFetchResponseData;
        onOperModuleImportDeclareRequestAsync(context: MessageRouterContext, request: OperModuleImportDeclareRequest, response: OperModuleImportDeclareResponse): Promise<MessageResultType>;
        onOperModulePageRequestAsync(context: MessageRouterContext, request: OperModulePageRequest, response: OperModulePageResponse): Promise<MessageResultType>;
        onOperModuleDeleteRequestAsync(context: MessageRouterContext, request: OperModuleDeleteRequest, response: OperModuleDeleteResponse): Promise<MessageResultType>;
        onOperModuleFetchRequestAsync(context: MessageRouterContext, request: OperModuleFetchRequest, response: OperModuleFetchResponse): Promise<MessageResultType>;
        onOperModuleTreeRequestAsync(context: MessageRouterContext, request: OperModuleTreeRequest, response: OperModuleTreeResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/auth/router/OperModuleTypeActRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OperModuleTypeActListRequest } from 'sk/data/logic/auth/message/OperModuleTypeActListRequest';
    import { OperModuleTypeActListResponse } from 'sk/data/logic/auth/message/OperModuleTypeActListResponse';
    import { OperModuleTypeActController } from 'sk/service/data/logic/auth/controller/OperModuleTypeActController';
    export class OperModuleTypeActRouter extends MessageRouter {
        processCode: string;
        protected _operModuleTypeActController: OperModuleTypeActController;
        onOperModuleTypeActListRequestAsync(context: MessageRouterContext, request: OperModuleTypeActListRequest, response: OperModuleTypeActListResponse): Promise<MessageResultType>;
        private buildResponse;
        getRouter(): any;
    }
}
declare module "sk/service/logic/auth/router/RoleModuleActRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { RoleModuleActDeleteRequest } from 'sk/data/logic/auth/message/RoleModuleActDeleteRequest';
    import { RoleModuleActDeleteResponse } from 'sk/data/logic/auth/message/RoleModuleActDeleteResponse';
    import { RoleModuleActFindRequest } from 'sk/data/logic/auth/message/RoleModuleActFindRequest';
    import { RoleModuleActFindResponse } from 'sk/data/logic/auth/message/RoleModuleActFindResponse';
    import { RoleModuleActInsertRequest } from 'sk/data/logic/auth/message/RoleModuleActInsertRequest';
    import { RoleModuleActInsertResponse } from 'sk/data/logic/auth/message/RoleModuleActInsertResponse';
    import { RoleModuleActListRequest } from 'sk/data/logic/auth/message/RoleModuleActListRequest';
    import { RoleModuleActListResponse } from 'sk/data/logic/auth/message/RoleModuleActListResponse';
    import { RoleModuleActUpdateRequest } from 'sk/data/logic/auth/message/RoleModuleActUpdateRequest';
    import { RoleModuleActUpdateResponse } from 'sk/data/logic/auth/message/RoleModuleActUpdateResponse';
    import { OperModuleController } from 'sk/service/data/logic/auth/controller/OperModuleController';
    import { RoleModuleActController } from 'sk/service/data/logic/auth/controller/RoleModuleActController';
    export class RoleModuleActRouter extends MessageRouter {
        processCode: string;
        protected _roleModuleActController: RoleModuleActController;
        protected _operModuleController: OperModuleController;
        onRoleModuleActListRequestAsync(context: MessageRouterContext, request: RoleModuleActListRequest, response: RoleModuleActListResponse): Promise<MessageResultType>;
        onRoleModuleActFindRequestAsync(context: MessageRouterContext, request: RoleModuleActFindRequest, response: RoleModuleActFindResponse): Promise<MessageResultType>;
        onRoleModuleActInsertRequestAsync(context: MessageRouterContext, request: RoleModuleActInsertRequest, response: RoleModuleActInsertResponse): Promise<MessageResultType>;
        onRoleModuleActUpdateRequestAsync(context: MessageRouterContext, request: RoleModuleActUpdateRequest, response: RoleModuleActUpdateResponse): Promise<MessageResultType>;
        onRoleModuleActDeleteRequestAsync(context: MessageRouterContext, request: RoleModuleActDeleteRequest, response: RoleModuleActDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/auth/router/RoleRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { RoleListRequest } from 'sk/data/logic/auth/message/RoleListRequest';
    import { RoleListResponse } from 'sk/data/logic/auth/message/RoleListResponse';
    import { RoleController } from 'sk/service/data/logic/auth/controller/RoleController';
    export class RoleRouter extends MessageRouter {
        processCode: string;
        protected _roleController: RoleController;
        onRoleListRequestAsync(context: MessageRouterContext, request: RoleListRequest, response: RoleListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/auth/router/UserRoleRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { UserRoleFetchRequest } from 'sk/data/logic/auth/message/UserRoleFetchRequest';
    import { UserRoleFetchResponse } from 'sk/data/logic/auth/message/UserRoleFetchResponse';
    import { UserRoleFindRequest } from 'sk/data/logic/auth/message/UserRoleFindRequest';
    import { UserRoleFindResponse } from 'sk/data/logic/auth/message/UserRoleFindResponse';
    import { OperModuleController } from 'sk/service/data/logic/auth/controller/OperModuleController';
    import { OperModuleTypeActController } from 'sk/service/data/logic/auth/controller/OperModuleTypeActController';
    import { OperModuleTypeController } from 'sk/service/data/logic/auth/controller/OperModuleTypeController';
    import { RoleModuleActController } from 'sk/service/data/logic/auth/controller/RoleModuleActController';
    import { UserRoleController } from 'sk/service/data/logic/auth/controller/UserRoleController';
    export class UserRoleRouter extends MessageRouter {
        processCode: string;
        protected _userRoleController: UserRoleController;
        protected _roleModuleActController: RoleModuleActController;
        protected _operModuleController: OperModuleController;
        protected _operModuleTypeController: OperModuleTypeController;
        protected _environmentService: EnvironmentService;
        protected _jsonService: JsonService;
        protected _operModuleTypeActController: OperModuleTypeActController;
        private getUserRoleAsync;
        private makeUserTree;
        private setTree;
        private setParameters;
        onUserRoleFetchRequestAsync(context: MessageRouterContext, request: UserRoleFetchRequest, response: UserRoleFetchResponse): Promise<MessageResultType>;
        onUserRoleFindRequestAsync(context: MessageRouterContext, request: UserRoleFindRequest, response: UserRoleFindResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/base/LibraryLogicContext" {
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export class LibraryLogicContext extends LogicContext {
    }
}
declare module "sk/service/logic/base/PdmsConfigConst" {
    export class PdmsConfigConst {
        static readonly BaseLibraryTenantId = "00000000000000000000000000000001";
        static readonly StandardLibraryTenantId = "00000000000000000000000000009000";
        static readonly XJZTenantId = "cf91f28fe7d441be8e409445e7a8dfc0";
    }
}
declare module "sk/service/logic/base/ServiceConstants" {
    export class ServiceConstants {
        static SERVICE_DATA_CONVERT: string;
    }
}
declare module "sk/service/logic/business/router/AttributeCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { AttributeCategoryTreeRequest } from 'sk/data/logic/business/message/AttributeCategoryTreeRequest';
    import { AttributeCategoryTreeResponse, AttributeCategoryTreeResponseNodeVo } from 'sk/data/logic/business/message/AttributeCategoryTreeResponse';
    import { AttributeCategoryUnit } from 'sk/service/data/logic/module/logic/AttributeCategoryUnit';
    export class AttributeCategoryRouter extends MessageRouter {
        processCode: string;
        getTreeNode(dataset: DatasetResult<AttributeCategoryUnit>, unit: AttributeCategoryUnit, attribute?: boolean): AttributeCategoryTreeResponseNodeVo;
        getTreeNodes(dataset: DatasetResult<AttributeCategoryUnit>, parentId: string, items: StructureTypes<AttributeCategoryTreeResponseNodeVo>, attribute?: boolean): void;
        assignNode(node: AttributeCategoryTreeResponseNodeVo, unit: AttributeCategoryUnit): void;
        onAttributeCategoryTreeRequestAsync(context: MessageRouterContext, request: AttributeCategoryTreeRequest, response: AttributeCategoryTreeResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/AttributeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { AttributeGetRequest } from 'sk/data/logic/business/message/AttributeGetRequest';
    import { AttributeGetResponse } from 'sk/data/logic/business/message/AttributeGetResponse';
    import { AttributeListRequest } from 'sk/data/logic/business/message/AttributeListRequest';
    import { AttributeListResponse } from 'sk/data/logic/business/message/AttributeListResponse';
    import { AttributeSearchRequest } from 'sk/data/logic/business/message/AttributeSearchRequest';
    import { AttributeSearchResponse } from 'sk/data/logic/business/message/AttributeSearchResponse';
    import { AttributeController } from 'sk/service/data/logic/module/controller/AttributeController';
    export class AttributeRouter extends MessageRouter {
        processCode: string;
        protected _attributeController: AttributeController;
        onAttributeListRequestAsync(context: MessageRouterContext, request: AttributeListRequest, response: AttributeListResponse): Promise<MessageResultType>;
        onAttributeGetRequestAsync(context: MessageRouterContext, request: AttributeGetRequest, response: AttributeGetResponse): Promise<MessageResultType>;
        onAttributeSearchRequestAsync(context: MessageRouterContext, request: AttributeSearchRequest, response: AttributeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/FeatureGroupRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FeatureGroupListRequest } from 'sk/data/logic/business/message/FeatureGroupListRequest';
    import { FeatureGroupListResponse } from 'sk/data/logic/business/message/FeatureGroupListResponse';
    export class FeatureGroupRouter extends MessageRouter {
        processCode: string;
        onFeatureGroupListRequestAsync(context: MessageRouterContext, request: FeatureGroupListRequest, response: FeatureGroupListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/FeatureRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FeatureDeleteRequest } from 'sk/data/logic/business/message/FeatureDeleteRequest';
    import { FeatureDeleteResponse } from 'sk/data/logic/business/message/FeatureDeleteResponse';
    import { FeatureGetRequest } from 'sk/data/logic/business/message/FeatureGetRequest';
    import { FeatureGetResponse } from 'sk/data/logic/business/message/FeatureGetResponse';
    import { FeatureInsertRequest } from 'sk/data/logic/business/message/FeatureInsertRequest';
    import { FeatureInsertResponse } from 'sk/data/logic/business/message/FeatureInsertResponse';
    import { FeatureListRequest } from 'sk/data/logic/business/message/FeatureListRequest';
    import { FeatureListResponse } from 'sk/data/logic/business/message/FeatureListResponse';
    import { FeatureUpdateTypeRequest } from 'sk/data/logic/business/message/FeatureUpdateTypeRequest';
    import { FeatureUpdateTypeResponse } from 'sk/data/logic/business/message/FeatureUpdateTypeResponse';
    export class FeatureRouter extends MessageRouter {
        processCode: string;
        onFeatureListRequestAsync(context: MessageRouterContext, request: FeatureListRequest, response: FeatureListResponse): Promise<MessageResultType>;
        onFeatureGetRequestAsync(context: MessageRouterContext, request: FeatureGetRequest, response: FeatureGetResponse): Promise<MessageResultType>;
        onFeatureInsertRequestAsync(context: MessageRouterContext, request: FeatureInsertRequest, response: FeatureInsertResponse): Promise<MessageResultType>;
        onFeatureUpdateTypeRequestAsync(context: MessageRouterContext, request: FeatureUpdateTypeRequest, response: FeatureUpdateTypeResponse): Promise<MessageResultType>;
        onFeatureDeleteRequestAsync(context: MessageRouterContext, request: FeatureDeleteRequest, response: FeatureDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/ModuleConfigConfigureRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigConfigurePageRequest } from 'sk/data/logic/business/message/ConfigConfigurePageRequest';
    import { ConfigConfigurePageResponse } from 'sk/data/logic/business/message/ConfigConfigurePageResponse';
    export class ModuleConfigConfigureRouter extends MessageRouter {
        processCode: string;
        private buildConfigureOptionsDataAsync;
        private makeConfigurePageResponseDataAsync;
        private buildConfigurePageResponseContentVo;
        onConfigConfigurePageRequestAsync(context: MessageRouterContext, request: ConfigConfigurePageRequest, response: ConfigConfigurePageResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/ModuleConfigDecorateRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigDecoratePageRequest } from 'sk/data/logic/business/message/ConfigDecoratePageRequest';
    import { ConfigDecoratePageResponse } from 'sk/data/logic/business/message/ConfigDecoratePageResponse';
    export class ModuleConfigDecorateRouter extends MessageRouter {
        processCode: string;
        private makeDecoratePageResponseDataAsync;
        private buildDecoratePageResponseContentVo;
        onConfigDecoratePageRequestAsync(context: MessageRouterContext, request: ConfigDecoratePageRequest, response: ConfigDecoratePageResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/ModuleConfigVariableRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigVariableDeleteRequest } from 'sk/data/logic/business/message/ConfigVariableDeleteRequest';
    import { ConfigVariableDeleteResponse } from 'sk/data/logic/business/message/ConfigVariableDeleteResponse';
    import { ConfigVariableInsertRequest } from 'sk/data/logic/business/message/ConfigVariableInsertRequest';
    import { ConfigVariableInsertResponse } from 'sk/data/logic/business/message/ConfigVariableInsertResponse';
    import { ConfigVariablePageRequest } from 'sk/data/logic/business/message/ConfigVariablePageRequest';
    import { ConfigVariablePageResponse } from 'sk/data/logic/business/message/ConfigVariablePageResponse';
    import { ConfigVariableUpdateRequest } from 'sk/data/logic/business/message/ConfigVariableUpdateRequest';
    import { ConfigVariableUpdateResponse } from 'sk/data/logic/business/message/ConfigVariableUpdateResponse';
    export class ModuleConfigVariableRouter extends MessageRouter {
        processCode: string;
        private makeVariablePageResponseDataAsync;
        private buildVariablePageResponseContentVo;
        onConfigVariablePageRequestAsync(context: MessageRouterContext, request: ConfigVariablePageRequest, response: ConfigVariablePageResponse): Promise<MessageResultType>;
        onConfigVariableInsertRequestAsync(context: MessageRouterContext, request: ConfigVariableInsertRequest, response: ConfigVariableInsertResponse): Promise<MessageResultType>;
        onConfigVariableUpdateRequestAsync(context: MessageRouterContext, request: ConfigVariableUpdateRequest, response: ConfigVariableUpdateResponse): Promise<MessageResultType>;
        onConfigVariableDeleteRequestAsync(context: MessageRouterContext, request: ConfigVariableDeleteRequest, response: ConfigVariableDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/TenantRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { TenantPageRequest } from 'sk/data/logic/business/message/TenantPageRequest';
    import { TenantPageResponse } from 'sk/data/logic/business/message/TenantPageResponse';
    export class TenantRouter extends MessageRouter {
        processCode: string;
        onTenantPageRequestAsync(context: MessageRouterContext, request: TenantPageRequest, response: TenantPageResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/UserConfigRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { UserConfigSetRequest } from 'sk/data/logic/business/message/UserConfigSetRequest';
    import { UserConfigSetResponse } from 'sk/data/logic/business/message/UserConfigSetResponse';
    export class UserConfigRouter extends MessageRouter {
        processCode: string;
        protected _ossConnectionService: OssConnectionService;
        onUserConfigSetRequestAsync(context: MessageRouterContext, request: UserConfigSetRequest, response: UserConfigSetResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/router/UserSettingRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { ServerWarehouseService } from 'foundation/service/common/router/database/ServerWarehouseService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { UserSettingDeleteRequest } from 'sk/data/logic/business/message/UserSettingDeleteRequest';
    import { UserSettingDeleteResponse } from 'sk/data/logic/business/message/UserSettingDeleteResponse';
    import { UserSettingGetRequest } from 'sk/data/logic/business/message/UserSettingGetRequest';
    import { UserSettingGetResponse } from 'sk/data/logic/business/message/UserSettingGetResponse';
    import { UserSettingSetRequest } from 'sk/data/logic/business/message/UserSettingSetRequest';
    import { UserSettingSetResponse } from 'sk/data/logic/business/message/UserSettingSetResponse';
    import { TenantController } from 'sk/service/data/logic/member/controller/TenantController';
    import { LibraryController as ModuleLibraryController } from 'sk/service/data/logic/module/controller/LibraryController';
    import { LibraryController as ResourceLibraryController } from 'sk/service/data/logic/resource/controller/LibraryController';
    export class UserSettingRouter extends MessageRouter {
        processCode: string;
        protected _tenantController: TenantController;
        protected _resourceLibraryController: ResourceLibraryController;
        protected _moduleLibraryController: ModuleLibraryController;
        protected _serverWarehouseService: ServerWarehouseService;
        onUserSettingGetRequestAsync(context: MessageRouterContext, request: UserSettingGetRequest, response: UserSettingGetResponse): Promise<MessageResultType>;
        onUserSettingSetRequestAsync(context: MessageRouterContext, request: UserSettingSetRequest, response: UserSettingSetResponse): Promise<MessageResultType>;
        onUserSettingDeleteRequestAsync(context: MessageRouterContext, request: UserSettingDeleteRequest, response: UserSettingDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/business/service/ConfigStorageService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { ConfigConfigureController } from 'sk/service/data/logic/module/controller/ConfigConfigureController';
    import { ConfigConfigureOptionController } from 'sk/service/data/logic/module/controller/ConfigConfigureOptionController';
    import { ConfigDecorateController } from 'sk/service/data/logic/module/controller/ConfigDecorateController';
    import { ConfigDecorateItemController } from 'sk/service/data/logic/module/controller/ConfigDecorateItemController';
    import { ConfigVariableController } from 'sk/service/data/logic/module/controller/ConfigVariableController';
    export class ConfigStorageService {
        protected _ossService: OssConnectionService;
        protected _environmentService: EnvironmentService;
        protected _configConfigureController: ConfigConfigureController;
        protected _configConfigureOptionController: ConfigConfigureOptionController;
        protected _configDecorateController: ConfigDecorateController;
        protected _configDecorateItemController: ConfigDecorateItemController;
        protected _configVariableController: ConfigVariableController;
        writeConfigFileAsync(context: MessageRouterContext, libraryId: string, version: string): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/common/CommonLogicService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    export class CommonLogicService extends Service {
        protected _ossConnectionService: OssConnectionService;
        insertParametersAsync(context: DataContext, parameters: any, typeCode?: string, code?: string): Promise<ResultObject<String>>;
    }
}
declare module "sk/service/logic/design/router/ProductRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureDataset } from 'foundation/data/common/structure/StructureDataset';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { SchemeConfigAttributeService } from 'sk/data/scheme/config/SchemeConfigAttributeService';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { ProductProductDigitizationTreeRequest } from 'sk/data/logic/design/message/ProductProductDigitizationTreeRequest';
    import { ProductProductDigitizationTreeResponse } from 'sk/data/logic/design/message/ProductProductDigitizationTreeResponse';
    import { ProductProductFamilyInfoListRequest } from 'sk/data/logic/design/message/ProductProductFamilyInfoListRequest';
    import { ProductProductFamilyInfoListResponse } from 'sk/data/logic/design/message/ProductProductFamilyInfoListResponse';
    import { ProductProductGetDigRequest } from 'sk/data/logic/design/message/ProductProductGetDigRequest';
    import { ProductProductGetDigResponse } from 'sk/data/logic/design/message/ProductProductGetDigResponse';
    import { ProductProductGetMaterialRequest } from 'sk/data/logic/design/message/ProductProductGetMaterialRequest';
    import { ProductProductGetMaterialResponse, ProductProductGetMaterialResponseItemsVo } from 'sk/data/logic/design/message/ProductProductGetMaterialResponse';
    import { ProductProductGetRequest } from 'sk/data/logic/design/message/ProductProductGetRequest';
    import { ProductProductGetResponse } from 'sk/data/logic/design/message/ProductProductGetResponse';
    import { ProductProductListRequest } from 'sk/data/logic/design/message/ProductProductListRequest';
    import { ProductProductListResponse } from 'sk/data/logic/design/message/ProductProductListResponse';
    import { ProductProductPageRequest } from 'sk/data/logic/design/message/ProductProductPageRequest';
    import { ProductProductPageResponse, ProductProductPageResponseContentVo } from 'sk/data/logic/design/message/ProductProductPageResponse';
    import { ProductProductTreeRequest } from 'sk/data/logic/design/message/ProductProductTreeRequest';
    import { ProductProductTreeResponse } from 'sk/data/logic/design/message/ProductProductTreeResponse';
    import { ProductCategoryTreeResponseItemsVo } from 'sk/data/logic/module/message/ProductCategoryTreeResponse';
    import { ProductShowCategoryController } from 'sk/service/data/logic/digitization/controller/ProductShowCategoryController';
    import { ProductShowPerspectiveController } from 'sk/service/data/logic/digitization/controller/ProductShowPerspectiveController';
    import { BusinessTypeController } from 'sk/service/data/logic/module/controller/BusinessTypeController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { MaterialDto } from 'sk/service/data/logic/module/controller/MaterialDto';
    import { MaterialFamilyController } from 'sk/service/data/logic/module/controller/MaterialFamilyController';
    import { MaterialPatternController } from 'sk/service/data/logic/module/controller/MaterialPatternController';
    import { MaterialRuleController } from 'sk/service/data/logic/module/controller/MaterialRuleController';
    import { MaterialTypeController } from 'sk/service/data/logic/module/controller/MaterialTypeController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductDto } from 'sk/service/data/logic/module/controller/ProductDto';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { ProductCategoryUnit } from 'sk/service/data/logic/module/logic/ProductCategoryUnit';
    import { ModuleLibraryVersionController } from 'sk/service/data/logic/publish/controller/ModuleLibraryVersionController';
    export class ProductRouter extends MessageRouter {
        processCode: string;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _familySymbolController: FamilySymbolController;
        protected _businessTypeController: BusinessTypeController;
        protected _materialFamilyController: MaterialFamilyController;
        protected _materialPatternController: MaterialPatternController;
        protected _materialController: MaterialController;
        protected _familyTypeController: FamilyTypeController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _schemeModuleLibraryVersionController: ModuleLibraryVersionController;
        protected _productShowPerspectiveController: ProductShowPerspectiveController;
        protected _productShowCategoryController: ProductShowCategoryController;
        protected _schemeConfigService: SchemeConfigService;
        protected _materialTypeController: MaterialTypeController;
        protected _materialRuleController: MaterialRuleController;
        protected _attributeService: SchemeConfigAttributeService;
        private readonly _systemMaterialUnitCode;
        protected makeProductPageResponseData(dataset: DatasetResult<ProductDto>): StructureDataset<ProductProductPageResponseContentVo>;
        protected makeCategoryTreeResponseData(dataset: DatasetResult<ProductCategoryUnit>): StructureTypes<ProductCategoryTreeResponseItemsVo>;
        protected loopMakeCategoryTreeResponseItemsVo(unit: ProductCategoryUnit, dataset: DatasetResult<ProductCategoryUnit>): ProductCategoryTreeResponseItemsVo;
        protected buildProductCategoryTreeResponseItemsVo(unit: ProductCategoryUnit): ProductCategoryTreeResponseItemsVo;
        protected buildMaterialResponseData(productSymbolId: string, businessTypeCode: string, materialDto: MaterialDto): ProductProductGetMaterialResponseItemsVo;
        private getRuleProcessUnitsAsync;
        private getUnitVoAsync;
        onProductProductListRequestAsync(context: MessageRouterContext, request: ProductProductListRequest, response: ProductProductListResponse): Promise<MessageResultType>;
        onProductProductPageRequestAsync(context: MessageRouterContext, request: ProductProductPageRequest, response: ProductProductPageResponse): Promise<MessageResultType>;
        onProductProductTreeRequestAsync(context: MessageRouterContext, request: ProductProductTreeRequest, response: ProductProductTreeResponse): Promise<MessageResultType>;
        onProductProductDigitizationTreeRequestAsync(context: MessageRouterContext, request: ProductProductDigitizationTreeRequest, response: ProductProductDigitizationTreeResponse): Promise<MessageResultType>;
        onProductProductGetRequestAsync(context: MessageRouterContext, request: ProductProductGetRequest, response: ProductProductGetResponse): Promise<MessageResultType>;
        onProductProductGetMaterialRequestAsync(context: MessageRouterContext, request: ProductProductGetMaterialRequest, response: ProductProductGetMaterialResponse): Promise<MessageResultType>;
        onProductProductGetDigRequestAsync(context: MessageRouterContext, request: ProductProductGetDigRequest, response: ProductProductGetDigResponse): Promise<MessageResultType>;
        onProductProductFamilyInfoListRequestAsync(context: MessageRouterContext, request: ProductProductFamilyInfoListRequest, response: ProductProductFamilyInfoListResponse): Promise<MessageResultType>;
        private makeDigitizationCategoryTreeResponseData;
        private loopMakeDigitizationCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/util/JsonCompressUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    export class JsonCompressUtil {
        protected static _environmentService: EnvironmentService;
        static compressJsonFileAsync(sourceFile: string, targetFile: string): Promise<ResultObject<any>>;
        static decompressJsonFileAsync(sourceFile: string, targetFile: string): Promise<ResultObject<any>>;
    }
}
declare module "sk/service/logic/digitization/service/CadBuildService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNode, DrawingTree } from 'sk/data/scheme/drawing/data/DrawingNode';
    export class CadBuildService extends Service {
        work_path: string;
        private toolPath;
        protected _environmentService: EnvironmentService;
        initializeConfig(jconfig: any): void;
        convertAsync(drawingTree: DrawingTree, rootPath?: string): Promise<ResultObject<any>>;
        convertDrawingNodeFiles(drawingNode: DrawingNode, rootPath: string, drawPromises: Promise<ResultObject>[]): void;
        private convertDrawingItemDataAsync;
        buildAsync(drawingDocument: DrawingDataDocument, code: string, path: string): Promise<ResultObject<any>>;
    }
}
declare module "sk/service/logic/digitization/service/StorageService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { HttpDeviceService } from 'cross/core/device/http/HttpDeviceService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { SystemService } from 'cross/system/module/SystemService';
    import { StorageDigitizationTypeEnum } from 'foundation/data/common/enumeration/StorageDigitizationTypeEnum';
    import { StorageModeEnum } from 'foundation/data/common/enumeration/StorageModeEnum';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { IDataContext } from 'foundation/service/common/database/IDataContext';
    import { DataLogicService } from 'foundation/service/common/logic/DataLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { OssResult } from 'foundation/service/common/oss/OssResult';
    import { RouterService } from 'foundation/service/common/router/RouterService';
    import { DrawingNode, DrawingTree } from 'sk/data/scheme/drawing/data/DrawingNode';
    import { SchemeTechnologyDataDocument } from 'sk/data/scheme/model/SchemeTechnologyDataDocument';
    import { TaskTypeEnum } from 'sk/data/logic/calculate/enumeration/task/TaskTypeEnum';
    import { StorageTypeEnum } from 'sk/data/logic/digitization/enumeration/StorageTypeEnum';
    import { BatchItemGetResultRequest } from 'sk/data/logic/digitization/message/BatchItemGetResultRequest';
    import { BatchItemGetResultResponse, BatchItemGetResultResponseInfoVo } from 'sk/data/logic/digitization/message/BatchItemGetResultResponse';
    import { SubtaskUnit } from 'sk/service/data/logic/calculate/logic/SubtaskUnit';
    import { TaskUnit } from 'sk/service/data/logic/calculate/logic/TaskUnit';
    import { BatchItemController } from 'sk/service/data/logic/digitization/controller/BatchItemController';
    import { BatchItemDto } from 'sk/service/data/logic/digitization/controller/BatchItemDto';
    import { BatchItemUnit } from 'sk/service/data/logic/digitization/logic/BatchItemUnit';
    import { StorageUnit } from 'sk/service/data/logic/digitization/logic/StorageUnit';
    import { CommonLogicService } from "sk/service/logic/common/CommonLogicService";
    import { CadBuildService } from "sk/service/logic/digitization/service/CadBuildService";
    export class StorageService extends SystemService {
        protected _host: string;
        protected _port: string;
        _localStorageDirectory: string;
        protected _ossService: OssConnectionService;
        protected _batchItemController: BatchItemController;
        protected _dataLogicService: DataLogicService;
        protected _jsonService: JsonService;
        protected _httpService: HttpDeviceService;
        protected _routerService: RouterService;
        protected _commonLogicService: CommonLogicService;
        protected _cadBuildService: CadBuildService;
        constructor();
        initializeConfig(jconfig: any): void;
        getItemDatasAsync(context: MessageRouterContext, batchId: string): Promise<ResultObject<Object[]>>;
        getItemData(batchItem: BatchItemDto | any): any;
        resourceUpLoadAsync(context: MessageRouterContext, batchItem: BatchItemDto): Promise<ResultObject>;
        deleteCalculateOssAsync(context: MessageRouterContext, task: TaskUnit): Promise<ResultObject>;
        getCalculateTypeCodeByTaskTypeCd(taskTypeCd: TaskTypeEnum): string;
        uploadOssAsync(context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto): Promise<ResultObject>;
        copyFromOssFileAsync(context: IContext, from: string, to: string): Promise<OssResult>;
        uploadJsonAsync(context: IContext, remote: string, data: any): Promise<OssResult>;
        downloadJsonAsync(context: IContext, remote: string): Promise<OssResult>;
        existsObjectAsync(context: IContext, remote: string): Promise<OssResult>;
        onBatchItemUploadSuccessAsync: (context: MessageRouterContext, batchItem: BatchItemDto) => Promise<void>;
        onBatchItemUploadFailureAsync: (context: MessageRouterContext, batchItem: BatchItemDto) => Promise<void>;
        uploadContentAsync(context: IContext, modeCd: StorageModeEnum, digitizationCd: StorageDigitizationTypeEnum, id: string, name: string, content: any): Promise<ResultObject>;
        uploadProduceResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto, subtask?: SubtaskUnit) => Promise<ResultObject>;
        downloadSceneAsync(context: MessageRouterContext, id: string, version: any): Promise<ResultObject>;
        makeStorageUri(...parameters: Array<any>): string;
        uploadSceneAsync(context: MessageRouterContext, id: string, version: any, content: any): Promise<ResultObject>;
        uploadRender3PanoResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadRender4ResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadAddtionResultAsync: (context: MessageRouterContext, addtionOssUrl: string, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadRender3ResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadRenderResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadRender2ResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadDrawingDataAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto, subTask?: SubtaskUnit) => Promise<ResultObject>;
        private uploadSvgAndDrawingJsonAsync;
        uploadDrawingResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto, subTask?: SubtaskUnit) => Promise<ResultObject>;
        uploadExplodedResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadQuoteResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto, subTask?: SubtaskUnit) => Promise<ResultObject>;
        uploadAtlasResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto) => Promise<ResultObject>;
        uploadMakeResultAsync: (context: MessageRouterContext, task: TaskUnit, subTasks: DatasetResult<SubtaskUnit>, batchItem: BatchItemDto, subTask?: SubtaskUnit) => Promise<ResultObject>;
        setLinkInfosByBatchItemIdAsync(context: MessageRouterContext, request: BatchItemGetResultRequest, response: BatchItemGetResultResponse): Promise<ResultObject>;
        private getLinkUnitByBatchItemAsync;
        getResultInfosByBatchItemIdAsync(context: MessageRouterContext, id: string): Promise<ResultObject<StructureTypes<BatchItemGetResultResponseInfoVo>>>;
        getResultContentAsync(infos: StructureTypes<BatchItemGetResultResponseInfoVo>): Promise<ResultObject<any>>;
        setBatchItemStageFunAsync(context: LogicContext, batchItemId: string, param: any): Promise<ResultObject>;
        setBatchItemStageAsync(batchItemId: string, param: any): Promise<ResultObject>;
        getMakeFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit | BatchItemDto): Promise<ResultObject<FileInfo[]>>;
        getProduceFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit | BatchItemDto): Promise<ResultObject<FileInfo[]>>;
        getBomFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit | BatchItemDto): Promise<ResultObject<FileInfo[]>>;
        getExplodedFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit | BatchItemDto): Promise<ResultObject<FileInfo[]>>;
        getRenderFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit | BatchItemDto): Promise<ResultObject<FileInfo[]>>;
        getAtlasFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit | BatchItemDto): Promise<ResultObject<FileInfo[]>>;
        getDrawingFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit | BatchItemDto): Promise<ResultObject<FileInfo[]>>;
        createStorageByLinkIdAsync(context: IDataContext, storageType: StorageTypeEnum, linkId: string, linkVersion?: string): Promise<ResultObject<StorageUnit>>;
        existsDrawingDataBystorageIdAsync(context: IContext, storageId: string): Promise<ResultObject<boolean>>;
        loadDrawingDataByStorageIdAsync(context: MessageRouterContext, storageId: string): Promise<ResultObject<DrawingTree>>;
        uploadDrawingDataByStorageIdAsync(context: IContext, drawingTree: DrawingTree, storageId: string, optionCompress?: boolean): Promise<ResultObject>;
        uploadDrawingFilesAsync(context: IContext, drawingTree: DrawingTree, storageUri: string, drawingPath: string, storageId: string, uploadType?: string): Promise<ResultObject>;
        private uploadDrawingNodeZipDataAsync;
        private saveDrawingNodeDataAsync;
        private saveDrawingItemAsync;
        uploadDrawingNodeFilesAsync(context: IContext, drawingNode: DrawingNode, storageUri: string): Promise<ResultObject>;
        private uploadDrawingItemDataAsync;
        private cleanDrawingTree;
        uploadProduceDocumentByStorageIdAsync(context: IContext, produceDocument: any | string, storageId: string): Promise<ResultObject>;
        uploadOriginSchemeDocumentAsync(storageId: string, document: any): Promise<ResultObject>;
        uploadIpdStageFilesByStorageIdAsync(storageId: string, ipdFiles: Array<any>): Promise<ResultObject<any>>;
        uploadReportStageFilesByStorageIdAsync(storageId: string, reportFiles: Array<any>): Promise<ResultObject<any>>;
        uploadIpdMetaFileByStorageIdAsync(storageId: string, tenantIds: Array<string>): Promise<ResultObject<any>>;
        uploadLocalCheckMessageByStorageIdAsync(check: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        uploadLocalStructureMessageByStorageIdAsync(sturctureJson: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        uploadLocalBomJsonByStorageIdAsync(bomJson: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        uploadLocalSlidingBomJsonByStorageIdAsync(bomJson: any, storageId: string): Promise<ResultObject>;
        uploadLocalErrorMessageByStorageIdAsync(errorMessage: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        getLocalDirectoryUri(storageId: string): string;
        uploadLocalDrawingDataByStorageIdAsync(drawingTree: DrawingTree, storageId: string, optionCompress?: boolean): Promise<ResultObject>;
        uploadLocalDrawingFilesAsync(drawingTree: DrawingTree, storageId: string, uri: string): Promise<ResultObject>;
        makeDrawingConfigNewData(drawingNode: DrawingNode, storageId: string, drawingResults: Array<any>): any;
        makeFurnitureDrawingData(drawingTree: DrawingTree): DrawingTree;
        uploadCalculateResultByZipAsync(context: IContext, storageId: string): Promise<ResultObject>;
        uploadLocalTechnologyDocumentByStorageIdAsync(context: IContext, schemeDocument: SchemeTechnologyDataDocument, storageId: string, roomMode?: boolean, options?: any): Promise<ResultObject<any>>;
        private uploadLocalDocumentByRoomAsync;
        uploadLocalCompressBinaryAsync(technologyDocument: SchemeTechnologyDataDocument, uri: string): Promise<ResultObject>;
        uploadLocalCompressJsonAsync(technologyDocument: SchemeTechnologyDataDocument, uri: string): Promise<ResultObject>;
        uploadLocalMetaJsonAsync(meta: any, uri: string): Promise<ResultObject>;
        uploadTechnologyDocumentByStorageIdAsync(context: IContext, schemeDocument: SchemeTechnologyDataDocument, storageId: string, roomMode?: boolean, options?: any): Promise<ResultObject<any>>;
        uploadBomJsonByStorageIdAsync(context: IContext, bomJson: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        uploadCheckMessageByStorageIdAsync(context: IContext, check: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        uploadStructureMessageByStorageIdAsync(context: IContext, sturctureJson: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        uploadErrorMessageByStorageIdAsync(context: IContext, errorMessage: any, storageId: string, optionStatistics?: boolean): Promise<ResultObject>;
        uploadCompressBinaryAsync(context: IContext, technologyDocument: SchemeTechnologyDataDocument, uri: string): Promise<ResultObject>;
        uploadCompressJsonAsync(context: IContext, technologyDocument: SchemeTechnologyDataDocument, storageId: string, uri: string): Promise<ResultObject>;
        uploadMetaJsonAsync(context: IContext, meta: any, uri: string): Promise<ResultObject>;
        createSchemeTechnologyDataDocumentByStorageIdAsync(context: IContext, storageId: string): Promise<ResultObject<SchemeTechnologyDataDocument>>;
        getBomJsonByStoageIdAsync(storageId: string): Promise<ResultObject<any>>;
        getProduceJsonByStorageIdAsync(storageId: string): Promise<ResultObject<any>>;
        getProduceStrByStorageIdAsync(storageId: string): Promise<ResultObject<string>>;
        getTechnologyDocumentJsonByStorageIdAsync(context: IContext, storageId: string): Promise<ResultObject<any>>;
        getMetaJsonByStorageIdAsync(context: MessageRouterContext, storageId: string): Promise<ResultObject<any>>;
    }
    export type FileInfo = {
        fileName: string;
        filePath: string;
        option: any;
    };
}
declare module "sk/service/logic/digitization/router/DigitizationBatchItemRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { BatchItemGetResultContentRequest } from 'sk/data/logic/digitization/message/BatchItemGetResultContentRequest';
    import { BatchItemGetResultContentResponse } from 'sk/data/logic/digitization/message/BatchItemGetResultContentResponse';
    import { BatchItemGetResultRequest } from 'sk/data/logic/digitization/message/BatchItemGetResultRequest';
    import { BatchItemGetResultResponse } from 'sk/data/logic/digitization/message/BatchItemGetResultResponse';
    import { StorageService } from "sk/service/logic/digitization/service/StorageService";
    export class DigitizationBatchItemRouter extends MessageRouter {
        processCode: string;
        protected _storageService: StorageService;
        onBatchItemGetResultRequestAsync(context: MessageRouterContext, request: BatchItemGetResultRequest, response: BatchItemGetResultResponse): Promise<MessageResultType>;
        onBatchItemGetResultContentRequestAsync(context: MessageRouterContext, request: BatchItemGetResultContentRequest, response: BatchItemGetResultContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/service/CalculateService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleTypeDocumentService } from 'sk/data/family/rule/RuleTypeDocumentService';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { ResourceConfigService } from 'sk/data/resource/service/ResourceConfigService';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { LinkTypeEnum } from 'sk/data/logic/calculate/enumeration/task/LinkTypeEnum';
    import { DesignCreateResponse } from 'sk/data/logic/calculate/message/DesignCreateResponse';
    import { BatchItemTypeEnum } from 'sk/data/logic/digitization/enumeration/BatchItemTypeEnum';
    import { BatchCalculateItemRequest } from 'sk/data/logic/digitization/message/BatchCalculateItemRequest';
    import { BatchCreateRequest, BatchCreateRequestItemVo } from 'sk/data/logic/digitization/message/BatchCreateRequest';
    import { BatchController } from 'sk/service/data/logic/digitization/controller/BatchController';
    import { BatchItemController } from 'sk/service/data/logic/digitization/controller/BatchItemController';
    import { BatchItemUnit } from 'sk/service/data/logic/digitization/logic/BatchItemUnit';
    import { StorageService } from "sk/service/logic/digitization/service/StorageService";
    export type StageNodeFilter = {
        eliminate?: boolean;
        detail?: boolean;
        tenantId?: string;
        targetNodeIds: string[];
    };
    type CreateTaskFunAsync = (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, linkVersion: string, schemeName: string, storageId: string, item?: BatchCreateRequestItemVo, batchItemId?: string) => Promise<ResultObject<DesignCreateResponse>>;
    export class CalculateService extends Service {
        protected _batchController: BatchController;
        protected _batchItemController: BatchItemController;
        protected _storageService: StorageService;
        protected _familyDocumentService: FamilyDocumentService;
        protected _schemeDocumentService: SchemeDocumentService;
        protected _environmentService: EnvironmentService;
        protected _resourceConfigService: ResourceConfigService;
        protected _ruleTypeDocumentService: RuleTypeDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        protected _familyConfigService: FamilyConfigService;
        protected _schemeConfigService: SchemeConfigService;
        createBatchAsync(context: MessageRouterContext, request: BatchCreateRequest): Promise<ResultObject<{
            id: string;
            items: BatchItemUnit[];
        }>>;
        calculateBatchItemAsync: (context: MessageRouterContext, request: BatchCalculateItemRequest) => Promise<any>;
        getSendRequestFun: (typeCd: BatchItemTypeEnum) => CreateTaskFunAsync;
        sendProduceRequestByContentAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, linkVersion: string, schemeName: string, storageId: string, item: BatchCreateRequestItemVo, batchItemId?: string) => Promise<ResultObject<DesignCreateResponse>>;
        sendDrawingRequestByContentAsync: (linkId: string, linkVersion: string, schemeName: string, content: any) => Promise<DesignCreateResponse>;
        sendDrawingRequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, linkVersion: string, schemeName: string, storageId: string, item?: any) => Promise<ResultObject<DesignCreateResponse>>;
        private getResourcInfoAsync;
        sendTechnologyRequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, linkVersion: string, schemeName: string, storageId: string, item: BatchCreateRequestItemVo) => Promise<ResultObject<DesignCreateResponse>>;
        sendQuoteRequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, linkVersion: string, schemeName: string, storageId: string, item: BatchCreateRequestItemVo) => Promise<ResultObject<DesignCreateResponse>>;
        sendMakeRequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, linkVersion: string, schemeName: string, storageId: string, item: BatchCreateRequestItemVo) => Promise<ResultObject<DesignCreateResponse>>;
        sendRender2RequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, content: any, schemeName: string, storageId: string, item: BatchCreateRequestItemVo, batchItemId: string) => Promise<ResultObject<DesignCreateResponse>>;
        sendRenderRequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, content: any, schemeName: string, storageId: string, item: BatchCreateRequestItemVo, batchItemId?: string) => Promise<ResultObject<DesignCreateResponse>>;
        sendRender4RequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, content: any, schemeName: string, storageId: string, item: BatchCreateRequestItemVo, batchItemId?: string) => Promise<ResultObject<DesignCreateResponse>>;
        sendRender3RequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, content: any, schemeName: string, storageId: string, item: BatchCreateRequestItemVo, batchItemId?: string) => Promise<ResultObject<DesignCreateResponse>>;
        sendAtlasRequestAsync: (context: MessageRouterContext, linkType: LinkTypeEnum, linkId: string, linkVersion: string, schemeName: string, storageId: string, item: BatchCreateRequestItemVo) => Promise<ResultObject<DesignCreateResponse>>;
        createAllDrawingCalculateByStageAsync(context: DataContext, parameter: any, stage: any, stageIndex: number, stageInfo?: any): Promise<ResultObject>;
        createMakeCalculateByStageAsync(context: DataContext, parameters: {
            linkId: string;
            linkType: LinkTypeEnum;
            storageId: string;
            batchId: string;
            businessTypeId: string;
            orderId: string;
            orderName: string;
        }, stage: any, stageIndex: number, stageInfo?: any): Promise<ResultObject>;
        getTenantStagesByStorageIdAsync(context: MessageRouterContext, storageId: string): Promise<ResultObject<StageNodeFilter[]>>;
        private putLinkNodeIdAsync;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationBatchRouter" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { CommonService } from 'foundation/data/common/common/CommonService';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { BatchCalculateItemRequest } from 'sk/data/logic/digitization/message/BatchCalculateItemRequest';
    import { BatchCalculateItemResponse } from 'sk/data/logic/digitization/message/BatchCalculateItemResponse';
    import { BatchCreateRequest } from 'sk/data/logic/digitization/message/BatchCreateRequest';
    import { BatchCreateResponse } from 'sk/data/logic/digitization/message/BatchCreateResponse';
    import { BatchDeleteRequest } from 'sk/data/logic/digitization/message/BatchDeleteRequest';
    import { BatchDeleteResponse } from 'sk/data/logic/digitization/message/BatchDeleteResponse';
    import { BatchFetchRequest } from 'sk/data/logic/digitization/message/BatchFetchRequest';
    import { BatchFetchResponse } from 'sk/data/logic/digitization/message/BatchFetchResponse';
    import { BatchGetRequest } from 'sk/data/logic/digitization/message/BatchGetRequest';
    import { BatchGetResponse } from 'sk/data/logic/digitization/message/BatchGetResponse';
    import { BatchGetResultRequest } from 'sk/data/logic/digitization/message/BatchGetResultRequest';
    import { BatchGetResultResponse, BatchGetResultResponseFileInfoVo } from 'sk/data/logic/digitization/message/BatchGetResultResponse';
    import { BatchGetStructureResultRequest } from 'sk/data/logic/digitization/message/BatchGetStructureResultRequest';
    import { BatchGetStructureResultResponse } from 'sk/data/logic/digitization/message/BatchGetStructureResultResponse';
    import { BatchListRequest } from 'sk/data/logic/digitization/message/BatchListRequest';
    import { BatchListResponse } from 'sk/data/logic/digitization/message/BatchListResponse';
    import { BatchUpdateRequest } from 'sk/data/logic/digitization/message/BatchUpdateRequest';
    import { BatchUpdateResponse } from 'sk/data/logic/digitization/message/BatchUpdateResponse';
    import { BatchController } from 'sk/service/data/logic/digitization/controller/BatchController';
    import { BatchItemUnit } from 'sk/service/data/logic/digitization/logic/BatchItemUnit';
    import { CalculateService } from "sk/service/logic/digitization/service/CalculateService";
    import { StorageService } from "sk/service/logic/digitization/service/StorageService";
    export class DigitizationBatchRouter extends MessageRouter {
        processCode: string;
        protected _calculateService: CalculateService;
        protected _storageService: StorageService;
        protected _commonService: CommonService;
        protected _batchController: BatchController;
        protected _jsonService: JsonService;
        protected _ossService: OssConnectionService;
        onBatchGetRequestAsync(context: MessageRouterContext, request: BatchGetRequest, response: BatchGetResponse): Promise<MessageResultType>;
        onBatchFetchRequestAsync(context: MessageRouterContext, request: BatchFetchRequest, response: BatchFetchResponse): Promise<MessageResultType>;
        onBatchGetResultRequestAsync(context: MessageRouterContext, request: BatchGetResultRequest, response: BatchGetResultResponse): Promise<MessageResultType>;
        onBatchGetStructureResultRequestAsync(context: MessageRouterContext, request: BatchGetStructureResultRequest, response: BatchGetStructureResultResponse): Promise<MessageResultType>;
        onBatchDeleteRequestAsync(context: MessageRouterContext, request: BatchDeleteRequest, response: BatchDeleteResponse): Promise<MessageResultType>;
        onBatchUpdateRequestAsync(context: MessageRouterContext, request: BatchUpdateRequest, response: BatchUpdateResponse): Promise<MessageResultType>;
        onBatchListRequestAsync(context: MessageRouterContext, request: BatchListRequest, response: BatchListResponse): Promise<MessageResultType>;
        onBatchCalculateItemRequestAsync(context: MessageRouterContext, request: BatchCalculateItemRequest, response: BatchCalculateItemResponse): Promise<MessageResultType>;
        onBatchCreateRequestAsync(context: MessageRouterContext, request: BatchCreateRequest, response: BatchCreateResponse): Promise<MessageResultType>;
        getFileInfosByBatchItemAsync(context: ContextObject, batchItem: BatchItemUnit): Promise<ResultObject<StructureTypes<BatchGetResultResponseFileInfoVo>>>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationConfigCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigCategoryTreeRequest } from 'sk/data/logic/digitization/message/ConfigCategoryTreeRequest';
    import { ConfigCategoryTreeResponse } from 'sk/data/logic/digitization/message/ConfigCategoryTreeResponse';
    export class DigitizationConfigCategoryRouter extends MessageRouter {
        processCode: string;
        private _categoryController;
        onConfigCategoryTreeRequestAsync(context: MessageRouterContext, request: ConfigCategoryTreeRequest, response: ConfigCategoryTreeResponse): Promise<MessageResultType>;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationConfigVariableRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigVariablePageRequest } from 'sk/data/logic/digitization/message/ConfigVariablePageRequest';
    import { ConfigVariablePageResponse } from 'sk/data/logic/digitization/message/ConfigVariablePageResponse';
    export class DigitizationConfigVariableRouter extends MessageRouter {
        processCode: string;
        private _variableController;
        onConfigVariablePageRequestAsync(context: MessageRouterContext, request: ConfigVariablePageRequest, response: ConfigVariablePageResponse): Promise<MessageResultType>;
        private makeConfigVariablePageResponseData;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationFloorplanRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FloorplanDeleteRequest } from 'sk/data/logic/digitization/message/FloorplanDeleteRequest';
    import { FloorplanDeleteResponse } from 'sk/data/logic/digitization/message/FloorplanDeleteResponse';
    import { FloorplanInsertRequest } from 'sk/data/logic/digitization/message/FloorplanInsertRequest';
    import { FloorplanInsertResponse } from 'sk/data/logic/digitization/message/FloorplanInsertResponse';
    import { FloorplanPageRequest } from 'sk/data/logic/digitization/message/FloorplanPageRequest';
    import { FloorplanPageResponse } from 'sk/data/logic/digitization/message/FloorplanPageResponse';
    import { FloorplanUpdateRequest } from 'sk/data/logic/digitization/message/FloorplanUpdateRequest';
    import { FloorplanUpdateResponse } from 'sk/data/logic/digitization/message/FloorplanUpdateResponse';
    import { FloorplanController } from 'sk/service/data/logic/digitization/controller/FloorplanController';
    import { DigitizationStorageService } from 'sk/service/data/logic/digitization/storage/DigitizationStorageService';
    export class DigitizationFloorplanRouter extends MessageRouter {
        processCode: string;
        protected _storageService: DigitizationStorageService;
        protected _floorplanController: FloorplanController;
        onFloorplanPageRequestAsync(context: MessageRouterContext, request: FloorplanPageRequest, response: FloorplanPageResponse): Promise<MessageResultType>;
        onFloorplanInsertRequestAsync(context: MessageRouterContext, request: FloorplanInsertRequest, response: FloorplanInsertResponse): Promise<MessageResultType>;
        onFloorplanDeleteRequestAsync(context: MessageRouterContext, request: FloorplanDeleteRequest, response: FloorplanDeleteResponse): Promise<MessageResultType>;
        onFloorplanUpdateRequestAsync(context: MessageRouterContext, request: FloorplanUpdateRequest, response: FloorplanUpdateResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationHomeManageImageRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { HomeManageImageProcessRequest } from 'sk/data/logic/digitization/message/HomeManageImageProcessRequest';
    import { HomeManageImageProcessResponse } from 'sk/data/logic/digitization/message/HomeManageImageProcessResponse';
    export class DigitizationHomeManageImageRouter extends MessageRouter {
        protected _ossService: OssConnectionService;
        processCode: string;
        onHomeManageImageProcessRequestAsync(context: MessageRouterContext, request: HomeManageImageProcessRequest, response: HomeManageImageProcessResponse): Promise<MessageResultType>;
        private doReset;
        private doUpdate;
        private doBeauty;
        private convertImageToBeauty;
        private ossSave;
        private updateTxtFile;
        private getTxtBeautyInfo;
        private deleteOssPath;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationMerchandiseRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { SpecificationFamilyService } from 'sk/data/specification/family/SpecificationFamilyService';
    import { SpecificationPatternService } from 'sk/data/specification/pattern/SpecificationPatternService';
    import { MerchandiseCategoryItemListRequest } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemListRequest';
    import { MerchandiseCategoryItemListResponse } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemListResponse';
    import { MerchandiseCategoryItemPageRequest } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemPageRequest';
    import { MerchandiseCategoryItemPageResponse } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemPageResponse';
    import { MerchandiseCategoryItemSyncRequest } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemSyncRequest';
    import { MerchandiseCategoryItemSyncResponse } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemSyncResponse';
    import { MerchandiseCategoryItemUpdateRequest } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemUpdateRequest';
    import { MerchandiseCategoryItemUpdateResponse } from 'sk/data/logic/digitization/message/MerchandiseCategoryItemUpdateResponse';
    import { MerchandiseCategoryController } from 'sk/service/data/logic/digitization/controller/MerchandiseCategoryController';
    import { MerchandiseCategoryItemController } from 'sk/service/data/logic/digitization/controller/MerchandiseCategoryItemController';
    import { ProductShowCategoryItemController } from 'sk/service/data/logic/digitization/controller/ProductShowCategoryItemController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    export class DigitizationMerchandiseRouter extends MessageRouter {
        processCode: string;
        protected _merchandiseCategoryController: MerchandiseCategoryController;
        protected _merchandiseItemController: MerchandiseCategoryItemController;
        protected _productController: ProductController;
        protected _productShowCategoryItemController: ProductShowCategoryItemController;
        protected _datasetLogicService: DatasetLogicService;
        protected _specificationFamilyService: SpecificationFamilyService;
        protected _specificationPatternService: SpecificationPatternService;
        onMerchandiseCategoryItemListRequestAsync(context: MessageRouterContext, request: MerchandiseCategoryItemListRequest, response: MerchandiseCategoryItemListResponse): Promise<MessageResultType>;
        onMerchandiseCategoryItemUpdateRequestAsync(context: MessageRouterContext, request: MerchandiseCategoryItemUpdateRequest, response: MerchandiseCategoryItemUpdateResponse): Promise<MessageResultType>;
        onMerchandiseCategoryItemPageRequestAsync(context: MessageRouterContext, request: MerchandiseCategoryItemPageRequest, response: MerchandiseCategoryItemPageResponse): Promise<MessageResultType>;
        onMerchandiseCategoryItemSyncRequestAsync(context: MessageRouterContext, request: MerchandiseCategoryItemSyncRequest, response: MerchandiseCategoryItemSyncResponse): Promise<MessageResultType>;
        private buildListResponseItemsAsync;
        private buildListResponseFamilyAsync;
        private buildListResponsePatternAsync;
        private buildListResponseTypes;
        private buildListResponseCategories;
        private clearByLinkDataAsync;
        private clearByCategoryAsync;
        private syncCategoryAsync;
        private synCategoryItemAsync;
        private buildPageResponseContent;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationOssUrlRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { OssUrlVerifyRequest } from 'sk/data/logic/digitization/message/OssUrlVerifyRequest';
    import { OssUrlVerifyResponse } from 'sk/data/logic/digitization/message/OssUrlVerifyResponse';
    export class DigitizationOssUrlRouter extends MessageRouter {
        protected _ossService: OssConnectionService;
        processCode: string;
        onOssUrlVerifyRequestAsync(context: MessageRouterContext, request: OssUrlVerifyRequest, response: OssUrlVerifyResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationPerspectiveProductShowRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductShowPerspectiveGetRequest } from 'sk/data/logic/digitization/message/ProductShowPerspectiveGetRequest';
    import { ProductShowPerspectiveGetResponse } from 'sk/data/logic/digitization/message/ProductShowPerspectiveGetResponse';
    import { ProductShowPerspectivePageRequest } from 'sk/data/logic/digitization/message/ProductShowPerspectivePageRequest';
    import { ProductShowPerspectivePageResponse } from 'sk/data/logic/digitization/message/ProductShowPerspectivePageResponse';
    import { ProductShowPerspectiveSearchRequest } from 'sk/data/logic/digitization/message/ProductShowPerspectiveSearchRequest';
    import { ProductShowPerspectiveSearchResponse } from 'sk/data/logic/digitization/message/ProductShowPerspectiveSearchResponse';
    import { ProductShowPerspectiveSyncRequest } from 'sk/data/logic/digitization/message/ProductShowPerspectiveSyncRequest';
    import { ProductShowPerspectiveSyncResponse } from 'sk/data/logic/digitization/message/ProductShowPerspectiveSyncResponse';
    import { ProductShowCategoryController } from 'sk/service/data/logic/digitization/controller/ProductShowCategoryController';
    import { ProductShowPerspectiveController } from 'sk/service/data/logic/digitization/controller/ProductShowPerspectiveController';
    import { DesignInterfaceCacheService } from 'sk/service/data/logic/digitization/service/DesignInterfaceCacheService';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class DigitizationPerspectiveProductShowRouter extends MessageRouter {
        processCode: string;
        protected _productShowPerspectiveController: ProductShowPerspectiveController;
        protected _productShowCategoryController: ProductShowCategoryController;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _logicHistoryService: LogicHistoryService;
        protected _interfaceCacheService: DesignInterfaceCacheService;
        private addDataPathAsync;
        onProductShowPerspectiveGetRequestAsync(context: MessageRouterContext, request: ProductShowPerspectiveGetRequest, response: ProductShowPerspectiveGetResponse): Promise<MessageResultType>;
        onProductShowPerspectiveSyncRequestAsync(context: MessageRouterContext, request: ProductShowPerspectiveSyncRequest, response: ProductShowPerspectiveSyncResponse): Promise<MessageResultType>;
        onProductShowPerspectivePageRequestAsync(context: MessageRouterContext, request: ProductShowPerspectivePageRequest, response: ProductShowPerspectivePageResponse): Promise<MessageResultType>;
        onProductShowPerspectiveSearchRequestAsync(context: MessageRouterContext, request: ProductShowPerspectiveSearchRequest, response: ProductShowPerspectiveSearchResponse): Promise<MessageResultType>;
        private makePageResponseDataAsync;
        private buildPageResponseItemAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationPlatformSchemeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { PlatformSchemePublishRequest } from 'sk/data/logic/digitization/message/PlatformSchemePublishRequest';
    import { PlatformSchemePublishResponse } from 'sk/data/logic/digitization/message/PlatformSchemePublishResponse';
    import { EventController } from 'sk/service/data/logic/control/controller/EventController';
    import { EventHistoryController } from 'sk/service/data/logic/control/controller/EventHistoryController';
    import { BatchController } from 'sk/service/data/logic/digitization/controller/BatchController';
    import { BatchItemController } from 'sk/service/data/logic/digitization/controller/BatchItemController';
    import { SchemeController } from 'sk/service/data/logic/digitization/controller/SchemeController';
    import { StorageController } from 'sk/service/data/logic/digitization/controller/StorageController';
    import { DigitizationStorageService } from 'sk/service/data/logic/digitization/storage/DigitizationStorageService';
    export class DigitizationPlatformSchemeRouter extends MessageRouter {
        processCode: string;
        protected _schemeController: SchemeController;
        protected _storageController: StorageController;
        protected _eventController: EventController;
        protected _eventHistoryController: EventHistoryController;
        protected _batchController: BatchController;
        protected _batchItemController: BatchItemController;
        protected _digitizationStorageService: DigitizationStorageService;
        protected _ossService: OssConnectionService;
        onPlatformSchemePublishRequestAsync(context: MessageRouterContext, request: PlatformSchemePublishRequest, response: PlatformSchemePublishResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationProductNonsaleproductRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductNonsaleproductDeleteRequest } from 'sk/data/logic/digitization/message/ProductNonsaleproductDeleteRequest';
    import { ProductNonsaleproductDeleteResponse } from 'sk/data/logic/digitization/message/ProductNonsaleproductDeleteResponse';
    import { ProductNonsaleproductInsertRequest } from 'sk/data/logic/digitization/message/ProductNonsaleproductInsertRequest';
    import { ProductNonsaleproductInsertResponse } from 'sk/data/logic/digitization/message/ProductNonsaleproductInsertResponse';
    import { ProductNonsaleproductPageRequest } from 'sk/data/logic/digitization/message/ProductNonsaleproductPageRequest';
    import { ProductNonsaleproductPageResponse } from 'sk/data/logic/digitization/message/ProductNonsaleproductPageResponse';
    import { ProductNonsaleproductSearchCategorysRequest } from 'sk/data/logic/digitization/message/ProductNonsaleproductSearchCategorysRequest';
    import { ProductNonsaleproductSearchCategorysResponse } from 'sk/data/logic/digitization/message/ProductNonsaleproductSearchCategorysResponse';
    import { ProductNonsaleproductSyncRequest } from 'sk/data/logic/digitization/message/ProductNonsaleproductSyncRequest';
    import { ProductNonsaleproductSyncResponse } from 'sk/data/logic/digitization/message/ProductNonsaleproductSyncResponse';
    import { ProductShowCategoryItemController } from 'sk/service/data/logic/digitization/controller/ProductShowCategoryItemController';
    import { ProductShowPerspectiveController } from 'sk/service/data/logic/digitization/controller/ProductShowPerspectiveController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class DigitizationProductNonsaleproductRouter extends MessageRouter {
        processCode: string;
        protected _productShowCategoryItemController: ProductShowCategoryItemController;
        protected _logicHistoryService: LogicHistoryService;
        protected _productShowPerspectiveController: ProductShowPerspectiveController;
        private fetchNonSaleProductAsync;
        private fetchLickIdList;
        private makePageResponseDataAsync;
        private buildProductInsertDto;
        onProductNonsaleproductSyncRequestAsync(context: MessageRouterContext, request: ProductNonsaleproductSyncRequest, response: ProductNonsaleproductSyncResponse): Promise<MessageResultType>;
        onProductNonsaleproductInsertRequestAsync(context: MessageRouterContext, request: ProductNonsaleproductInsertRequest, response: ProductNonsaleproductInsertResponse): Promise<MessageResultType>;
        onProductNonsaleproductPageRequestAsync(context: MessageRouterContext, request: ProductNonsaleproductPageRequest, response: ProductNonsaleproductPageResponse): Promise<MessageResultType>;
        onProductNonsaleproductSearchCategorysRequestAsync(context: MessageRouterContext, request: ProductNonsaleproductSearchCategorysRequest, response: ProductNonsaleproductSearchCategorysResponse): Promise<MessageResultType>;
        onProductNonsaleproductDeleteRequestAsync(context: MessageRouterContext, request: ProductNonsaleproductDeleteRequest, response: ProductNonsaleproductDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationProductShowCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductShowCategoryDeleteRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryDeleteRequest';
    import { ProductShowCategoryDeleteResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryDeleteResponse';
    import { ProductShowCategoryGetRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryGetRequest';
    import { ProductShowCategoryGetResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryGetResponse';
    import { ProductShowCategoryInsertRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryInsertRequest';
    import { ProductShowCategoryInsertResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryInsertResponse';
    import { ProductShowCategorySearchRequest } from 'sk/data/logic/digitization/message/ProductShowCategorySearchRequest';
    import { ProductShowCategorySearchResponse, ProductShowCategorySearchResponseCategoryListVo } from 'sk/data/logic/digitization/message/ProductShowCategorySearchResponse';
    import { ProductShowCategorySortRequest } from 'sk/data/logic/digitization/message/ProductShowCategorySortRequest';
    import { ProductShowCategorySortResponse } from 'sk/data/logic/digitization/message/ProductShowCategorySortResponse';
    import { ProductShowCategoryTreeRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryTreeRequest';
    import { ProductShowCategoryTreeResponse, ProductShowCategoryTreeResponseItemsVo } from 'sk/data/logic/digitization/message/ProductShowCategoryTreeResponse';
    import { ProductShowCategoryUpdateRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryUpdateRequest';
    import { ProductShowCategoryUpdateResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryUpdateResponse';
    import { ProductShowCategoryUpdateShowtypeRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryUpdateShowtypeRequest';
    import { ProductShowCategoryUpdateShowtypeResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryUpdateShowtypeResponse';
    import { ProductShowCategoryController } from 'sk/service/data/logic/digitization/controller/ProductShowCategoryController';
    import { DesignInterfaceCacheService } from 'sk/service/data/logic/digitization/service/DesignInterfaceCacheService';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class DigitizationProductShowCategoryRouter extends MessageRouter {
        processCode: string;
        protected _productShowCategoryController: ProductShowCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _productController: ProductController;
        protected _interfaceCacheService: DesignInterfaceCacheService;
        onProductShowCategoryGetRequestAsync(context: MessageRouterContext, request: ProductShowCategoryGetRequest, response: ProductShowCategoryGetResponse): Promise<MessageResultType>;
        onProductShowCategoryTreeRequestAsync(context: MessageRouterContext, request: ProductShowCategoryTreeRequest, response: ProductShowCategoryTreeResponse): Promise<MessageResultType>;
        onProductShowCategorySearchRequestAsync(context: MessageRouterContext, request: ProductShowCategorySearchRequest, response: ProductShowCategorySearchResponse): Promise<MessageResultType>;
        onProductShowCategoryInsertRequestAsync(context: MessageRouterContext, request: ProductShowCategoryInsertRequest, response: ProductShowCategoryInsertResponse): Promise<MessageResultType>;
        onProductShowCategoryUpdateRequestAsync(context: MessageRouterContext, request: ProductShowCategoryUpdateRequest, response: ProductShowCategoryUpdateResponse): Promise<MessageResultType>;
        onProductShowCategorySortRequestAsync(context: MessageRouterContext, request: ProductShowCategorySortRequest, response: ProductShowCategorySortResponse): Promise<MessageResultType>;
        onProductShowCategoryUpdateShowtypeRequestAsync(context: MessageRouterContext, request: ProductShowCategoryUpdateShowtypeRequest, response: ProductShowCategoryUpdateShowtypeResponse): Promise<MessageResultType>;
        onProductShowCategoryDeleteRequestAsync(context: MessageRouterContext, request: ProductShowCategoryDeleteRequest, response: ProductShowCategoryDeleteResponse): Promise<MessageResultType>;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        makeNamePath(items: StructureTypes<ProductShowCategorySearchResponseCategoryListVo>, data: ProductShowCategoryTreeResponseItemsVo, namePath: string, name: string): void;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationProductShowRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductShowCategoryItemDeleteRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryItemDeleteRequest';
    import { ProductShowCategoryItemDeleteResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryItemDeleteResponse';
    import { ProductShowCategoryItemGetRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryItemGetRequest';
    import { ProductShowCategoryItemGetResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryItemGetResponse';
    import { ProductShowCategoryItemInsertRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryItemInsertRequest';
    import { ProductShowCategoryItemInsertResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryItemInsertResponse';
    import { ProductShowCategoryItemPageRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryItemPageRequest';
    import { ProductShowCategoryItemPageResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryItemPageResponse';
    import { ProductShowCategoryItemUpdateRequest } from 'sk/data/logic/digitization/message/ProductShowCategoryItemUpdateRequest';
    import { ProductShowCategoryItemUpdateResponse } from 'sk/data/logic/digitization/message/ProductShowCategoryItemUpdateResponse';
    import { ProductShowCategoryController } from 'sk/service/data/logic/digitization/controller/ProductShowCategoryController';
    import { ProductShowCategoryItemController } from 'sk/service/data/logic/digitization/controller/ProductShowCategoryItemController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class DigitizationProductShowRouter extends MessageRouter {
        processCode: string;
        private readonly _moduleSpaceName;
        private _maxLoopCount;
        protected _productShowCategoryItemController: ProductShowCategoryItemController;
        protected _productShowCategoryController: ProductShowCategoryController;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _familyController: FamilyController;
        protected _familyTypeController: FamilyTypeController;
        protected _logicHistoryService: LogicHistoryService;
        onProductShowCategoryItemGetRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemGetRequest, response: ProductShowCategoryItemGetResponse): Promise<MessageResultType>;
        onProductShowCategoryItemInsertRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemInsertRequest, response: ProductShowCategoryItemInsertResponse): Promise<MessageResultType>;
        onProductShowCategoryItemUpdateRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemUpdateRequest, response: ProductShowCategoryItemUpdateResponse): Promise<MessageResultType>;
        onProductShowCategoryItemPageRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemPageRequest, response: ProductShowCategoryItemPageResponse): Promise<MessageResultType>;
        onProductShowCategoryItemDeleteRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemDeleteRequest, response: ProductShowCategoryItemDeleteResponse): Promise<MessageResultType>;
        private buildProductShowItemDto;
        private makeFamilyPageResponseDataAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationResourceShowCategoryItemRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceShowCategoryItemDeleteRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemDeleteRequest';
    import { ResourceShowCategoryItemDeleteResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemDeleteResponse';
    import { ResourceShowCategoryItemGetRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemGetRequest';
    import { ResourceShowCategoryItemGetResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemGetResponse';
    import { ResourceShowCategoryItemInsertRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemInsertRequest';
    import { ResourceShowCategoryItemInsertResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemInsertResponse';
    import { ResourceShowCategoryItemPageRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemPageRequest';
    import { ResourceShowCategoryItemPageResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemPageResponse';
    import { ResourceShowCategoryItemUpdateRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemUpdateRequest';
    import { ResourceShowCategoryItemUpdateResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryItemUpdateResponse';
    import { ResourceShowCategoryItemController } from 'sk/service/data/logic/digitization/controller/ResourceShowCategoryItemController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class DigitizationResourceShowCategoryItemRouter extends MessageRouter {
        processCode: string;
        protected _resourceShowCategoryItemController: ResourceShowCategoryItemController;
        protected _logicHistoryService: LogicHistoryService;
        onResourceShowCategoryItemGetRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryItemGetRequest, response: ResourceShowCategoryItemGetResponse): Promise<MessageResultType>;
        onResourceShowCategoryItemInsertRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryItemInsertRequest, response: ResourceShowCategoryItemInsertResponse): Promise<MessageResultType>;
        onResourceShowCategoryItemUpdateRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryItemUpdateRequest, response: ResourceShowCategoryItemUpdateResponse): Promise<MessageResultType>;
        onResourceShowCategoryItemPageRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryItemPageRequest, response: ResourceShowCategoryItemPageResponse): Promise<MessageResultType>;
        onResourceShowCategoryItemDeleteRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryItemDeleteRequest, response: ResourceShowCategoryItemDeleteResponse): Promise<MessageResultType>;
        private buildResourceShowItemDto;
        private makePageResponseDataAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationResourceShowCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceShowCategoryDeleteRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryDeleteRequest';
    import { ResourceShowCategoryDeleteResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryDeleteResponse';
    import { ResourceShowCategoryGetRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryGetRequest';
    import { ResourceShowCategoryGetResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryGetResponse';
    import { ResourceShowCategoryInsertRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryInsertRequest';
    import { ResourceShowCategoryInsertResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryInsertResponse';
    import { ResourceShowCategoryTreeRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryTreeRequest';
    import { ResourceShowCategoryTreeResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryTreeResponse';
    import { ResourceShowCategoryUpdateRequest } from 'sk/data/logic/digitization/message/ResourceShowCategoryUpdateRequest';
    import { ResourceShowCategoryUpdateResponse } from 'sk/data/logic/digitization/message/ResourceShowCategoryUpdateResponse';
    import { ResourceShowCategoryController } from 'sk/service/data/logic/digitization/controller/ResourceShowCategoryController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class DigitizationResourceShowCategoryRouter extends MessageRouter {
        processCode: string;
        protected _resourceShowCategoryController: ResourceShowCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        onResourceShowCategoryGetRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryGetRequest, response: ResourceShowCategoryGetResponse): Promise<MessageResultType>;
        onResourceShowCategoryTreeRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryTreeRequest, response: ResourceShowCategoryTreeResponse): Promise<MessageResultType>;
        onResourceShowCategoryInsertRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryInsertRequest, response: ResourceShowCategoryInsertResponse): Promise<MessageResultType>;
        onResourceShowCategoryUpdateRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryUpdateRequest, response: ResourceShowCategoryUpdateResponse): Promise<MessageResultType>;
        onResourceShowCategoryDeleteRequestAsync(context: MessageRouterContext, request: ResourceShowCategoryDeleteRequest, response: ResourceShowCategoryDeleteResponse): Promise<MessageResultType>;
        private buildResourceShowDto;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationSchemeCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { SchemeCategoryDeleteRequest } from 'sk/data/logic/digitization/message/SchemeCategoryDeleteRequest';
    import { SchemeCategoryDeleteResponse } from 'sk/data/logic/digitization/message/SchemeCategoryDeleteResponse';
    import { SchemeCategoryInsertRequest } from 'sk/data/logic/digitization/message/SchemeCategoryInsertRequest';
    import { SchemeCategoryInsertResponse } from 'sk/data/logic/digitization/message/SchemeCategoryInsertResponse';
    import { SchemeCategoryListRequest } from 'sk/data/logic/digitization/message/SchemeCategoryListRequest';
    import { SchemeCategoryListResponse } from 'sk/data/logic/digitization/message/SchemeCategoryListResponse';
    import { SchemeCategoryTreeRequest } from 'sk/data/logic/digitization/message/SchemeCategoryTreeRequest';
    import { SchemeCategoryTreeResponse } from 'sk/data/logic/digitization/message/SchemeCategoryTreeResponse';
    import { SchemeCategoryUpdateRequest } from 'sk/data/logic/digitization/message/SchemeCategoryUpdateRequest';
    import { SchemeCategoryUpdateResponse } from 'sk/data/logic/digitization/message/SchemeCategoryUpdateResponse';
    import { SchemeCategoryController } from 'sk/service/data/logic/digitization/controller/SchemeCategoryController';
    import { SchemeController } from 'sk/service/data/logic/digitization/controller/SchemeController';
    export class DigitizationSchemeCategoryRouter extends MessageRouter {
        processCode: string;
        protected _schemeCategoryController: SchemeCategoryController;
        protected _schemeController: SchemeController;
        private makeCategoryTreeResponseItems;
        private makeCategoryTreeResponseItemsVo;
        private setCategoryTreeResponseItemVo;
        private steCategoryResponseItemVo;
        onSchemeCategoryTreeRequestAsync(context: MessageRouterContext, request: SchemeCategoryTreeRequest, response: SchemeCategoryTreeResponse): Promise<MessageResultType>;
        onSchemeCategoryListRequestAsync(context: MessageRouterContext, request: SchemeCategoryListRequest, response: SchemeCategoryListResponse): Promise<MessageResultType>;
        onSchemeCategoryInsertRequestAsync(context: MessageRouterContext, request: SchemeCategoryInsertRequest, response: SchemeCategoryInsertResponse): Promise<MessageResultType>;
        onSchemeCategoryUpdateRequestAsync(context: MessageRouterContext, request: SchemeCategoryUpdateRequest, response: SchemeCategoryUpdateResponse): Promise<MessageResultType>;
        onSchemeCategoryDeleteRequestAsync(context: MessageRouterContext, request: SchemeCategoryDeleteRequest, response: SchemeCategoryDeleteResponse): Promise<MessageResultType>;
        private deleteCategoryAsync;
        private deleteChildCategoriesAsync;
        private deleteChildCategoryAsync;
        private updateSchemeCategoryAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/service/ReportPathService" {
    import { SystemService } from 'cross/system/module/SystemService';
    export class ReportPathService extends SystemService {
        protected _localStorageDirectory: string;
        get localStorageDirectory(): string;
        initializeConfig(jconfig: any): void;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationSchemeReportResultRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { SchemeReportResultProcessMakeRequest } from 'sk/data/logic/digitization/message/SchemeReportResultProcessMakeRequest';
    import { SchemeReportResultProcessMakeResponse } from 'sk/data/logic/digitization/message/SchemeReportResultProcessMakeResponse';
    import { ReportPathService } from "sk/service/logic/digitization/service/ReportPathService";
    export class DigitizationSchemeReportResultRouter extends MessageRouter {
        processCode: string;
        protected _environmentService: EnvironmentService;
        protected _ossService: OssConnectionService;
        protected _reportPathService: ReportPathService;
        getLocalDirectoryUri(storageId: string): string;
        uploadFileAsync(context: IContext, ossName: string, fileName: string): Promise<ResultObject>;
        onSchemeReportResultProcessMakeRequestAsync(context: MessageRouterContext, request: SchemeReportResultProcessMakeRequest, response: SchemeReportResultProcessMakeResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationSchemeReportRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { SchemeReportResultProcessMakeRequest } from 'sk/data/logic/digitization/message/SchemeReportResultProcessMakeRequest';
    import { SchemeReportResultProcessMakeResponse } from 'sk/data/logic/digitization/message/SchemeReportResultProcessMakeResponse';
    export class DigitizationSchemeReportRouter extends MessageRouter {
        processCode: string;
        onSchemeReportResultProcessMakeRequestAsync(context: MessageRouterContext, request: SchemeReportResultProcessMakeRequest, response: SchemeReportResultProcessMakeResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationSchemeReportTemplateRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { SchemeReportTemplateGetListRequest } from 'sk/data/logic/digitization/message/SchemeReportTemplateGetListRequest';
    import { SchemeReportTemplateGetListResponse } from 'sk/data/logic/digitization/message/SchemeReportTemplateGetListResponse';
    export class DigitizationSchemeReportTemplateRouter extends MessageRouter {
        processCode: string;
        protected static _ossService: OssConnectionService;
        onSchemeReportTemplateGetListRequestAsync(context: MessageRouterContext, request: SchemeReportTemplateGetListRequest, response: SchemeReportTemplateGetListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/service/BomCalculateService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { SlidingDoorBedPlanksStructure } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorBedPlanksStructure';
    import { SlidingDoorHardwaresStructure } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorHardwaresStructure';
    import { SlidingDoorLayoutsStructure } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorLayoutsStructure';
    import { MaterialCalculationTypeEnum } from 'sk/data/family/enumeration/MaterialCalculationTypeEnum';
    import { SchemeStructureElement } from 'sk/data/scheme/database/scheme/element/SchemeStructureElement';
    import { BomDataDocument } from 'sk/data/scheme/model/bom/BomDataDocument';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ISchemeConfigMaterialVariableInfo } from 'sk/data/scheme/config/ISchemeConfigMaterialVariableInfo';
    import { ISchemeConfigSystemCodeInfo } from 'sk/data/scheme/config/ISchemeConfigSystemCodeInfo';
    import { SchemeConfigBusinessType } from 'sk/data/scheme/config/SchemeConfigBusinessType';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeTechnologyDataDocument } from 'sk/data/scheme/model/SchemeTechnologyDataDocument';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { BusinessTypeEnum } from 'sk/data/logic/digitization/enumeration/BusinessTypeEnum';
    export type BomCalculateParameters = {
        schemeDocument: SchemeTechnologyDataDocument;
        performerContext: SchemeElementPerformerContext;
        businessTypeId: string;
        calculationType: MaterialCalculationTypeEnum;
        optionStatistics?: boolean;
        bomUnits: Array<ISchemeConfigSystemCodeInfo>;
        bomVariables: Array<ISchemeConfigMaterialVariableInfo>;
        bomContent: any;
    };
    export type BomCalculateOptions = {
        document?: BomDataDocument;
        element: SchemeStructureElement;
        parameters: BomCalculateParameters;
    };
    export type SlidingReportData = {
        chestName: string;
        schemeName: string;
        slidingDoorLayout: SlidingDoorLayoutsStructure;
        slidingDoorHardware: SlidingDoorHardwaresStructure;
        slidingDoorBedPlanks: SlidingDoorBedPlanksStructure;
        slidingDoorHoleWidth: number;
        slidingDoorHoleHeight: number;
    };
    export class BomCalculateService extends Service {
        protected _schemeConfigService: SchemeConfigService;
        protected _schemeDocumentService: SchemeDocumentService;
        private readonly _systemMaterialUnitCode;
        protected _parametersMap: TypeMap<MaterialCalculationTypeEnum, Array<{
            businessTypeCode: string;
            calculationType: string;
        }>>;
        constructor();
        private prepareAsync;
        computeAsync(context: ContextObject, schemeDocument: SchemeTechnologyDataDocument, calcType?: string): Promise<ResultObject<{
            bomDocument: any;
            bomStatisticsDocument: any;
            slidingReportDataData: any;
        }>>;
        protected getSlidingReportDataAsync(schemeDocument: SchemeTechnologyDataDocument): Promise<SlidingReportData>;
        computeValuationAsync(context: ContextObject, performerContext: SchemeElementPerformerContext, technologyDocument: SchemeTechnologyDataDocument, businessTypeId: string, calculationType: MaterialCalculationTypeEnum, optionStatistics?: boolean): Promise<ResultObject>;
        protected computeBomAsync(context: ContextObject, options: BomCalculateOptions, optionStatistics?: boolean): Promise<ResultObject>;
        protected mergeMaterial(source: any, target: any): any;
        protected getBusinessIdByCode(businessTypeList: Array<SchemeConfigBusinessType>, code: BusinessTypeEnum): string;
    }
}
declare module "sk/service/logic/digitization/util/SchemeTechnologyCheckUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class SchemeTechnologyCheckUtil {
        static recursiveFunction(materials: Array<any>, nodeIds?: Array<string>): Array<string>;
        static checkBomIpdLinkId(bomFile: any, ipdFile: string): ResultObject;
        static checkIpdKeyData(ipdFile: any): ResultObject;
        static checkPlank(key: string, unit: any, processMap: Map<String, any>, resultObject: any): any;
        static ipdModuleRecursiveFunction(ipdModule: Array<any>, processMap: Map<string, Object>, resultObject: Object): boolean;
        static ipdRecursiveFunction(chest: Array<any>, processMap: Map<string, Object>, resultObject: Object): boolean;
    }
}
declare module "sk/service/logic/digitization/util/SchemeTechnologyProcessor" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { ValidateService } from 'foundation/core/module/validate/ValidateService';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DecorateCacheService } from 'sk/data/family/service/DecorateCacheService';
    import { StructureDocumentService } from 'sk/data/family/structure/StructureDocumentService';
    import { DrawingTree } from 'sk/data/scheme/drawing/data/DrawingNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeTechnologyDataDocument } from 'sk/data/scheme/model/SchemeTechnologyDataDocument';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { LinkTypeEnum } from 'sk/data/logic/calculate/enumeration/task/LinkTypeEnum';
    import { IpdConvertService } from 'sk/rule/process/ipd/IpdConvertService';
    import { BusinessTypeUnit } from 'sk/service/data/logic/module/logic/BusinessTypeUnit';
    import { CommonLogicService } from "sk/service/logic/common/CommonLogicService";
    import { BomCalculateService } from "sk/service/logic/digitization/service/BomCalculateService";
    import { StageNodeFilter } from "sk/service/logic/digitization/service/CalculateService";
    import { StorageService } from "sk/service/logic/digitization/service/StorageService";
    export type TechnologyProcessOptions = {
        needStorage?: boolean;
        roomMode?: boolean;
        linkId: string;
        linkType: LinkTypeEnum;
        linkVersion: string;
        documentSource?: any;
        document?: any;
        businessTypeId?: string;
        businessTypeCode?: string;
        computeBom?: boolean;
        computeDrawing: boolean;
        calculationType?: any;
        saveOriginalScheme?: boolean;
        optionSplitTenant?: boolean;
        optionCacheStatus?: boolean;
        optionStructureScheme?: boolean;
        optionUploadParameters?: boolean;
    };
    export class SchemeTechnologyProcessor {
        protected _schemeDocumentService: SchemeDocumentService;
        protected _structureDocumentService: StructureDocumentService;
        protected _bomCalculateService: BomCalculateService;
        protected _validateService: ValidateService;
        protected _storageService: StorageService;
        protected _ipdConvertService: IpdConvertService;
        protected _cacheService: CacheConnectionService;
        protected _schemeConfigService: SchemeConfigService;
        protected _commonLogicService: CommonLogicService;
        protected _decorateCacheService: DecorateCacheService;
        processTechnologyAsync(context: DataContext, options: TechnologyProcessOptions): Promise<ResultObject>;
        getBusinessTypeByCodeAsync(context: DataContext, code: string): Promise<ResultObject<BusinessTypeUnit>>;
        computeMakeAsync(context: ContextObject, technologyDocument: SchemeTechnologyDataDocument, orderNo: string, orderName: string, businessTypeId: string, nodeFilters?: Array<StageNodeFilter>): Promise<ResultObject<{
            content1?: any;
            content2?: string;
            contents?: Array<Array<any>>;
        }>>;
        makeIpdJsonFileAsync(context: ContextObject, schemeTechnologyDataDocument: SchemeTechnologyDataDocument, orderNo: any, orderName: any, stage?: any): Promise<ResultObject<Array<any>>>;
        makeIpdCheckFile(resultMessage: Object, bomDocument: any, ipdJson: any, errorList: Array<string>): void;
        computeDrawingAsync(context: DataContext, technologyDocument: SchemeTechnologyDataDocument): Promise<ResultObject<DrawingTree>>;
        computeCadAsync(drawingTree: DrawingTree, storageId: string): Promise<ResultObject<any>>;
        saveStructureAsync(schemeId: string, schemeVersion: string, stream: any): Promise<ResultObject>;
        getTenantStagesAsync(context: DataContext, schemeDocument: SchemeTechnologyDataDocument): Promise<ResultObject<StageNodeFilter[]>>;
        private putLinkNodeIdAsync;
        private getStagesAsync;
        updateEventProcessAsync(context: DataContext, parameters: {}): Promise<ResultObject<any>>;
    }
}
declare module "sk/service/logic/digitization/util/SchemeTechnologyProcessorUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    export class SchemeTechnologyProcessorUtil {
        static processTechnologyTestAsync(context: DataContext, requestJson: any): Promise<ResultObject>;
        static processDesignTechnologyTestAsync(context: DataContext, requestJson: any): Promise<ResultObject>;
        static processDesignTechnologyAsync(context: DataContext, requestJson: any): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationSchemeRouter" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { ValidateService } from 'foundation/core/module/validate/ValidateService';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { ServiceProcessService } from 'foundation/service/common/process/ServiceProcessService';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { RouterService } from 'foundation/service/common/router/RouterService';
    import { StructureDocumentService } from 'sk/data/family/structure/StructureDocumentService';
    import { DrawingTree } from 'sk/data/scheme/drawing/data/DrawingNode';
    import { SchemeTechnologyDataDocument } from 'sk/data/scheme/model/SchemeTechnologyDataDocument';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { LinkTypeEnum } from 'sk/data/logic/calculate/enumeration/task/LinkTypeEnum';
    import { SchemeCreateEventRequest } from 'sk/data/logic/digitization/message/SchemeCreateEventRequest';
    import { SchemeCreateEventResponse } from 'sk/data/logic/digitization/message/SchemeCreateEventResponse';
    import { SchemeDeleteRequest } from 'sk/data/logic/digitization/message/SchemeDeleteRequest';
    import { SchemeDeleteResponse } from 'sk/data/logic/digitization/message/SchemeDeleteResponse';
    import { SchemeDuplicateRequest } from 'sk/data/logic/digitization/message/SchemeDuplicateRequest';
    import { SchemeDuplicateResponse } from 'sk/data/logic/digitization/message/SchemeDuplicateResponse';
    import { SchemeGetCalculateResultRequest } from 'sk/data/logic/digitization/message/SchemeGetCalculateResultRequest';
    import { SchemeGetCalculateResultResponse } from 'sk/data/logic/digitization/message/SchemeGetCalculateResultResponse';
    import { SchemeGetRequest } from 'sk/data/logic/digitization/message/SchemeGetRequest';
    import { SchemeGetResponse } from 'sk/data/logic/digitization/message/SchemeGetResponse';
    import { SchemeGetTechnologyMetaRequest } from 'sk/data/logic/digitization/message/SchemeGetTechnologyMetaRequest';
    import { SchemeGetTechnologyMetaResponse } from 'sk/data/logic/digitization/message/SchemeGetTechnologyMetaResponse';
    import { SchemeInsertRequest } from 'sk/data/logic/digitization/message/SchemeInsertRequest';
    import { SchemeInsertResponse } from 'sk/data/logic/digitization/message/SchemeInsertResponse';
    import { SchemeMoveRequest } from 'sk/data/logic/digitization/message/SchemeMoveRequest';
    import { SchemeMoveResponse } from 'sk/data/logic/digitization/message/SchemeMoveResponse';
    import { SchemePageRequest } from 'sk/data/logic/digitization/message/SchemePageRequest';
    import { SchemePageResponse } from 'sk/data/logic/digitization/message/SchemePageResponse';
    import { SchemeProcessArrangementRequest } from 'sk/data/logic/digitization/message/SchemeProcessArrangementRequest';
    import { SchemeProcessArrangementResponse } from 'sk/data/logic/digitization/message/SchemeProcessArrangementResponse';
    import { SchemeProcessBomRequest } from 'sk/data/logic/digitization/message/SchemeProcessBomRequest';
    import { SchemeProcessBomResponse } from 'sk/data/logic/digitization/message/SchemeProcessBomResponse';
    import { SchemeProcessCalculateRequest } from 'sk/data/logic/digitization/message/SchemeProcessCalculateRequest';
    import { SchemeProcessCalculateResponse } from 'sk/data/logic/digitization/message/SchemeProcessCalculateResponse';
    import { SchemeProcessMakeRequest, SchemeProcessMakeRequestFilterVo } from 'sk/data/logic/digitization/message/SchemeProcessMakeRequest';
    import { SchemeProcessMakeResponse, SchemeProcessMakeResponseIpdDocumentVo } from 'sk/data/logic/digitization/message/SchemeProcessMakeResponse';
    import { SchemeProcessRenderRequest } from 'sk/data/logic/digitization/message/SchemeProcessRenderRequest';
    import { SchemeProcessRenderResponse } from 'sk/data/logic/digitization/message/SchemeProcessRenderResponse';
    import { SchemeProcessTaskTechnologyRequest } from 'sk/data/logic/digitization/message/SchemeProcessTaskTechnologyRequest';
    import { SchemeProcessTaskTechnologyResponse } from 'sk/data/logic/digitization/message/SchemeProcessTaskTechnologyResponse';
    import { SchemeProcessTechnologyCheckRequest } from 'sk/data/logic/digitization/message/SchemeProcessTechnologyCheckRequest';
    import { SchemeProcessTechnologyCheckResponse } from 'sk/data/logic/digitization/message/SchemeProcessTechnologyCheckResponse';
    import { SchemeProcessTechnologyRequest } from 'sk/data/logic/digitization/message/SchemeProcessTechnologyRequest';
    import { SchemeProcessTechnologyResponse } from 'sk/data/logic/digitization/message/SchemeProcessTechnologyResponse';
    import { SchemeProcessValuationRequest } from 'sk/data/logic/digitization/message/SchemeProcessValuationRequest';
    import { SchemeProcessValuationResponse } from 'sk/data/logic/digitization/message/SchemeProcessValuationResponse';
    import { SchemeRecycleRequest } from 'sk/data/logic/digitization/message/SchemeRecycleRequest';
    import { SchemeRecycleResponse } from 'sk/data/logic/digitization/message/SchemeRecycleResponse';
    import { SchemeRenameRequest } from 'sk/data/logic/digitization/message/SchemeRenameRequest';
    import { SchemeRenameResponse } from 'sk/data/logic/digitization/message/SchemeRenameResponse';
    import { SchemeRestoreRequest } from 'sk/data/logic/digitization/message/SchemeRestoreRequest';
    import { SchemeRestoreResponse } from 'sk/data/logic/digitization/message/SchemeRestoreResponse';
    import { SchemeSearchCacheRequest } from 'sk/data/logic/digitization/message/SchemeSearchCacheRequest';
    import { SchemeSearchCacheResponse } from 'sk/data/logic/digitization/message/SchemeSearchCacheResponse';
    import { SchemeSearchStorageRequest } from 'sk/data/logic/digitization/message/SchemeSearchStorageRequest';
    import { SchemeSearchStorageResponse } from 'sk/data/logic/digitization/message/SchemeSearchStorageResponse';
    import { SchemeUpdateRequest } from 'sk/data/logic/digitization/message/SchemeUpdateRequest';
    import { SchemeUpdateResponse } from 'sk/data/logic/digitization/message/SchemeUpdateResponse';
    import { SchemeUploadUnderlayFileRequest } from 'sk/data/logic/digitization/message/SchemeUploadUnderlayFileRequest';
    import { SchemeUploadUnderlayFileResponse } from 'sk/data/logic/digitization/message/SchemeUploadUnderlayFileResponse';
    import { IpdConvertService } from 'sk/rule/process/ipd/IpdConvertService';
    import { EventController } from 'sk/service/data/logic/control/controller/EventController';
    import { EventHistoryController } from 'sk/service/data/logic/control/controller/EventHistoryController';
    import { EventTypeController } from 'sk/service/data/logic/control/controller/EventTypeController';
    import { SchemeCategoryController } from 'sk/service/data/logic/digitization/controller/SchemeCategoryController';
    import { SchemeController } from 'sk/service/data/logic/digitization/controller/SchemeController';
    import { TechnologyController } from 'sk/service/data/logic/digitization/controller/TechnologyController';
    import { DigitizationStorageService } from 'sk/service/data/logic/digitization/storage/DigitizationStorageService';
    import { DrawingController } from 'sk/service/data/logic/module/controller/DrawingController';
    import { BusinessTypeUnit } from 'sk/service/data/logic/module/logic/BusinessTypeUnit';
    import { BomCalculateService } from "sk/service/logic/digitization/service/BomCalculateService";
    import { CadBuildService } from "sk/service/logic/digitization/service/CadBuildService";
    import { CalculateService, StageNodeFilter } from "sk/service/logic/digitization/service/CalculateService";
    import { StorageService } from "sk/service/logic/digitization/service/StorageService";
    type ProduceStageInfo = {
        index: number;
        content: string[];
        linkDataNodeFilter: StageNodeFilter;
    };
    export class DigitizationSchemeRouter extends MessageRouter {
        processCode: string;
        protected _digitizationStorageService: DigitizationStorageService;
        protected _schemeController: SchemeController;
        protected _schemeCategoryController: SchemeCategoryController;
        protected _drawingController: DrawingController;
        protected _technologyController: TechnologyController;
        protected _schemeDocumentService: SchemeDocumentService;
        protected _structureDocumentService: StructureDocumentService;
        protected _ipdConvertService: IpdConvertService;
        protected _ossService: OssConnectionService;
        protected _calculateService: CalculateService;
        protected _storageService: StorageService;
        protected _serviceProcessService: ServiceProcessService;
        protected _eventHistoryController: EventHistoryController;
        protected _eventTypeController: EventTypeController;
        protected _eventController: EventController;
        protected _environmentService: EnvironmentService;
        protected _cacheService: CacheConnectionService;
        protected _bomCalculateService: BomCalculateService;
        protected _routerService2: RouterService;
        protected _validateService: ValidateService;
        protected _cadBuildService: CadBuildService;
        protected _ossConnectionService: OssConnectionService;
        protected _expiredDays: number;
        onSchemeGetRequestAsync(context: MessageRouterContext, request: SchemeGetRequest, response: SchemeGetResponse): Promise<MessageResultType>;
        onSchemePageRequestAsync(context: MessageRouterContext, request: SchemePageRequest, response: SchemePageResponse): Promise<MessageResultType>;
        onSchemeInsertRequestAsync(context: MessageRouterContext, request: SchemeInsertRequest, response: SchemeInsertResponse): Promise<MessageResultType>;
        onSchemeDuplicateRequestAsync(context: MessageRouterContext, request: SchemeDuplicateRequest, response: SchemeDuplicateResponse): Promise<MessageResultType>;
        onSchemeRestoreRequestAsync(context: MessageRouterContext, request: SchemeRestoreRequest, response: SchemeRestoreResponse): Promise<MessageResultType>;
        onSchemeDeleteRequestAsync(context: MessageRouterContext, request: SchemeDeleteRequest, response: SchemeDeleteResponse): Promise<MessageResultType>;
        onSchemeRecycleRequestAsync(context: MessageRouterContext, request: SchemeRecycleRequest, response: SchemeRecycleResponse): Promise<MessageResultType>;
        onSchemeSearchCacheRequestAsync(context: MessageRouterContext, request: SchemeSearchCacheRequest, response: SchemeSearchCacheResponse): Promise<MessageResultType>;
        onSchemeGetCalculateResultRequestAsync(context: MessageRouterContext, request: SchemeGetCalculateResultRequest, response: SchemeGetCalculateResultResponse): Promise<MessageResultType>;
        onSchemeSearchStorageRequestAsync(context: MessageRouterContext, request: SchemeSearchStorageRequest, response: SchemeSearchStorageResponse): Promise<MessageResultType>;
        onSchemeMoveRequestAsync(context: MessageRouterContext, request: SchemeMoveRequest, response: SchemeMoveResponse): Promise<MessageResultType>;
        onSchemeRenameRequestAsync(context: MessageRouterContext, request: SchemeRenameRequest, response: SchemeRenameResponse): Promise<MessageResultType>;
        onSchemeUpdateRequestAsync(context: MessageRouterContext, request: SchemeUpdateRequest, response: SchemeUpdateResponse): Promise<MessageResultType>;
        onSchemeProcessMakeRequestAsync(context: MessageRouterContext, request: SchemeProcessMakeRequest, response: SchemeProcessMakeResponse): Promise<MessageResultType>;
        onSchemeProcessRenderRequestAsync(context: MessageRouterContext, request: SchemeProcessRenderRequest, response: SchemeProcessRenderResponse): Promise<MessageResultType>;
        onSchemeProcessBomRequestAsync(context: MessageRouterContext, request: SchemeProcessBomRequest, response: SchemeProcessBomResponse): Promise<MessageResultType>;
        onSchemeProcessTechnologyRequestAsync(context: MessageRouterContext, request: SchemeProcessTechnologyRequest, response: SchemeProcessTechnologyResponse): Promise<MessageResultType>;
        onSchemeCreateEventRequestAsync(context: MessageRouterContext, request: SchemeCreateEventRequest, response: SchemeCreateEventResponse): Promise<MessageResultType>;
        onSchemeProcessTaskTechnologyRequestAsync(context: MessageRouterContext, request: SchemeProcessTaskTechnologyRequest, response: SchemeProcessTaskTechnologyResponse): Promise<MessageResultType>;
        onSchemeProcessTechnologyCheckRequestAsync(context: MessageRouterContext, request: SchemeProcessTechnologyCheckRequest, response: SchemeProcessTechnologyCheckResponse): Promise<MessageResultType>;
        onSchemeGetTechnologyMetaRequestAsync(context: MessageRouterContext, request: SchemeGetTechnologyMetaRequest, response: SchemeGetTechnologyMetaResponse): Promise<MessageResultType>;
        onSchemeProcessValuationRequestAsync(context: MessageRouterContext, request: SchemeProcessValuationRequest, response: SchemeProcessValuationResponse): Promise<MessageResultType>;
        onSchemeProcessArrangementRequestAsync(context: MessageRouterContext, request: SchemeProcessArrangementRequest, response: SchemeProcessArrangementResponse): Promise<MessageResultType>;
        onSchemeProcessCalculateRequestAsync(context: MessageRouterContext, request: SchemeProcessCalculateRequest, response: SchemeProcessCalculateResponse): Promise<MessageResultType>;
        onSchemeUploadUnderlayFileRequestAsync(context: MessageRouterContext, request: SchemeUploadUnderlayFileRequest, response: SchemeUploadUnderlayFileResponse): Promise<MessageResultType>;
        getTimeByRouterServiceDate(dateStr: string): number;
        onProcessTechnologyByJsonRequestAsync(context: DataContext, requestJson: any, processId?: string): Promise<ResultObject>;
        onProcessTechnologyByJsonRequestAsync2(context: DataContext, requestJson: any, processId?: string): Promise<ResultObject>;
        createBatchByStagesAsync(context: MessageRouterContext, stages: StageNodeFilter[], parameters: {
            linkId: string;
            linkType: LinkTypeEnum;
            storageId: string;
            businessTypeId: string;
            orderId: string;
            orderName: string;
            batchId?: string;
        }): Promise<ResultObject<{
            batchId: string;
            stageInfoList: ProduceStageInfo[];
        }>>;
        computeMakeAsync(context: ContextObject, technologyDocument: SchemeTechnologyDataDocument, orderNo: string, orderName: string, businessTypeId: string, nodeFilters?: StructureTypes<SchemeProcessMakeRequestFilterVo>): Promise<ResultObject<{
            content1?: any;
            content2?: string;
            contents?: StructureTypes<SchemeProcessMakeResponseIpdDocumentVo>;
        }>>;
        computeDrawingAsync(context: DataContext, technologyDocument: SchemeTechnologyDataDocument): Promise<ResultObject<DrawingTree>>;
        getBusinessTypeByCodeAsync(context: DataContext, code: string): Promise<ResultObject<BusinessTypeUnit>>;
        createEventAsync(context: RouterContext, requestJson: string, code: string, linkId: string, linkType: string, eventParameter: any): Promise<ResultObject>;
        private buildDuplicateSchemeName;
        private getShowDate;
        private getLeftDays;
        private getDaySpan;
        private getExpiredDate;
        private addTagSearchCondition;
        private clearExpiredSchemeAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationSchemeScriptRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { SchemeScriptDeleteRequest } from 'sk/data/logic/digitization/message/SchemeScriptDeleteRequest';
    import { SchemeScriptDeleteResponse } from 'sk/data/logic/digitization/message/SchemeScriptDeleteResponse';
    import { SchemeScriptGetListRequest } from 'sk/data/logic/digitization/message/SchemeScriptGetListRequest';
    import { SchemeScriptGetListResponse } from 'sk/data/logic/digitization/message/SchemeScriptGetListResponse';
    import { SchemeScriptGetRequest } from 'sk/data/logic/digitization/message/SchemeScriptGetRequest';
    import { SchemeScriptGetResponse } from 'sk/data/logic/digitization/message/SchemeScriptGetResponse';
    import { SchemeScriptInsertRequest } from 'sk/data/logic/digitization/message/SchemeScriptInsertRequest';
    import { SchemeScriptInsertResponse } from 'sk/data/logic/digitization/message/SchemeScriptInsertResponse';
    import { SchemeScriptSearchRequest } from 'sk/data/logic/digitization/message/SchemeScriptSearchRequest';
    import { SchemeScriptSearchResponse } from 'sk/data/logic/digitization/message/SchemeScriptSearchResponse';
    import { SchemeScriptUpdateRequest } from 'sk/data/logic/digitization/message/SchemeScriptUpdateRequest';
    import { SchemeScriptUpdateResponse } from 'sk/data/logic/digitization/message/SchemeScriptUpdateResponse';
    import { SchemeScriptController } from 'sk/service/data/logic/digitization/controller/SchemeScriptController';
    export class DigitizationSchemeScriptRouter extends MessageRouter {
        processCode: string;
        protected _schemeScriptController: SchemeScriptController;
        onSchemeScriptInsertRequestAsync(context: MessageRouterContext, request: SchemeScriptInsertRequest, response: SchemeScriptInsertResponse): Promise<MessageResultType>;
        onSchemeScriptGetListRequestAsync(context: MessageRouterContext, request: SchemeScriptGetListRequest, response: SchemeScriptGetListResponse): Promise<MessageResultType>;
        onSchemeScriptGetRequestAsync(context: MessageRouterContext, request: SchemeScriptGetRequest, response: SchemeScriptGetResponse): Promise<MessageResultType>;
        onSchemeScriptDeleteRequestAsync(context: MessageRouterContext, request: SchemeScriptDeleteRequest, response: SchemeScriptDeleteResponse): Promise<MessageResultType>;
        onSchemeScriptSearchRequestAsync(context: MessageRouterContext, request: SchemeScriptSearchRequest, response: SchemeScriptSearchResponse): Promise<MessageResultType>;
        onSchemeScriptUpdateRequestAsync(context: MessageRouterContext, request: SchemeScriptUpdateRequest, response: SchemeScriptUpdateResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationSchemeTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { SchemeTypeGetRequest } from 'sk/data/logic/digitization/message/SchemeTypeGetRequest';
    import { SchemeTypeGetResponse } from 'sk/data/logic/digitization/message/SchemeTypeGetResponse';
    import { SchemeTypeInsertRequest } from 'sk/data/logic/digitization/message/SchemeTypeInsertRequest';
    import { SchemeTypeInsertResponse } from 'sk/data/logic/digitization/message/SchemeTypeInsertResponse';
    import { SchemeTypeSearchRequest } from 'sk/data/logic/digitization/message/SchemeTypeSearchRequest';
    import { SchemeTypeSearchResponse } from 'sk/data/logic/digitization/message/SchemeTypeSearchResponse';
    import { SchemeTypeController } from 'sk/service/data/logic/digitization/controller/SchemeTypeController';
    export class DigitizationSchemeTypeRouter extends MessageRouter {
        processCode: string;
        protected _schemeTypeController: SchemeTypeController;
        onSchemeTypeGetRequestAsync(context: MessageRouterContext, request: SchemeTypeGetRequest, response: SchemeTypeGetResponse): Promise<MessageResultType>;
        onSchemeTypeSearchRequestAsync(context: MessageRouterContext, request: SchemeTypeSearchRequest, response: SchemeTypeSearchResponse): Promise<MessageResultType>;
        onSchemeTypeInsertRequestAsync(context: MessageRouterContext, request: SchemeTypeInsertRequest, response: SchemeTypeInsertResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationStorageRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StorageDeleteRequest } from 'sk/data/logic/digitization/message/StorageDeleteRequest';
    import { StorageDeleteResponse } from 'sk/data/logic/digitization/message/StorageDeleteResponse';
    import { StoragePageRequest } from 'sk/data/logic/digitization/message/StoragePageRequest';
    import { StoragePageResponse } from 'sk/data/logic/digitization/message/StoragePageResponse';
    import { StorageController } from 'sk/service/data/logic/digitization/controller/StorageController';
    export class DigitizationStorageRouter extends MessageRouter {
        processCode: string;
        protected _storageController: StorageController;
        onStoragePageRequestAsync(context: MessageRouterContext, request: StoragePageRequest, response: StoragePageResponse): Promise<MessageResultType>;
        onStorageDeleteRequestAsync(context: MessageRouterContext, request: StorageDeleteRequest, response: StorageDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationStructureSchemeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { CommonService } from 'foundation/data/common/common/CommonService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { BusinessService } from 'sk/data/scheme/service/BusinessService';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { StructureSchemeCalculateRequest } from 'sk/data/logic/digitization/message/StructureSchemeCalculateRequest';
    import { StructureSchemeCalculateResponse } from 'sk/data/logic/digitization/message/StructureSchemeCalculateResponse';
    import { StructureSchemeGetStatusRequest } from 'sk/data/logic/digitization/message/StructureSchemeGetStatusRequest';
    import { StructureSchemeGetStatusResponse } from 'sk/data/logic/digitization/message/StructureSchemeGetStatusResponse';
    import { StructureSchemeInsertRequest } from 'sk/data/logic/digitization/message/StructureSchemeInsertRequest';
    import { StructureSchemeInsertResponse } from 'sk/data/logic/digitization/message/StructureSchemeInsertResponse';
    import { StructureSchemeSearchRequest } from 'sk/data/logic/digitization/message/StructureSchemeSearchRequest';
    import { StructureSchemeSearchResponse } from 'sk/data/logic/digitization/message/StructureSchemeSearchResponse';
    import { StructureSchemeUpdateRequest } from 'sk/data/logic/digitization/message/StructureSchemeUpdateRequest';
    import { StructureSchemeUpdateResponse } from 'sk/data/logic/digitization/message/StructureSchemeUpdateResponse';
    import { StructureSchemeUpdateStatusRequest } from 'sk/data/logic/digitization/message/StructureSchemeUpdateStatusRequest';
    import { StructureSchemeUpdateStatusResponse } from 'sk/data/logic/digitization/message/StructureSchemeUpdateStatusResponse';
    import { SchemeController } from 'sk/service/data/logic/digitization/controller/SchemeController';
    import { StructureController } from 'sk/service/data/logic/digitization/controller/StructureController';
    import { DigitizationStorageService } from 'sk/service/data/logic/digitization/storage/DigitizationStorageService';
    export class DigitizationStructureSchemeRouter extends MessageRouter {
        processCode: string;
        protected _digitizationStorageService: DigitizationStorageService;
        protected _structureController: StructureController;
        protected _schemeController: SchemeController;
        protected _schemeDocumentService: SchemeDocumentService;
        protected _commonService: CommonService;
        protected _businessService: BusinessService;
        onStructureSchemeInsertRequestAsync(context: MessageRouterContext, request: StructureSchemeInsertRequest, response: StructureSchemeInsertResponse): Promise<MessageResultType>;
        onStructureSchemeGetStatusRequestAsync(context: MessageRouterContext, request: StructureSchemeGetStatusRequest, response: StructureSchemeGetStatusResponse): Promise<MessageResultType>;
        onStructureSchemeUpdateStatusRequestAsync(context: MessageRouterContext, request: StructureSchemeUpdateStatusRequest, response: StructureSchemeUpdateStatusResponse): Promise<MessageResultType>;
        onStructureSchemeSearchRequestAsync(context: MessageRouterContext, request: StructureSchemeSearchRequest, response: StructureSchemeSearchResponse): Promise<MessageResultType>;
        onStructureSchemeCalculateRequestAsync(context: MessageRouterContext, request: StructureSchemeCalculateRequest, response: StructureSchemeCalculateResponse): Promise<MessageResultType>;
        onStructureSchemeUpdateRequestAsync(context: MessageRouterContext, request: StructureSchemeUpdateRequest, response: StructureSchemeUpdateResponse): Promise<MessageResultType>;
        private computeStructureAsync;
        private buildStructureAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationTechnologyRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { TechnologyDeleteRequest } from 'sk/data/logic/digitization/message/TechnologyDeleteRequest';
    import { TechnologyDeleteResponse } from 'sk/data/logic/digitization/message/TechnologyDeleteResponse';
    import { TechnologyGetRequest } from 'sk/data/logic/digitization/message/TechnologyGetRequest';
    import { TechnologyGetResponse } from 'sk/data/logic/digitization/message/TechnologyGetResponse';
    import { TechnologyInsertRequest } from 'sk/data/logic/digitization/message/TechnologyInsertRequest';
    import { TechnologyInsertResponse } from 'sk/data/logic/digitization/message/TechnologyInsertResponse';
    import { TechnologyUpdateRequest } from 'sk/data/logic/digitization/message/TechnologyUpdateRequest';
    import { TechnologyUpdateResponse } from 'sk/data/logic/digitization/message/TechnologyUpdateResponse';
    import { TechnologyController } from 'sk/service/data/logic/digitization/controller/TechnologyController';
    export class DigitizationTechnologyRouter extends MessageRouter {
        processCode: string;
        protected _technologyController: TechnologyController;
        onTechnologyGetRequestAsync(context: MessageRouterContext, request: TechnologyGetRequest, response: TechnologyGetResponse): Promise<MessageResultType>;
        onTechnologyInsertRequestAsync(context: MessageRouterContext, request: TechnologyInsertRequest, response: TechnologyInsertResponse): Promise<MessageResultType>;
        onTechnologyDeleteRequestAsync(context: MessageRouterContext, request: TechnologyDeleteRequest, response: TechnologyDeleteResponse): Promise<MessageResultType>;
        onTechnologyUpdateRequestAsync(context: MessageRouterContext, request: TechnologyUpdateRequest, response: TechnologyUpdateResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationUserRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { UserDeleteRequest } from 'sk/data/logic/digitization/message/UserDeleteRequest';
    import { UserDeleteResponse } from 'sk/data/logic/digitization/message/UserDeleteResponse';
    import { UserGetRequest } from 'sk/data/logic/digitization/message/UserGetRequest';
    import { UserGetResponse } from 'sk/data/logic/digitization/message/UserGetResponse';
    import { UserInsertRequest } from 'sk/data/logic/digitization/message/UserInsertRequest';
    import { UserInsertResponse } from 'sk/data/logic/digitization/message/UserInsertResponse';
    import { UserUpdateRequest } from 'sk/data/logic/digitization/message/UserUpdateRequest';
    import { UserUpdateResponse } from 'sk/data/logic/digitization/message/UserUpdateResponse';
    import { UserController } from 'sk/service/data/logic/digitization/controller/UserController';
    export class DigitizationUserRouter extends MessageRouter {
        processCode: string;
        protected _userController: UserController;
        onUserGetRequestAsync(context: MessageRouterContext, request: UserGetRequest, response: UserGetResponse): Promise<MessageResultType>;
        onUserInsertRequestAsync(context: MessageRouterContext, request: UserInsertRequest, response: UserInsertResponse): Promise<MessageResultType>;
        onUserUpdateRequestAsync(context: MessageRouterContext, request: UserUpdateRequest, response: UserUpdateResponse): Promise<MessageResultType>;
        onUserDeleteRequestAsync(context: MessageRouterContext, request: UserDeleteRequest, response: UserDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/DigitizationValidationRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { ValidationProcessRequest } from 'sk/data/logic/digitization/message/ValidationProcessRequest';
    import { ValidationProcessResponse } from 'sk/data/logic/digitization/message/ValidationProcessResponse';
    export class DigitizationValidationRouter extends MessageRouter {
        processCode: string;
        protected _schemeDocumentService: SchemeDocumentService;
        onValidationProcessRequestAsync(context: MessageRouterContext, request: ValidationProcessRequest, response: ValidationProcessResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/router/LibraryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { LibraryPageRequest } from 'sk/data/logic/digitization/message/LibraryPageRequest';
    import { LibraryPageResponse } from 'sk/data/logic/digitization/message/LibraryPageResponse';
    export class LibraryRouter extends MessageRouter {
        processCode: string;
        onLibraryPageRequestAsync(context: MessageRouterContext, request: LibraryPageRequest, response: LibraryPageResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/digitization/util/SchemeTenantUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { StageNodeFilter } from "sk/service/logic/digitization/service/CalculateService";
    export class SchemeTenantUtil {
        static getTenantStagesAsync(context: ContextObject, schemeDocument: SchemeDocument): Promise<ResultObject<StageNodeFilter[]>>;
        private static putLinkNodeIdAsync;
    }
}
declare module "sk/service/logic/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/service/logic/language/router/LanguageRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { LanguageFindRequest } from 'sk/data/logic/language/message/LanguageFindRequest';
    import { LanguageFindResponse } from 'sk/data/logic/language/message/LanguageFindResponse';
    import { LanguageGetListRequest } from 'sk/data/logic/language/message/LanguageGetListRequest';
    import { LanguageGetListResponse } from 'sk/data/logic/language/message/LanguageGetListResponse';
    export class LanguageRouter extends MessageRouter {
        processCode: string;
        onLanguageFindRequestAsync(context: MessageRouterContext, request: LanguageFindRequest, response: LanguageFindResponse): Promise<MessageResultType>;
        onLanguageGetListRequestAsync(context: MessageRouterContext, request: LanguageGetListRequest, response: LanguageGetListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/LogicWorkflowUtil" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class LogicWorkflowUtil {
        static loadAsync(context?: IContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/message/router/MessageMessageRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { MessageDeleteRequest } from 'sk/data/logic/message/message/MessageDeleteRequest';
    import { MessageDeleteResponse } from 'sk/data/logic/message/message/MessageDeleteResponse';
    import { MessageFetchRequest } from 'sk/data/logic/message/message/MessageFetchRequest';
    import { MessageFetchResponse } from 'sk/data/logic/message/message/MessageFetchResponse';
    import { MessageFindResourceRequest } from 'sk/data/logic/message/message/MessageFindResourceRequest';
    import { MessageFindResourceResponse } from 'sk/data/logic/message/message/MessageFindResourceResponse';
    import { MessageImportRequest } from 'sk/data/logic/message/message/MessageImportRequest';
    import { MessageImportResponse } from 'sk/data/logic/message/message/MessageImportResponse';
    import { MessageInsertOrUpdateResourceRequest } from 'sk/data/logic/message/message/MessageInsertOrUpdateResourceRequest';
    import { MessageInsertOrUpdateResourceResponse } from 'sk/data/logic/message/message/MessageInsertOrUpdateResourceResponse';
    import { MessageUploadRequest } from 'sk/data/logic/message/message/MessageUploadRequest';
    import { MessageUploadResponse } from 'sk/data/logic/message/message/MessageUploadResponse';
    import { LanguageController } from 'sk/service/data/logic/logic/controller/LanguageController';
    import { MessageController } from 'sk/service/data/logic/logic/controller/MessageController';
    import { MessageResourceController } from 'sk/service/data/logic/logic/controller/MessageResourceController';
    export class MessageMessageRouter extends MessageRouter {
        processCode: string;
        protected _languageController: LanguageController;
        protected _messageController: MessageController;
        protected _messageResourceController: MessageResourceController;
        protected _ossConnectionService: OssConnectionService;
        onMessageFetchRequestAsync(context: MessageRouterContext, request: MessageFetchRequest, response: MessageFetchResponse): Promise<MessageResultType>;
        onMessageFindResourceRequestAsync(context: MessageRouterContext, request: MessageFindResourceRequest, response: MessageFindResourceResponse): Promise<MessageResultType>;
        onMessageImportRequestAsync(context: MessageRouterContext, request: MessageImportRequest, response: MessageImportResponse): Promise<MessageResultType>;
        onMessageInsertOrUpdateResourceRequestAsync(context: MessageRouterContext, request: MessageInsertOrUpdateResourceRequest, response: MessageInsertOrUpdateResourceResponse): Promise<MessageResultType>;
        onMessageDeleteRequestAsync(context: MessageRouterContext, request: MessageDeleteRequest, response: MessageDeleteResponse): Promise<MessageResultType>;
        onMessageUploadRequestAsync(context: MessageRouterContext, request: MessageUploadRequest, response: MessageUploadResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/LogicRelationUtil" {
    import { FamilyRelation } from 'sk/data/family/util/FamilyDataDocumentRelationUtil';
    import { LogicRelationItem } from 'sk/service/data/logic/module/service/LogicRelationItem';
    export class LogicRelationUtil {
        static getLogicRelationItems(familyRelations: Array<FamilyRelation>): LogicRelationItem[];
    }
}
declare module "sk/service/logic/module/router/AttributeCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { AttributeCategoryDeleteRequest } from 'sk/data/logic/module/message/AttributeCategoryDeleteRequest';
    import { AttributeCategoryDeleteResponse } from 'sk/data/logic/module/message/AttributeCategoryDeleteResponse';
    import { AttributeCategoryInsertRequest } from 'sk/data/logic/module/message/AttributeCategoryInsertRequest';
    import { AttributeCategoryInsertResponse } from 'sk/data/logic/module/message/AttributeCategoryInsertResponse';
    import { AttributeCategoryTreeRequest } from 'sk/data/logic/module/message/AttributeCategoryTreeRequest';
    import { AttributeCategoryTreeResponse, AttributeCategoryTreeResponseNodeVo } from 'sk/data/logic/module/message/AttributeCategoryTreeResponse';
    import { AttributeCategoryUpdateRequest } from 'sk/data/logic/module/message/AttributeCategoryUpdateRequest';
    import { AttributeCategoryUpdateResponse } from 'sk/data/logic/module/message/AttributeCategoryUpdateResponse';
    import { AttributeCategoryController } from 'sk/service/data/logic/module/controller/AttributeCategoryController';
    import { AttributeCategoryUnit } from 'sk/service/data/logic/module/logic/AttributeCategoryUnit';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class AttributeCategoryRouter extends MessageRouter {
        processCode: string;
        protected _attributeCategoryController: AttributeCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        getTreeNode(dataset: DatasetResult<AttributeCategoryUnit>, unit: AttributeCategoryUnit, attribute?: boolean): AttributeCategoryTreeResponseNodeVo;
        getTreeNodes(dataset: DatasetResult<AttributeCategoryUnit>, parentId: string, items: StructureTypes<AttributeCategoryTreeResponseNodeVo>, attribute?: boolean): void;
        assignNode(node: AttributeCategoryTreeResponseNodeVo, unit: AttributeCategoryUnit): void;
        onAttributeCategoryTreeRequestAsync(context: MessageRouterContext, request: AttributeCategoryTreeRequest, response: AttributeCategoryTreeResponse): Promise<MessageResultType>;
        onAttributeCategoryInsertRequestAsync(context: MessageRouterContext, request: AttributeCategoryInsertRequest, response: AttributeCategoryInsertResponse): Promise<MessageResultType>;
        onAttributeCategoryUpdateRequestAsync(context: MessageRouterContext, request: AttributeCategoryUpdateRequest, response: AttributeCategoryUpdateResponse): Promise<MessageResultType>;
        onAttributeCategoryDeleteRequestAsync(context: MessageRouterContext, request: AttributeCategoryDeleteRequest, response: AttributeCategoryDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/AttributeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { AttributeDeleteRequest } from 'sk/data/logic/module/message/AttributeDeleteRequest';
    import { AttributeDeleteResponse } from 'sk/data/logic/module/message/AttributeDeleteResponse';
    import { AttributeGetRequest } from 'sk/data/logic/module/message/AttributeGetRequest';
    import { AttributeGetResponse } from 'sk/data/logic/module/message/AttributeGetResponse';
    import { AttributeInsertRequest } from 'sk/data/logic/module/message/AttributeInsertRequest';
    import { AttributeInsertResponse } from 'sk/data/logic/module/message/AttributeInsertResponse';
    import { AttributeListRequest } from 'sk/data/logic/module/message/AttributeListRequest';
    import { AttributeListResponse } from 'sk/data/logic/module/message/AttributeListResponse';
    import { AttributeSearchRequest } from 'sk/data/logic/module/message/AttributeSearchRequest';
    import { AttributeSearchResponse } from 'sk/data/logic/module/message/AttributeSearchResponse';
    import { AttributeUpdateRequest } from 'sk/data/logic/module/message/AttributeUpdateRequest';
    import { AttributeUpdateResponse } from 'sk/data/logic/module/message/AttributeUpdateResponse';
    import { AttributeCategoryController } from 'sk/service/data/logic/module/controller/AttributeCategoryController';
    import { AttributeController } from 'sk/service/data/logic/module/controller/AttributeController';
    import { AttributeTypeController } from 'sk/service/data/logic/module/controller/AttributeTypeController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class AttributeRouter extends MessageRouter {
        processCode: string;
        protected _attributeController: AttributeController;
        protected _attributeTypeController: AttributeTypeController;
        protected _attributeCategoryController: AttributeCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        onAttributeListRequestAsync(context: MessageRouterContext, request: AttributeListRequest, response: AttributeListResponse): Promise<MessageResultType>;
        onAttributeGetRequestAsync(context: MessageRouterContext, request: AttributeGetRequest, response: AttributeGetResponse): Promise<MessageResultType>;
        onAttributeSearchRequestAsync(context: MessageRouterContext, request: AttributeSearchRequest, response: AttributeSearchResponse): Promise<MessageResultType>;
        onAttributeInsertRequestAsync(context: MessageRouterContext, request: AttributeInsertRequest, response: AttributeInsertResponse): Promise<MessageResultType>;
        onAttributeUpdateRequestAsync(context: MessageRouterContext, request: AttributeUpdateRequest, response: AttributeUpdateResponse): Promise<MessageResultType>;
        onAttributeDeleteRequestAsync(context: MessageRouterContext, request: AttributeDeleteRequest, response: AttributeDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/AttributeTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { AttributeTypeSearchRequest } from 'sk/data/logic/module/message/AttributeTypeSearchRequest';
    import { AttributeTypeSearchResponse } from 'sk/data/logic/module/message/AttributeTypeSearchResponse';
    import { AttributeTypeController } from 'sk/service/data/logic/module/controller/AttributeTypeController';
    export class AttributeTypeRouter extends MessageRouter {
        processCode: string;
        protected _attributeTypeController: AttributeTypeController;
        onAttributeTypeSearchRequestAsync(context: MessageRouterContext, request: AttributeTypeSearchRequest, response: AttributeTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/custom/ConfigRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetControllerContext } from 'foundation/service/common/router/database/DatasetControllerContext';
    import { DatasetControllerRouter } from 'foundation/service/common/router/database/DatasetControllerRouter';
    import { ConfigParameterController } from 'sk/service/data/logic/calculate/controller/ConfigParameterController';
    import { ConfigConfigureController } from 'sk/service/data/logic/module/controller/ConfigConfigureController';
    import { ConfigConfigureOptionController } from 'sk/service/data/logic/module/controller/ConfigConfigureOptionController';
    import { ConfigDecorateController } from 'sk/service/data/logic/module/controller/ConfigDecorateController';
    import { ConfigDecorateItemController } from 'sk/service/data/logic/module/controller/ConfigDecorateItemController';
    import { ConfigFormulaController } from 'sk/service/data/logic/module/controller/ConfigFormulaController';
    import { ConfigVariableController } from 'sk/service/data/logic/module/controller/ConfigVariableController';
    export class ConfigRouter extends DatasetControllerRouter {
        protected _parameterController: ConfigParameterController;
        protected _variableController: ConfigVariableController;
        protected _formulaController: ConfigFormulaController;
        protected _decorateController: ConfigDecorateController;
        protected _decorateItemController: ConfigDecorateItemController;
        protected _configureController: ConfigConfigureController;
        protected _configureOptionController: ConfigConfigureOptionController;
        private loadConfigAsync;
        onGetSystemConfigureAsync(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onGetLibraryConfigureAsync(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onReloadSystemConfigureAsync(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/custom/FamilyStructureRouter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DatasetControllerContext } from 'foundation/service/common/router/database/DatasetControllerContext';
    import { DatasetControllerRouter } from 'foundation/service/common/router/database/DatasetControllerRouter';
    import { SpecificationFamilyCategory } from 'sk/data/specification/familycategory/structure/SpecificationFamilyCategory';
    import { SpecificationFamilyType } from 'sk/data/specification/familytype/structure/SpecificationFamilyType';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    export class FamilyStructureRouter extends DatasetControllerRouter {
        protected _familyController: FamilyController;
        protected _typeController: FamilyTypeController;
        protected _categoryController: FamilyCategoryController;
        protected _symbolController: FamilySymbolController;
        protected _familyInfoController: PublishFamilyInfoController;
        buildFamilyTypesAsync(context: DatasetControllerContext, typeId: string, types: Types<SpecificationFamilyType>): Promise<void>;
        buildFamilyCategoriesAsync(context: DatasetControllerContext, categoryId: string, categories: Types<SpecificationFamilyCategory>): Promise<void>;
        private buildSymbolsAsync;
        onGetFamilyDataStructureAsync(context: DatasetControllerContext, request: any, response: any): Promise<void>;
        onGetFamilyInfoStructureAsync(context: DatasetControllerContext, request: any, response: any): Promise<void>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/custom/RuleRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetControllerContext } from 'foundation/service/common/router/database/DatasetControllerContext';
    import { DatasetControllerRouter } from 'foundation/service/common/router/database/DatasetControllerRouter';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    import { RuleTypeController } from 'sk/service/data/logic/module/controller/RuleTypeController';
    export class RuleRouter extends DatasetControllerRouter {
        _ruleController: RuleController;
        _ruleTypeController: RuleTypeController;
        onGetRuleTypeAsync(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onGetRuleAsync(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onGetRuleTypeListAsync(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onGetRuleListAsync(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/custom/UploadFileRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { AsyncRouter } from 'foundation/service/common/router/AsyncRouter';
    export class UploadFileRouter extends AsyncRouter {
        protected _ossService: OssConnectionService;
        uploadToOssAsync(context: IContext, file: any): Promise<ResultObject>;
        uploadUnderlayToOssAsync(context: IContext, file: any): Promise<ResultObject>;
        onUploadTempFileAsync(request: any, response: any): Promise<void>;
        onUploadUnderlayFileAsync(request: any, response: any): Promise<void>;
        onUploadRenderAsync(request: any, response: any): Promise<void>;
        onDeleteRenderAsync(request: any, response: any): Promise<void>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/custom/WorkflowRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ProcessAsyncResult } from 'foundation/service/common/router/ProcessAsyncResult';
    import { ProcessAsyncRouter } from 'foundation/service/common/router/ProcessAsyncRouter';
    import { WorkflowController } from 'sk/service/data/logic/module/controller/WorkflowController';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class WorkflowRouter extends ProcessAsyncRouter {
        static workflowMap: {};
        _workflowController: WorkflowController;
        protected _storageService: ModuleStorageService;
        downloadWorkflowAsync(context: IContext, code: string, id: string, version: number): Promise<void>;
        refreshWorkflowAsync(): Promise<void>;
        onGetWorkflowAsync(context: IContext, request: any, response: any): Promise<ProcessAsyncResult>;
        private startRefreshWorkflow;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/FeatureGroupRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FeatureGroupListRequest } from 'sk/data/logic/module/message/FeatureGroupListRequest';
    import { FeatureGroupListResponse } from 'sk/data/logic/module/message/FeatureGroupListResponse';
    export class FeatureGroupRouter extends MessageRouter {
        processCode: string;
        onFeatureGroupListRequestAsync(context: MessageRouterContext, request: FeatureGroupListRequest, response: FeatureGroupListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/FeatureRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FeatureDeleteRequest } from 'sk/data/logic/module/message/FeatureDeleteRequest';
    import { FeatureDeleteResponse } from 'sk/data/logic/module/message/FeatureDeleteResponse';
    import { FeatureGetRequest } from 'sk/data/logic/module/message/FeatureGetRequest';
    import { FeatureGetResponse } from 'sk/data/logic/module/message/FeatureGetResponse';
    import { FeatureInsertRequest } from 'sk/data/logic/module/message/FeatureInsertRequest';
    import { FeatureInsertResponse } from 'sk/data/logic/module/message/FeatureInsertResponse';
    import { FeatureListRequest } from 'sk/data/logic/module/message/FeatureListRequest';
    import { FeatureListResponse } from 'sk/data/logic/module/message/FeatureListResponse';
    import { FeatureUpdateTypeRequest } from 'sk/data/logic/module/message/FeatureUpdateTypeRequest';
    import { FeatureUpdateTypeResponse } from 'sk/data/logic/module/message/FeatureUpdateTypeResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class FeatureRouter extends MessageRouter {
        processCode: string;
        protected _logicHistoryService: LogicHistoryService;
        onFeatureListRequestAsync(context: MessageRouterContext, request: FeatureListRequest, response: FeatureListResponse): Promise<MessageResultType>;
        onFeatureGetRequestAsync(context: MessageRouterContext, request: FeatureGetRequest, response: FeatureGetResponse): Promise<MessageResultType>;
        onFeatureInsertRequestAsync(context: MessageRouterContext, request: FeatureInsertRequest, response: FeatureInsertResponse): Promise<MessageResultType>;
        onFeatureUpdateTypeRequestAsync(context: MessageRouterContext, request: FeatureUpdateTypeRequest, response: FeatureUpdateTypeResponse): Promise<MessageResultType>;
        onFeatureDeleteRequestAsync(context: MessageRouterContext, request: FeatureDeleteRequest, response: FeatureDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleApparatusCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ApparatusCategoryDeleteRequest } from 'sk/data/logic/module/message/ApparatusCategoryDeleteRequest';
    import { ApparatusCategoryDeleteResponse } from 'sk/data/logic/module/message/ApparatusCategoryDeleteResponse';
    import { ApparatusCategoryGetRequest } from 'sk/data/logic/module/message/ApparatusCategoryGetRequest';
    import { ApparatusCategoryGetResponse } from 'sk/data/logic/module/message/ApparatusCategoryGetResponse';
    import { ApparatusCategoryInsertRequest } from 'sk/data/logic/module/message/ApparatusCategoryInsertRequest';
    import { ApparatusCategoryInsertResponse } from 'sk/data/logic/module/message/ApparatusCategoryInsertResponse';
    import { ApparatusCategoryPageRequest } from 'sk/data/logic/module/message/ApparatusCategoryPageRequest';
    import { ApparatusCategoryPageResponse } from 'sk/data/logic/module/message/ApparatusCategoryPageResponse';
    import { ApparatusCategorySearchRequest } from 'sk/data/logic/module/message/ApparatusCategorySearchRequest';
    import { ApparatusCategorySearchResponse } from 'sk/data/logic/module/message/ApparatusCategorySearchResponse';
    import { ApparatusCategorySortRequest } from 'sk/data/logic/module/message/ApparatusCategorySortRequest';
    import { ApparatusCategorySortResponse } from 'sk/data/logic/module/message/ApparatusCategorySortResponse';
    import { ApparatusCategoryTreeRequest } from 'sk/data/logic/module/message/ApparatusCategoryTreeRequest';
    import { ApparatusCategoryTreeResponse } from 'sk/data/logic/module/message/ApparatusCategoryTreeResponse';
    import { ApparatusCategoryUpdateRequest } from 'sk/data/logic/module/message/ApparatusCategoryUpdateRequest';
    import { ApparatusCategoryUpdateResponse } from 'sk/data/logic/module/message/ApparatusCategoryUpdateResponse';
    import { ApparatusCategoryController } from 'sk/service/data/logic/module/controller/ApparatusCategoryController';
    import { ApparatusController } from 'sk/service/data/logic/module/controller/ApparatusController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleApparatusCategoryRouter extends MessageRouter {
        processCode: string;
        protected _apparatusCategoryController: ApparatusCategoryController;
        protected _apparatusController: ApparatusController;
        protected _logicHistoryService: LogicHistoryService;
        private buildCategoryTreeResponseItemsVo;
        private loopBuildCategoryTreeResponseItemsVo;
        private makeCategoryTreeResponseData;
        private makeFamilyPageResponseDataAsync;
        onApparatusCategoryInsertRequestAsync(context: MessageRouterContext, request: ApparatusCategoryInsertRequest, response: ApparatusCategoryInsertResponse): Promise<MessageResultType>;
        onApparatusCategoryUpdateRequestAsync(context: MessageRouterContext, request: ApparatusCategoryUpdateRequest, response: ApparatusCategoryUpdateResponse): Promise<MessageResultType>;
        onApparatusCategorySortRequestAsync(context: MessageRouterContext, request: ApparatusCategorySortRequest, response: ApparatusCategorySortResponse): Promise<MessageResultType>;
        onApparatusCategoryPageRequestAsync(context: MessageRouterContext, request: ApparatusCategoryPageRequest, response: ApparatusCategoryPageResponse): Promise<MessageResultType>;
        onApparatusCategoryGetRequestAsync(context: MessageRouterContext, request: ApparatusCategoryGetRequest, response: ApparatusCategoryGetResponse): Promise<MessageResultType>;
        onApparatusCategoryTreeRequestAsync(context: MessageRouterContext, request: ApparatusCategoryTreeRequest, response: ApparatusCategoryTreeResponse): Promise<MessageResultType>;
        onApparatusCategoryDeleteRequestAsync(context: MessageRouterContext, request: ApparatusCategoryDeleteRequest, response: ApparatusCategoryDeleteResponse): Promise<MessageResultType>;
        onApparatusCategorySearchRequestAsync(context: MessageRouterContext, request: ApparatusCategorySearchRequest, response: ApparatusCategorySearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleApparatusRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ApparatusDocumentService } from 'sk/data/family/apparatus/ApparatusDocumentService';
    import { ApparatusDeleteRequest } from 'sk/data/logic/module/message/ApparatusDeleteRequest';
    import { ApparatusDeleteResponse } from 'sk/data/logic/module/message/ApparatusDeleteResponse';
    import { ApparatusGetRequest } from 'sk/data/logic/module/message/ApparatusGetRequest';
    import { ApparatusGetResponse } from 'sk/data/logic/module/message/ApparatusGetResponse';
    import { ApparatusInsertRequest } from 'sk/data/logic/module/message/ApparatusInsertRequest';
    import { ApparatusInsertResponse } from 'sk/data/logic/module/message/ApparatusInsertResponse';
    import { ApparatusPageRequest } from 'sk/data/logic/module/message/ApparatusPageRequest';
    import { ApparatusPageResponse } from 'sk/data/logic/module/message/ApparatusPageResponse';
    import { ApparatusPasteRequest } from 'sk/data/logic/module/message/ApparatusPasteRequest';
    import { ApparatusPasteResponse } from 'sk/data/logic/module/message/ApparatusPasteResponse';
    import { ApparatusSearchRequest } from 'sk/data/logic/module/message/ApparatusSearchRequest';
    import { ApparatusSearchResponse } from 'sk/data/logic/module/message/ApparatusSearchResponse';
    import { ApparatusUpdateRequest } from 'sk/data/logic/module/message/ApparatusUpdateRequest';
    import { ApparatusUpdateResponse } from 'sk/data/logic/module/message/ApparatusUpdateResponse';
    import { ApparatusCategoryController } from 'sk/service/data/logic/module/controller/ApparatusCategoryController';
    import { ApparatusController } from 'sk/service/data/logic/module/controller/ApparatusController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleApparatusRouter extends MessageRouter {
        processCode: string;
        protected _apparatusController: ApparatusController;
        protected _apparatusCategoryController: ApparatusCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _storageService: ModuleStorageService;
        protected _apparatusDocumentService: ApparatusDocumentService;
        protected _logicRelationService: LogicRelationService;
        private createApparatusDocumentAsync;
        private getApparatusDocumentAsync;
        private getOrCreateApparatusDocumentAsync;
        private getElementByApparatusUnitAsync;
        private updateApparatusDocumentData;
        private updateApparatusDocmentDataAsync;
        private makeApparatusPageResponseDataAsync;
        onApparatusPageRequestAsync(context: MessageRouterContext, request: ApparatusPageRequest, response: ApparatusPageResponse): Promise<MessageResultType>;
        onApparatusGetRequestAsync(context: MessageRouterContext, request: ApparatusGetRequest, response: ApparatusGetResponse): Promise<MessageResultType>;
        onApparatusSearchRequestAsync(context: MessageRouterContext, request: ApparatusSearchRequest, response: ApparatusSearchResponse): Promise<MessageResultType>;
        onApparatusInsertRequestAsync(context: MessageRouterContext, request: ApparatusInsertRequest, response: ApparatusInsertResponse): Promise<MessageResultType>;
        onApparatusPasteRequestAsync(context: MessageRouterContext, request: ApparatusPasteRequest, response: ApparatusPasteResponse): Promise<MessageResultType>;
        onApparatusUpdateRequestAsync(context: MessageRouterContext, request: ApparatusUpdateRequest, response: ApparatusUpdateResponse): Promise<MessageResultType>;
        onApparatusDeleteRequestAsync(context: MessageRouterContext, request: ApparatusDeleteRequest, response: ApparatusDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleApparatusTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ApparatusTypeSearchRequest } from 'sk/data/logic/module/message/ApparatusTypeSearchRequest';
    import { ApparatusTypeSearchResponse } from 'sk/data/logic/module/message/ApparatusTypeSearchResponse';
    import { ApparatusTypeController } from 'sk/service/data/logic/module/controller/ApparatusTypeController';
    export class ModuleApparatusTypeRouter extends MessageRouter {
        processCode: string;
        protected _apparatusTypeController: ApparatusTypeController;
        onApparatusTypeSearchRequestAsync(context: MessageRouterContext, request: ApparatusTypeSearchRequest, response: ApparatusTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleBusinessTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { BusinessTypeListRequest } from 'sk/data/logic/module/message/BusinessTypeListRequest';
    import { BusinessTypeListResponse } from 'sk/data/logic/module/message/BusinessTypeListResponse';
    import { BusinessTypeSearchRequest } from 'sk/data/logic/module/message/BusinessTypeSearchRequest';
    import { BusinessTypeSearchResponse } from 'sk/data/logic/module/message/BusinessTypeSearchResponse';
    import { BusinessTypeController } from 'sk/service/data/logic/module/controller/BusinessTypeController';
    export class ModuleBusinessTypeRouter extends MessageRouter {
        processCode: string;
        protected _businessTypeController: BusinessTypeController;
        onBusinessTypeListRequestAsync(context: MessageRouterContext, request: BusinessTypeListRequest, response: BusinessTypeListResponse): Promise<MessageResultType>;
        onBusinessTypeSearchRequestAsync(context: MessageRouterContext, request: BusinessTypeSearchRequest, response: BusinessTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigCategoryDeleteRequest } from 'sk/data/logic/module/message/ConfigCategoryDeleteRequest';
    import { ConfigCategoryDeleteResponse } from 'sk/data/logic/module/message/ConfigCategoryDeleteResponse';
    import { ConfigCategoryGetRequest } from 'sk/data/logic/module/message/ConfigCategoryGetRequest';
    import { ConfigCategoryGetResponse } from 'sk/data/logic/module/message/ConfigCategoryGetResponse';
    import { ConfigCategoryInsertRequest } from 'sk/data/logic/module/message/ConfigCategoryInsertRequest';
    import { ConfigCategoryInsertResponse } from 'sk/data/logic/module/message/ConfigCategoryInsertResponse';
    import { ConfigCategorySearchRequest } from 'sk/data/logic/module/message/ConfigCategorySearchRequest';
    import { ConfigCategorySearchResponse } from 'sk/data/logic/module/message/ConfigCategorySearchResponse';
    import { ConfigCategorySortRequest } from 'sk/data/logic/module/message/ConfigCategorySortRequest';
    import { ConfigCategorySortResponse } from 'sk/data/logic/module/message/ConfigCategorySortResponse';
    import { ConfigCategoryTreeRequest } from 'sk/data/logic/module/message/ConfigCategoryTreeRequest';
    import { ConfigCategoryTreeResponse } from 'sk/data/logic/module/message/ConfigCategoryTreeResponse';
    import { ConfigCategoryUpdateRequest } from 'sk/data/logic/module/message/ConfigCategoryUpdateRequest';
    import { ConfigCategoryUpdateResponse } from 'sk/data/logic/module/message/ConfigCategoryUpdateResponse';
    import { ConfigCategoryController } from 'sk/service/data/logic/module/controller/ConfigCategoryController';
    import { ConfigController } from 'sk/service/data/logic/module/controller/ConfigController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleConfigCategoryRouter extends MessageRouter {
        processCode: string;
        protected _configCategoryController: ConfigCategoryController;
        protected _configController: ConfigController;
        protected _logicHistoryService: LogicHistoryService;
        private makeCategoryTreeResponseData;
        private makeChildrenCategoryTreeResponseData;
        private mergePath;
        private getChildCategoryTreeByChildId;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        onConfigCategoryGetRequestAsync(context: MessageRouterContext, request: ConfigCategoryGetRequest, response: ConfigCategoryGetResponse): Promise<MessageResultType>;
        onConfigCategoryInsertRequestAsync(context: MessageRouterContext, request: ConfigCategoryInsertRequest, response: ConfigCategoryInsertResponse): Promise<MessageResultType>;
        onConfigCategorySortRequestAsync(context: MessageRouterContext, request: ConfigCategorySortRequest, response: ConfigCategorySortResponse): Promise<MessageResultType>;
        onConfigCategoryUpdateRequestAsync(context: MessageRouterContext, request: ConfigCategoryUpdateRequest, response: ConfigCategoryUpdateResponse): Promise<MessageResultType>;
        onConfigCategoryTreeRequestAsync(context: MessageRouterContext, request: ConfigCategoryTreeRequest, response: ConfigCategoryTreeResponse): Promise<MessageResultType>;
        onConfigCategoryDeleteRequestAsync(context: MessageRouterContext, request: ConfigCategoryDeleteRequest, response: ConfigCategoryDeleteResponse): Promise<MessageResultType>;
        onConfigCategorySearchRequestAsync(context: MessageRouterContext, request: ConfigCategorySearchRequest, response: ConfigCategorySearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigConfigureOptionRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigConfigureOptionDeleteRequest } from 'sk/data/logic/module/message/ConfigConfigureOptionDeleteRequest';
    import { ConfigConfigureOptionDeleteResponse } from 'sk/data/logic/module/message/ConfigConfigureOptionDeleteResponse';
    import { ConfigConfigureOptionGetRequest } from 'sk/data/logic/module/message/ConfigConfigureOptionGetRequest';
    import { ConfigConfigureOptionGetResponse } from 'sk/data/logic/module/message/ConfigConfigureOptionGetResponse';
    import { ConfigConfigureOptionInsertRequest } from 'sk/data/logic/module/message/ConfigConfigureOptionInsertRequest';
    import { ConfigConfigureOptionInsertResponse } from 'sk/data/logic/module/message/ConfigConfigureOptionInsertResponse';
    import { ConfigConfigureOptionPageRequest } from 'sk/data/logic/module/message/ConfigConfigureOptionPageRequest';
    import { ConfigConfigureOptionPageResponse } from 'sk/data/logic/module/message/ConfigConfigureOptionPageResponse';
    import { ConfigConfigureOptionUpdateRequest } from 'sk/data/logic/module/message/ConfigConfigureOptionUpdateRequest';
    import { ConfigConfigureOptionUpdateResponse } from 'sk/data/logic/module/message/ConfigConfigureOptionUpdateResponse';
    import { ConfigConfigureOptionController } from 'sk/service/data/logic/module/controller/ConfigConfigureOptionController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    export class ModuleConfigConfigureOptionRouter extends MessageRouter {
        processCode: string;
        protected _configConfigureOptionController: ConfigConfigureOptionController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        private makeConfigureOptionPageResponseDataAsync;
        onConfigConfigureOptionGetRequestAsync(context: MessageRouterContext, request: ConfigConfigureOptionGetRequest, response: ConfigConfigureOptionGetResponse): Promise<MessageResultType>;
        onConfigConfigureOptionInsertRequestAsync(context: MessageRouterContext, request: ConfigConfigureOptionInsertRequest, response: ConfigConfigureOptionInsertResponse): Promise<MessageResultType>;
        onConfigConfigureOptionUpdateRequestAsync(context: MessageRouterContext, request: ConfigConfigureOptionUpdateRequest, response: ConfigConfigureOptionUpdateResponse): Promise<MessageResultType>;
        onConfigConfigureOptionPageRequestAsync(context: MessageRouterContext, request: ConfigConfigureOptionPageRequest, response: ConfigConfigureOptionPageResponse): Promise<MessageResultType>;
        onConfigConfigureOptionDeleteRequestAsync(context: MessageRouterContext, request: ConfigConfigureOptionDeleteRequest, response: ConfigConfigureOptionDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigConfigureRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigConfigureChangeRequest } from 'sk/data/logic/module/message/ConfigConfigureChangeRequest';
    import { ConfigConfigureChangeResponse } from 'sk/data/logic/module/message/ConfigConfigureChangeResponse';
    import { ConfigConfigureDeleteRequest } from 'sk/data/logic/module/message/ConfigConfigureDeleteRequest';
    import { ConfigConfigureDeleteResponse } from 'sk/data/logic/module/message/ConfigConfigureDeleteResponse';
    import { ConfigConfigureGetRequest } from 'sk/data/logic/module/message/ConfigConfigureGetRequest';
    import { ConfigConfigureGetResponse } from 'sk/data/logic/module/message/ConfigConfigureGetResponse';
    import { ConfigConfigureInsertRequest } from 'sk/data/logic/module/message/ConfigConfigureInsertRequest';
    import { ConfigConfigureInsertResponse } from 'sk/data/logic/module/message/ConfigConfigureInsertResponse';
    import { ConfigConfigurePageRequest } from 'sk/data/logic/module/message/ConfigConfigurePageRequest';
    import { ConfigConfigurePageResponse } from 'sk/data/logic/module/message/ConfigConfigurePageResponse';
    import { ConfigConfigurePasteRequest } from 'sk/data/logic/module/message/ConfigConfigurePasteRequest';
    import { ConfigConfigurePasteResponse } from 'sk/data/logic/module/message/ConfigConfigurePasteResponse';
    import { ConfigConfigureUpdateRequest } from 'sk/data/logic/module/message/ConfigConfigureUpdateRequest';
    import { ConfigConfigureUpdateResponse } from 'sk/data/logic/module/message/ConfigConfigureUpdateResponse';
    import { ConfigCategoryController } from 'sk/service/data/logic/module/controller/ConfigCategoryController';
    import { ConfigConfigureController } from 'sk/service/data/logic/module/controller/ConfigConfigureController';
    import { ConfigConfigureOptionController } from 'sk/service/data/logic/module/controller/ConfigConfigureOptionController';
    import { ConfigController } from 'sk/service/data/logic/module/controller/ConfigController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleConfigConfigureRouter extends MessageRouter {
        processCode: string;
        protected _configConfigureController: ConfigConfigureController;
        protected _configConfigureOptionController: ConfigConfigureOptionController;
        protected _configCategoryController: ConfigCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _configController: ConfigController;
        private buildConfigureOptionsDataAsync;
        private buildCategoryNamesAsync;
        private makeConfigurePageResponseDataAsync;
        checkCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<string>;
        judgeCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<boolean>;
        onConfigConfigureChangeRequestAsync(context: MessageRouterContext, request: ConfigConfigureChangeRequest, response: ConfigConfigureChangeResponse): Promise<MessageResultType>;
        onConfigConfigureGetRequestAsync(context: MessageRouterContext, request: ConfigConfigureGetRequest, response: ConfigConfigureGetResponse): Promise<MessageResultType>;
        onConfigConfigureInsertRequestAsync(context: MessageRouterContext, request: ConfigConfigureInsertRequest, response: ConfigConfigureInsertResponse): Promise<MessageResultType>;
        onConfigConfigureUpdateRequestAsync(context: MessageRouterContext, request: ConfigConfigureUpdateRequest, response: ConfigConfigureUpdateResponse): Promise<MessageResultType>;
        onConfigConfigurePageRequestAsync(context: MessageRouterContext, request: ConfigConfigurePageRequest, response: ConfigConfigurePageResponse): Promise<MessageResultType>;
        onConfigConfigureDeleteRequestAsync(context: MessageRouterContext, request: ConfigConfigureDeleteRequest, response: ConfigConfigureDeleteResponse): Promise<MessageResultType>;
        onConfigConfigurePasteRequestAsync(context: MessageRouterContext, request: ConfigConfigurePasteRequest, response: ConfigConfigurePasteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigDecorateItemRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigDecorateItemDeleteRequest } from 'sk/data/logic/module/message/ConfigDecorateItemDeleteRequest';
    import { ConfigDecorateItemDeleteResponse } from 'sk/data/logic/module/message/ConfigDecorateItemDeleteResponse';
    import { ConfigDecorateItemGetRequest } from 'sk/data/logic/module/message/ConfigDecorateItemGetRequest';
    import { ConfigDecorateItemGetResponse } from 'sk/data/logic/module/message/ConfigDecorateItemGetResponse';
    import { ConfigDecorateItemInsertRequest } from 'sk/data/logic/module/message/ConfigDecorateItemInsertRequest';
    import { ConfigDecorateItemInsertResponse } from 'sk/data/logic/module/message/ConfigDecorateItemInsertResponse';
    import { ConfigDecorateItemListRequest } from 'sk/data/logic/module/message/ConfigDecorateItemListRequest';
    import { ConfigDecorateItemListResponse } from 'sk/data/logic/module/message/ConfigDecorateItemListResponse';
    import { ConfigDecorateItemPageRequest } from 'sk/data/logic/module/message/ConfigDecorateItemPageRequest';
    import { ConfigDecorateItemPageResponse } from 'sk/data/logic/module/message/ConfigDecorateItemPageResponse';
    import { ConfigDecorateItemSearchRequest } from 'sk/data/logic/module/message/ConfigDecorateItemSearchRequest';
    import { ConfigDecorateItemSearchResponse } from 'sk/data/logic/module/message/ConfigDecorateItemSearchResponse';
    import { ConfigDecorateItemSyncRequest } from 'sk/data/logic/module/message/ConfigDecorateItemSyncRequest';
    import { ConfigDecorateItemSyncResponse } from 'sk/data/logic/module/message/ConfigDecorateItemSyncResponse';
    import { ConfigDecorateItemUpdateRequest } from 'sk/data/logic/module/message/ConfigDecorateItemUpdateRequest';
    import { ConfigDecorateItemUpdateResponse } from 'sk/data/logic/module/message/ConfigDecorateItemUpdateResponse';
    import { ProductShowPerspectiveController } from 'sk/service/data/logic/digitization/controller/ProductShowPerspectiveController';
    import { ConfigDecorateController } from 'sk/service/data/logic/module/controller/ConfigDecorateController';
    import { ConfigDecorateItemController } from 'sk/service/data/logic/module/controller/ConfigDecorateItemController';
    import { ConfigDecorateItemDto } from 'sk/service/data/logic/module/controller/ConfigDecorateItemDto';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    export class ModuleConfigDecorateItemRouter extends MessageRouter {
        processCode: string;
        protected _configDecorateItemController: ConfigDecorateItemController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        protected _configDecorateController: ConfigDecorateController;
        protected _familyController: FamilyController;
        protected _productShowPerspectiveController: ProductShowPerspectiveController;
        private makeDecorateItemPageResponseDataAsync;
        updateRelationAsync(context: MessageRouterContext, configDecorateItemDto: ConfigDecorateItemDto): Promise<ResultObject>;
        onConfigDecorateItemGetRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemGetRequest, response: ConfigDecorateItemGetResponse): Promise<MessageResultType>;
        onConfigDecorateItemInsertRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemInsertRequest, response: ConfigDecorateItemInsertResponse): Promise<MessageResultType>;
        onConfigDecorateItemSyncRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemSyncRequest, response: ConfigDecorateItemSyncResponse): Promise<MessageResultType>;
        onConfigDecorateItemUpdateRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemUpdateRequest, response: ConfigDecorateItemUpdateResponse): Promise<MessageResultType>;
        onConfigDecorateItemPageRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemPageRequest, response: ConfigDecorateItemPageResponse): Promise<MessageResultType>;
        onConfigDecorateItemDeleteRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemDeleteRequest, response: ConfigDecorateItemDeleteResponse): Promise<MessageResultType>;
        onConfigDecorateItemListRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemListRequest, response: ConfigDecorateItemListResponse): Promise<MessageResultType>;
        onConfigDecorateItemSearchRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemSearchRequest, response: ConfigDecorateItemSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigDecorateRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigDecorateChangeRequest } from 'sk/data/logic/module/message/ConfigDecorateChangeRequest';
    import { ConfigDecorateChangeResponse } from 'sk/data/logic/module/message/ConfigDecorateChangeResponse';
    import { ConfigDecorateCombinedTreeRequest } from 'sk/data/logic/module/message/ConfigDecorateCombinedTreeRequest';
    import { ConfigDecorateCombinedTreeResponse } from 'sk/data/logic/module/message/ConfigDecorateCombinedTreeResponse';
    import { ConfigDecorateDeleteRequest } from 'sk/data/logic/module/message/ConfigDecorateDeleteRequest';
    import { ConfigDecorateDeleteResponse } from 'sk/data/logic/module/message/ConfigDecorateDeleteResponse';
    import { ConfigDecorateGetCategorysRequest } from 'sk/data/logic/module/message/ConfigDecorateGetCategorysRequest';
    import { ConfigDecorateGetCategorysResponse } from 'sk/data/logic/module/message/ConfigDecorateGetCategorysResponse';
    import { ConfigDecorateGetRequest } from 'sk/data/logic/module/message/ConfigDecorateGetRequest';
    import { ConfigDecorateGetResponse } from 'sk/data/logic/module/message/ConfigDecorateGetResponse';
    import { ConfigDecorateInsertRequest } from 'sk/data/logic/module/message/ConfigDecorateInsertRequest';
    import { ConfigDecorateInsertResponse } from 'sk/data/logic/module/message/ConfigDecorateInsertResponse';
    import { ConfigDecorateMoveRequest } from 'sk/data/logic/module/message/ConfigDecorateMoveRequest';
    import { ConfigDecorateMoveResponse } from 'sk/data/logic/module/message/ConfigDecorateMoveResponse';
    import { ConfigDecoratePageRequest } from 'sk/data/logic/module/message/ConfigDecoratePageRequest';
    import { ConfigDecoratePageResponse } from 'sk/data/logic/module/message/ConfigDecoratePageResponse';
    import { ConfigDecoratePasteRequest } from 'sk/data/logic/module/message/ConfigDecoratePasteRequest';
    import { ConfigDecoratePasteResponse } from 'sk/data/logic/module/message/ConfigDecoratePasteResponse';
    import { ConfigDecorateSearchRequest } from 'sk/data/logic/module/message/ConfigDecorateSearchRequest';
    import { ConfigDecorateSearchResponse } from 'sk/data/logic/module/message/ConfigDecorateSearchResponse';
    import { ConfigDecorateUpdateRequest } from 'sk/data/logic/module/message/ConfigDecorateUpdateRequest';
    import { ConfigDecorateUpdateResponse } from 'sk/data/logic/module/message/ConfigDecorateUpdateResponse';
    import { ConfigCategoryController } from 'sk/service/data/logic/module/controller/ConfigCategoryController';
    import { ConfigDecorateController } from 'sk/service/data/logic/module/controller/ConfigDecorateController';
    import { ConfigDecorateItemController } from 'sk/service/data/logic/module/controller/ConfigDecorateItemController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    export class ModuleConfigDecorateRouter extends MessageRouter {
        processCode: string;
        protected _configDecorateController: ConfigDecorateController;
        protected _configCategoryController: ConfigCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        protected _configDecorateItemController: ConfigDecorateItemController;
        private buildCategoryNamesAsync;
        checkCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<string>;
        judgeCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<boolean>;
        private makeDecoratePageResponseDataAsync;
        private makeCategoryTreeResponseDataAsync;
        private loopMakeCategoryTreeResponseItemsVoAsync;
        private buildCategoryTreeResponseItemsVo;
        private queryDataByCategoryAsync;
        onConfigDecorateChangeRequestAsync(context: MessageRouterContext, request: ConfigDecorateChangeRequest, response: ConfigDecorateChangeResponse): Promise<MessageResultType>;
        onConfigDecorateGetRequestAsync(context: MessageRouterContext, request: ConfigDecorateGetRequest, response: ConfigDecorateGetResponse): Promise<MessageResultType>;
        onConfigDecorateGetCategorysRequestAsync(context: MessageRouterContext, request: ConfigDecorateGetCategorysRequest, response: ConfigDecorateGetCategorysResponse): Promise<MessageResultType>;
        onConfigDecorateInsertRequestAsync(context: MessageRouterContext, request: ConfigDecorateInsertRequest, response: ConfigDecorateInsertResponse): Promise<MessageResultType>;
        onConfigDecorateUpdateRequestAsync(context: MessageRouterContext, request: ConfigDecorateUpdateRequest, response: ConfigDecorateUpdateResponse): Promise<MessageResultType>;
        onConfigDecorateCombinedTreeRequestAsync(context: MessageRouterContext, request: ConfigDecorateCombinedTreeRequest, response: ConfigDecorateCombinedTreeResponse): Promise<MessageResultType>;
        onConfigDecoratePageRequestAsync(context: MessageRouterContext, request: ConfigDecoratePageRequest, response: ConfigDecoratePageResponse): Promise<MessageResultType>;
        onConfigDecorateDeleteRequestAsync(context: MessageRouterContext, request: ConfigDecorateDeleteRequest, response: ConfigDecorateDeleteResponse): Promise<MessageResultType>;
        onConfigDecorateMoveRequestAsync(context: MessageRouterContext, request: ConfigDecorateMoveRequest, response: ConfigDecorateMoveResponse): Promise<MessageResultType>;
        onConfigDecorateSearchRequestAsync(context: MessageRouterContext, request: ConfigDecorateSearchRequest, response: ConfigDecorateSearchResponse): Promise<MessageResultType>;
        onConfigDecoratePasteRequestAsync(context: MessageRouterContext, request: ConfigDecoratePasteRequest, response: ConfigDecoratePasteResponse): Promise<MessageResultType>;
        private addDataPathAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigPaletteColorRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigPaletteColorChangeRequest } from 'sk/data/logic/module/message/ConfigPaletteColorChangeRequest';
    import { ConfigPaletteColorChangeResponse } from 'sk/data/logic/module/message/ConfigPaletteColorChangeResponse';
    import { ConfigPaletteColorDeleteRequest } from 'sk/data/logic/module/message/ConfigPaletteColorDeleteRequest';
    import { ConfigPaletteColorDeleteResponse } from 'sk/data/logic/module/message/ConfigPaletteColorDeleteResponse';
    import { ConfigPaletteColorGetRequest } from 'sk/data/logic/module/message/ConfigPaletteColorGetRequest';
    import { ConfigPaletteColorGetResponse } from 'sk/data/logic/module/message/ConfigPaletteColorGetResponse';
    import { ConfigPaletteColorInsertRequest } from 'sk/data/logic/module/message/ConfigPaletteColorInsertRequest';
    import { ConfigPaletteColorInsertResponse } from 'sk/data/logic/module/message/ConfigPaletteColorInsertResponse';
    import { ConfigPaletteColorPageRequest } from 'sk/data/logic/module/message/ConfigPaletteColorPageRequest';
    import { ConfigPaletteColorPageResponse } from 'sk/data/logic/module/message/ConfigPaletteColorPageResponse';
    import { ConfigPaletteColorPasteRequest } from 'sk/data/logic/module/message/ConfigPaletteColorPasteRequest';
    import { ConfigPaletteColorPasteResponse } from 'sk/data/logic/module/message/ConfigPaletteColorPasteResponse';
    import { ConfigPaletteColorUpdateRequest } from 'sk/data/logic/module/message/ConfigPaletteColorUpdateRequest';
    import { ConfigPaletteColorUpdateResponse } from 'sk/data/logic/module/message/ConfigPaletteColorUpdateResponse';
    import { ConfigCategoryController } from 'sk/service/data/logic/module/controller/ConfigCategoryController';
    import { ConfigController } from 'sk/service/data/logic/module/controller/ConfigController';
    import { ConfigPaletteColorController } from 'sk/service/data/logic/module/controller/ConfigPaletteColorController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleConfigPaletteColorRouter extends MessageRouter {
        processCode: string;
        protected _ConfigPaletteColorController: ConfigPaletteColorController;
        protected _configCategoryController: ConfigCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _configController: ConfigController;
        private buildConfigureOptionsDataAsync;
        private buildCategoryNamesAsync;
        private makeConfigurePageResponseDataAsync;
        checkCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<string>;
        judgeCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<boolean>;
        onConfigPaletteColorChangeRequestAsync(context: MessageRouterContext, request: ConfigPaletteColorChangeRequest, response: ConfigPaletteColorChangeResponse): Promise<MessageResultType>;
        onConfigPaletteColorGetRequestAsync(context: MessageRouterContext, request: ConfigPaletteColorGetRequest, response: ConfigPaletteColorGetResponse): Promise<MessageResultType>;
        onConfigPaletteColorInsertRequestAsync(context: MessageRouterContext, request: ConfigPaletteColorInsertRequest, response: ConfigPaletteColorInsertResponse): Promise<MessageResultType>;
        onConfigPaletteColorUpdateRequestAsync(context: MessageRouterContext, request: ConfigPaletteColorUpdateRequest, response: ConfigPaletteColorUpdateResponse): Promise<MessageResultType>;
        onConfigPaletteColorPageRequestAsync(context: MessageRouterContext, request: ConfigPaletteColorPageRequest, response: ConfigPaletteColorPageResponse): Promise<MessageResultType>;
        onConfigPaletteColorDeleteRequestAsync(context: MessageRouterContext, request: ConfigPaletteColorDeleteRequest, response: ConfigPaletteColorDeleteResponse): Promise<MessageResultType>;
        onConfigPaletteColorPasteRequestAsync(context: MessageRouterContext, request: ConfigPaletteColorPasteRequest, response: ConfigPaletteColorPasteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigPaletteRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigPaletteChangeRequest } from 'sk/data/logic/module/message/ConfigPaletteChangeRequest';
    import { ConfigPaletteChangeResponse } from 'sk/data/logic/module/message/ConfigPaletteChangeResponse';
    import { ConfigPaletteDeleteRequest } from 'sk/data/logic/module/message/ConfigPaletteDeleteRequest';
    import { ConfigPaletteDeleteResponse } from 'sk/data/logic/module/message/ConfigPaletteDeleteResponse';
    import { ConfigPaletteGetRequest } from 'sk/data/logic/module/message/ConfigPaletteGetRequest';
    import { ConfigPaletteGetResponse } from 'sk/data/logic/module/message/ConfigPaletteGetResponse';
    import { ConfigPaletteInsertRequest } from 'sk/data/logic/module/message/ConfigPaletteInsertRequest';
    import { ConfigPaletteInsertResponse } from 'sk/data/logic/module/message/ConfigPaletteInsertResponse';
    import { ConfigPalettePageRequest } from 'sk/data/logic/module/message/ConfigPalettePageRequest';
    import { ConfigPalettePageResponse } from 'sk/data/logic/module/message/ConfigPalettePageResponse';
    import { ConfigPalettePasteRequest } from 'sk/data/logic/module/message/ConfigPalettePasteRequest';
    import { ConfigPalettePasteResponse } from 'sk/data/logic/module/message/ConfigPalettePasteResponse';
    import { ConfigPaletteUpdateRequest } from 'sk/data/logic/module/message/ConfigPaletteUpdateRequest';
    import { ConfigPaletteUpdateResponse } from 'sk/data/logic/module/message/ConfigPaletteUpdateResponse';
    import { ConfigCategoryController } from 'sk/service/data/logic/module/controller/ConfigCategoryController';
    import { ConfigController } from 'sk/service/data/logic/module/controller/ConfigController';
    import { ConfigPaletteController } from 'sk/service/data/logic/module/controller/ConfigPaletteController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleConfigPaletteRouter extends MessageRouter {
        processCode: string;
        protected _configPaletteController: ConfigPaletteController;
        protected _configCategoryController: ConfigCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _moduleStorageService: ModuleStorageService;
        protected _configController: ConfigController;
        private buildConfigureOptionsDataAsync;
        private buildCategoryNamesAsync;
        private makeConfigurePageResponseDataAsync;
        checkCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<string>;
        judgeCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<boolean>;
        onConfigPaletteChangeRequestAsync(context: MessageRouterContext, request: ConfigPaletteChangeRequest, response: ConfigPaletteChangeResponse): Promise<MessageResultType>;
        onConfigPaletteGetRequestAsync(context: MessageRouterContext, request: ConfigPaletteGetRequest, response: ConfigPaletteGetResponse): Promise<MessageResultType>;
        onConfigPaletteInsertRequestAsync(context: MessageRouterContext, request: ConfigPaletteInsertRequest, response: ConfigPaletteInsertResponse): Promise<MessageResultType>;
        onConfigPaletteUpdateRequestAsync(context: MessageRouterContext, request: ConfigPaletteUpdateRequest, response: ConfigPaletteUpdateResponse): Promise<MessageResultType>;
        onConfigPalettePageRequestAsync(context: MessageRouterContext, request: ConfigPalettePageRequest, response: ConfigPalettePageResponse): Promise<MessageResultType>;
        onConfigPaletteDeleteRequestAsync(context: MessageRouterContext, request: ConfigPaletteDeleteRequest, response: ConfigPaletteDeleteResponse): Promise<MessageResultType>;
        onConfigPalettePasteRequestAsync(context: MessageRouterContext, request: ConfigPalettePasteRequest, response: ConfigPalettePasteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigTypeSearchRequest } from 'sk/data/logic/module/message/ConfigTypeSearchRequest';
    import { ConfigTypeSearchResponse } from 'sk/data/logic/module/message/ConfigTypeSearchResponse';
    import { ConfigTypeController } from 'sk/service/data/logic/module/controller/ConfigTypeController';
    export class ModuleConfigTypeRouter extends MessageRouter {
        processCode: string;
        protected _configTypeController: ConfigTypeController;
        onConfigTypeSearchRequestAsync(context: MessageRouterContext, request: ConfigTypeSearchRequest, response: ConfigTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleConfigVariableRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigVariableDocumentService } from 'sk/data/family/config/variable/ConfigVariableDocumentService';
    import { ConfigVariableDeleteRequest } from 'sk/data/logic/module/message/ConfigVariableDeleteRequest';
    import { ConfigVariableDeleteResponse } from 'sk/data/logic/module/message/ConfigVariableDeleteResponse';
    import { ConfigVariableGetRequest } from 'sk/data/logic/module/message/ConfigVariableGetRequest';
    import { ConfigVariableGetResponse } from 'sk/data/logic/module/message/ConfigVariableGetResponse';
    import { ConfigVariableInsertRequest } from 'sk/data/logic/module/message/ConfigVariableInsertRequest';
    import { ConfigVariableInsertResponse } from 'sk/data/logic/module/message/ConfigVariableInsertResponse';
    import { ConfigVariableListRequest } from 'sk/data/logic/module/message/ConfigVariableListRequest';
    import { ConfigVariableListResponse } from 'sk/data/logic/module/message/ConfigVariableListResponse';
    import { ConfigVariablePageRequest } from 'sk/data/logic/module/message/ConfigVariablePageRequest';
    import { ConfigVariablePageResponse } from 'sk/data/logic/module/message/ConfigVariablePageResponse';
    import { ConfigVariablePasteRequest } from 'sk/data/logic/module/message/ConfigVariablePasteRequest';
    import { ConfigVariablePasteResponse } from 'sk/data/logic/module/message/ConfigVariablePasteResponse';
    import { ConfigVariableUpdateRequest } from 'sk/data/logic/module/message/ConfigVariableUpdateRequest';
    import { ConfigVariableUpdateResponse } from 'sk/data/logic/module/message/ConfigVariableUpdateResponse';
    import { ConfigCategoryController } from 'sk/service/data/logic/module/controller/ConfigCategoryController';
    import { ConfigVariableController } from 'sk/service/data/logic/module/controller/ConfigVariableController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleConfigVariableRouter extends MessageRouter {
        processCode: string;
        protected _configVariableController: ConfigVariableController;
        protected _configCategoryController: ConfigCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        protected _moduleStorageService: ModuleStorageService;
        protected _configVarDocumentService: ConfigVariableDocumentService;
        private buildCategoryNamesAsync;
        private makeConfigVariablePageResponseDataAsync;
        private createVariableDocument;
        private updateConfigVariableDocmentDataAsync;
        judgeCodeAsync(context: MessageRouterContext, code: string): Promise<boolean>;
        checkCodeAsync(context: MessageRouterContext, code: string): Promise<string>;
        onConfigVariableListRequestAsync(context: MessageRouterContext, request: ConfigVariableListRequest, response: ConfigVariableListResponse): Promise<MessageResultType>;
        onConfigVariableGetRequestAsync(context: MessageRouterContext, request: ConfigVariableGetRequest, response: ConfigVariableGetResponse): Promise<MessageResultType>;
        onConfigVariableInsertRequestAsync(context: MessageRouterContext, request: ConfigVariableInsertRequest, response: ConfigVariableInsertResponse): Promise<MessageResultType>;
        onConfigVariableUpdateRequestAsync(context: MessageRouterContext, request: ConfigVariableUpdateRequest, response: ConfigVariableUpdateResponse): Promise<MessageResultType>;
        onConfigVariablePageRequestAsync(context: MessageRouterContext, request: ConfigVariablePageRequest, response: ConfigVariablePageResponse): Promise<MessageResultType>;
        onConfigVariableDeleteRequestAsync(context: MessageRouterContext, request: ConfigVariableDeleteRequest, response: ConfigVariableDeleteResponse): Promise<MessageResultType>;
        onConfigVariablePasteRequestAsync(context: MessageRouterContext, request: ConfigVariablePasteRequest, response: ConfigVariablePasteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleDrawingAtlasRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DrawingAtlasGetDrawingListRequest } from 'sk/data/logic/module/message/DrawingAtlasGetDrawingListRequest';
    import { DrawingAtlasGetDrawingListResponse } from 'sk/data/logic/module/message/DrawingAtlasGetDrawingListResponse';
    import { DrawingAtlasListRequest } from 'sk/data/logic/module/message/DrawingAtlasListRequest';
    import { DrawingAtlasListResponse } from 'sk/data/logic/module/message/DrawingAtlasListResponse';
    export class ModuleDrawingAtlasRouter extends MessageRouter {
        processCode: string;
        onDrawingAtlasListRequestAsync(context: MessageRouterContext, request: DrawingAtlasListRequest, response: DrawingAtlasListResponse): Promise<MessageResultType>;
        onDrawingAtlasGetDrawingListRequestAsync(context: MessageRouterContext, request: DrawingAtlasGetDrawingListRequest, response: DrawingAtlasGetDrawingListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleDrawingRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DrawingTemplateProcessUnit } from 'sk/data/scheme/drawing/template/info/DrawingTemplateProcessUnit';
    import { DrawingTree } from 'sk/data/scheme/drawing/data/DrawingNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDataDocument } from 'sk/data/scheme/model/SchemeDataDocument';
    import { SchemeTechnologyDataDocument } from 'sk/data/scheme/model/SchemeTechnologyDataDocument';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { SchemeTechnologyDocumentService } from 'sk/data/scheme/service/SchemeTechnologyDocumentService';
    import { DrawingConvertNodeRequest } from 'sk/data/logic/module/message/DrawingConvertNodeRequest';
    import { DrawingConvertNodeResponse } from 'sk/data/logic/module/message/DrawingConvertNodeResponse';
    import { DrawingConvertRequest } from 'sk/data/logic/module/message/DrawingConvertRequest';
    import { DrawingConvertResponse } from 'sk/data/logic/module/message/DrawingConvertResponse';
    import { DrawingConvertTreeRequest } from 'sk/data/logic/module/message/DrawingConvertTreeRequest';
    import { DrawingConvertTreeResponse } from 'sk/data/logic/module/message/DrawingConvertTreeResponse';
    import { DrawingGetCategoryTreeRequest } from 'sk/data/logic/module/message/DrawingGetCategoryTreeRequest';
    import { DrawingGetCategoryTreeResponse } from 'sk/data/logic/module/message/DrawingGetCategoryTreeResponse';
    import { DrawingGetContentRequest } from 'sk/data/logic/module/message/DrawingGetContentRequest';
    import { DrawingGetContentResponse } from 'sk/data/logic/module/message/DrawingGetContentResponse';
    import { DrawingListRequest } from 'sk/data/logic/module/message/DrawingListRequest';
    import { DrawingListResponse } from 'sk/data/logic/module/message/DrawingListResponse';
    import { DrawingUpdateContentRequest } from 'sk/data/logic/module/message/DrawingUpdateContentRequest';
    import { DrawingUpdateContentResponse } from 'sk/data/logic/module/message/DrawingUpdateContentResponse';
    import { DrawingCategoryController } from 'sk/service/data/logic/module/controller/DrawingCategoryController';
    import { DrawingController } from 'sk/service/data/logic/module/controller/DrawingController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    import { StorageService } from "sk/service/logic/digitization/service/StorageService";
    export class ModuleDrawingRouter extends MessageRouter {
        processCode: string;
        protected _moduleStorageService: ModuleStorageService;
        protected _storageService: StorageService;
        protected _drawingController: DrawingController;
        protected _drawingCategoryController: DrawingCategoryController;
        protected _schemeDocumentService: SchemeDocumentService;
        protected _schemeTechnologyDocumentService: SchemeTechnologyDocumentService;
        protected _schemeConfigService: SchemeConfigService;
        protected _logicHistoryService: LogicHistoryService;
        onDrawingListRequestAsync(context: MessageRouterContext, request: DrawingListRequest, response: DrawingListResponse): Promise<MessageResultType>;
        onDrawingGetCategoryTreeRequestAsync(context: MessageRouterContext, request: DrawingGetCategoryTreeRequest, response: DrawingGetCategoryTreeResponse): Promise<MessageResultType>;
        onDrawingGetContentRequestAsync(context: MessageRouterContext, request: DrawingGetContentRequest, response: DrawingGetContentResponse): Promise<MessageResultType>;
        onDrawingUpdateContentRequestAsync(context: MessageRouterContext, request: DrawingUpdateContentRequest, response: DrawingUpdateContentResponse): Promise<MessageResultType>;
        onDrawingConvertRequestAsync(context: MessageRouterContext, request: DrawingConvertRequest, response: DrawingConvertResponse): Promise<MessageResultType>;
        onDrawingConvertNodeRequestAsync(context: MessageRouterContext, request: DrawingConvertNodeRequest, response: DrawingConvertNodeResponse): Promise<MessageResultType>;
        onDrawingConvertTreeRequestAsync(context: MessageRouterContext, request: DrawingConvertTreeRequest, response: DrawingConvertTreeResponse): Promise<MessageResultType>;
        convertSubAsync(schemeDocument: SchemeDataDocument, drawingJson: any, templateUnit?: DrawingTemplateProcessUnit): Promise<any>;
        private getTemplateProcessInfoAsync;
        private getCategoryListAsync;
        computeDrawingAsync(context: MessageRouterContext, technologyDocument: SchemeTechnologyDataDocument): Promise<ResultObject<DrawingTree>>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyBomConfigRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyBomConfigGetRequest } from 'sk/data/logic/module/message/FamilyBomConfigGetRequest';
    import { FamilyBomConfigGetResponse } from 'sk/data/logic/module/message/FamilyBomConfigGetResponse';
    import { FamilyBomConfigListRequest } from 'sk/data/logic/module/message/FamilyBomConfigListRequest';
    import { FamilyBomConfigListResponse } from 'sk/data/logic/module/message/FamilyBomConfigListResponse';
    export class ModuleFamilyBomConfigRouter extends MessageRouter {
        processCode: string;
        onFamilyBomConfigGetRequestAsync(context: MessageRouterContext, request: FamilyBomConfigGetRequest, response: FamilyBomConfigGetResponse): Promise<MessageResultType>;
        onFamilyBomConfigListRequestAsync(context: MessageRouterContext, request: FamilyBomConfigListRequest, response: FamilyBomConfigListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/util/CategoryTreeDataTool" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    interface TreeItemDtoType extends InstanceObject {
        id: string;
        parentId: string;
    }
    export class CategoryTreeDataTool<V extends InstanceObject> {
        buildVoFunction: any;
        protected treeItemVoClazz: any;
        makeCategoryTreeResponseData(dataset: DatasetResult<TreeItemDtoType>, result: StructureTypes<V>, categoryIds: Array<string>, parentCategoryIds: Array<string>): void;
        private loopBuildCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyCategoryDeleteRequest } from 'sk/data/logic/module/message/FamilyCategoryDeleteRequest';
    import { FamilyCategoryDeleteResponse } from 'sk/data/logic/module/message/FamilyCategoryDeleteResponse';
    import { FamilyCategoryGetChildrenRequest } from 'sk/data/logic/module/message/FamilyCategoryGetChildrenRequest';
    import { FamilyCategoryGetChildrenResponse } from 'sk/data/logic/module/message/FamilyCategoryGetChildrenResponse';
    import { FamilyCategoryGetRequest } from 'sk/data/logic/module/message/FamilyCategoryGetRequest';
    import { FamilyCategoryGetResponse } from 'sk/data/logic/module/message/FamilyCategoryGetResponse';
    import { FamilyCategoryInsertRequest } from 'sk/data/logic/module/message/FamilyCategoryInsertRequest';
    import { FamilyCategoryInsertResponse } from 'sk/data/logic/module/message/FamilyCategoryInsertResponse';
    import { FamilyCategorySearchRequest } from 'sk/data/logic/module/message/FamilyCategorySearchRequest';
    import { FamilyCategorySearchResponse } from 'sk/data/logic/module/message/FamilyCategorySearchResponse';
    import { FamilyCategorySortRequest } from 'sk/data/logic/module/message/FamilyCategorySortRequest';
    import { FamilyCategorySortResponse } from 'sk/data/logic/module/message/FamilyCategorySortResponse';
    import { FamilyCategoryTreeRequest } from 'sk/data/logic/module/message/FamilyCategoryTreeRequest';
    import { FamilyCategoryTreeResponse } from 'sk/data/logic/module/message/FamilyCategoryTreeResponse';
    import { FamilyCategoryUpdateRequest } from 'sk/data/logic/module/message/FamilyCategoryUpdateRequest';
    import { FamilyCategoryUpdateResponse } from 'sk/data/logic/module/message/FamilyCategoryUpdateResponse';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleFamilyCategoryRouter extends MessageRouter {
        processCode: string;
        protected _familyCategoryController: FamilyCategoryController;
        protected _familyController: FamilyController;
        protected _logicHistoryService: LogicHistoryService;
        onFamilyCategoryInsertRequestAsync(context: MessageRouterContext, request: FamilyCategoryInsertRequest, response: FamilyCategoryInsertResponse): Promise<MessageResultType>;
        onFamilyCategoryUpdateRequestAsync(context: MessageRouterContext, request: FamilyCategoryUpdateRequest, response: FamilyCategoryUpdateResponse): Promise<MessageResultType>;
        onFamilyCategoryGetRequestAsync(context: MessageRouterContext, request: FamilyCategoryGetRequest, response: FamilyCategoryGetResponse): Promise<MessageResultType>;
        onFamilyCategorySortRequestAsync(context: MessageRouterContext, request: FamilyCategorySortRequest, response: FamilyCategorySortResponse): Promise<MessageResultType>;
        onFamilyCategoryTreeRequestAsync(context: MessageRouterContext, request: FamilyCategoryTreeRequest, response: FamilyCategoryTreeResponse): Promise<MessageResultType>;
        onFamilyCategoryGetChildrenRequestAsync(context: MessageRouterContext, request: FamilyCategoryGetChildrenRequest, response: FamilyCategoryGetChildrenResponse): Promise<MessageResultType>;
        onFamilyCategoryDeleteRequestAsync(context: MessageRouterContext, request: FamilyCategoryDeleteRequest, response: FamilyCategoryDeleteResponse): Promise<MessageResultType>;
        onFamilyCategorySearchRequestAsync(context: MessageRouterContext, request: FamilyCategorySearchRequest, response: FamilyCategorySearchResponse): Promise<MessageResultType>;
        private loopSearchCategoryAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyInfoRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PublishFamilyInfoFamilyRequest } from 'sk/data/logic/module/message/PublishFamilyInfoFamilyRequest';
    import { PublishFamilyInfoFamilyResponse } from 'sk/data/logic/module/message/PublishFamilyInfoFamilyResponse';
    import { PublishFamilyInfoGetBySymbolIdRequest } from 'sk/data/logic/module/message/PublishFamilyInfoGetBySymbolIdRequest';
    import { PublishFamilyInfoGetBySymbolIdResponse } from 'sk/data/logic/module/message/PublishFamilyInfoGetBySymbolIdResponse';
    import { PublishFamilyInfoGetRequest } from 'sk/data/logic/module/message/PublishFamilyInfoGetRequest';
    import { PublishFamilyInfoGetResponse } from 'sk/data/logic/module/message/PublishFamilyInfoGetResponse';
    import { PublishFamilyInfoListRequest } from 'sk/data/logic/module/message/PublishFamilyInfoListRequest';
    import { PublishFamilyInfoListResponse } from 'sk/data/logic/module/message/PublishFamilyInfoListResponse';
    import { PublishFamilyInfoListsRequest } from 'sk/data/logic/module/message/PublishFamilyInfoListsRequest';
    import { PublishFamilyInfoListsResponse } from 'sk/data/logic/module/message/PublishFamilyInfoListsResponse';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    export class ModuleFamilyInfoRouter extends MessageRouter {
        processCode: string;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _familyController: FamilyController;
        protected _familyTypeController: FamilyTypeController;
        protected _productSymbolController: ProductSymbolController;
        protected _familySymbolController: FamilySymbolController;
        private buildGetResponseDataAsync;
        private buildListResponseItems;
        private getInfoUnitsByFamilyIdAsync;
        onPublishFamilyInfoListRequestAsync(context: MessageRouterContext, request: PublishFamilyInfoListRequest, response: PublishFamilyInfoListResponse): Promise<MessageResultType>;
        onPublishFamilyInfoListsRequestAsync(context: MessageRouterContext, request: PublishFamilyInfoListsRequest, response: PublishFamilyInfoListsResponse): Promise<MessageResultType>;
        onPublishFamilyInfoGetRequestAsync(context: MessageRouterContext, request: PublishFamilyInfoGetRequest, response: PublishFamilyInfoGetResponse): Promise<MessageResultType>;
        onPublishFamilyInfoFamilyRequestAsync(context: MessageRouterContext, request: PublishFamilyInfoFamilyRequest, response: PublishFamilyInfoFamilyResponse): Promise<MessageResultType>;
        onPublishFamilyInfoGetBySymbolIdRequestAsync(context: MessageRouterContext, request: PublishFamilyInfoGetBySymbolIdRequest, response: PublishFamilyInfoGetBySymbolIdResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/util/WarehouseLibraryLogicUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MessageResponse } from 'cross/data/module/message/MessageResponse';
    import { StorageModuleTypeEnum } from 'foundation/data/common/enumeration/StorageModuleTypeEnum';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { DataQuery } from 'foundation/service/common/database/util/DataQuery';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { MongoStorageTransferService } from 'foundation/service/common/storage/mongodb/MongoStorageTransferService';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    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 { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { DataCheckerDocumentCompareResult } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    export class WarehouseLibraryLogicUtil {
        protected static _datasetLogicService: DatasetLogicService;
        protected static _ossService: OssConnectionService;
        protected static _monoStorageService: MongoStorageTransferService;
        static setBatchOption(context: DataContext, optionBatch?: boolean): void;
        static getBatchOption(context: DataContext): boolean;
        private static getDataContext;
        static buildLibraryVersionQuery(context: DataContext, logic: DatasetLogic, libraryVersion?: string): DataQuery;
        static buildLibraryQuery(context: DataContext, logic: DatasetLogic, libraryVersion: string): DataQuery;
        static findByIdAsync<U extends DatasetUnit>(context: DataContext, dataName: string, id: string): Promise<U>;
        static searchAsync<U extends DatasetUnit>(context: DataContext, dataName: string, query: DataQuery): Promise<U>;
        static fetchAsync<U extends DatasetUnit>(context: DataContext, dataName: string, query: DataQuery): Promise<DatasetResult<U>>;
        private static getDatasetCache;
        private static matchDatasetUnit;
        private static buildQueryCacheCode;
        static compareWithCurrentAsync(context: DataContext, documentService: DataDocumentService<DataDocument>, moduleCd: StorageModuleTypeEnum, id: string, version: AssetVersionType, latestContent?: any): Promise<ResultObject<DataCheckerDocumentCompareResult>>;
        static loadDocumentAsync<T extends DataDocument>(context: DataContext, documentService: DataDocumentService<T>, moduleCd: StorageModuleTypeEnum, id: string, version: AssetVersionType, optionStorageLoad?: boolean): Promise<DataDocumentResult<T>>;
        static loadContentAsync(context: DataContext, documentService: DataDocumentService<DataDocument>, moduleCd: StorageModuleTypeEnum, id: string, version: AssetVersionType, optionStorageLoad?: boolean): Promise<ResultObject>;
        private static loadContentFromRemoteAsync;
        private static loadContentFromStorageAsync;
        private static loadContentFromOssAsync;
        static addSessionLostMsg(owner: any, response: MessageResponse): void;
    }
}
declare module "sk/service/logic/warehouse/check/service/DatasetCheckLogicService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { DatasetUnitCheckTypeEnum } from 'sk/data/logic/module/enumeration/DatasetUnitCheckTypeEnum';
    import { DatasetCheckParameter } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DataCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { DatasetCheckerRegisterService } from 'sk/service/data/logic/warehouse/check/service/DatasetCheckerRegisterService';
    import { WarehouseDatabaseDto } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDto';
    export class DatasetCheckLogicService extends Service {
        protected _datasetLogicService: DatasetLogicService;
        protected _ossService: OssConnectionService;
        protected _datasetCheckRegisterService: DatasetCheckerRegisterService;
        processInvokerAsync(context: DataContext, database: WarehouseDatabaseDto, spaceNames: Array<string>, datasetName?: string, checkTypes?: Array<DatasetUnitCheckTypeEnum>): Promise<ResultObject<Array<DataCheckResultInfo>>>;
        private onProcessAsync;
        processAsync(context: LogicContext, parameter: DatasetCheckParameter): Promise<ResultObject<Array<DataCheckResultInfo>>>;
        private processByDatasetNameAsync;
        private processDatasetCheckersAsync;
        private processDatasetCheckerAsync;
        processDatasetUnitAsync(context: DataContext, datasetName: string, id: string, content?: any, checkTypes?: Array<DatasetUnitCheckTypeEnum>): Promise<ResultObject<Array<DataCheckResultInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/service/WarehouseLibraryInitializeService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageResponse } from 'cross/data/module/message/MessageResponse';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { DatasetController } from 'foundation/service/common/router/database/DatasetController';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LibraryTypeEnum } from 'foundation/service/common/router/database/LibraryTypeEnum';
    import { ServerWarehouseService } from 'foundation/service/common/router/database/ServerWarehouseService';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FieldMeta } from 'foundation/service/common/database/FieldMeta';
    import { LibraryBusinessTypeEnum } from 'sk/data/logic/library/enumeration/LibraryBusinessTypeEnum';
    import { LibraryCreateRequestVo } from 'sk/data/logic/warehouse/message/LibraryCreateRequest';
    import { ModuleLibraryInsertRequestVo } from 'sk/data/logic/warehouse/message/ModuleLibraryInsertRequest';
    import { ResourceLibraryInsertRequestVo } from 'sk/data/logic/warehouse/message/ResourceLibraryInsertRequest';
    import { WarehouseInsertRequest } from 'sk/data/logic/warehouse/message/WarehouseInsertRequest';
    import { WarehouseInsertResponse } from 'sk/data/logic/warehouse/message/WarehouseInsertResponse';
    import { ModuleLibraryController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryController';
    import { ModuleLibraryStructureController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryStructureController';
    import { ModuleLibraryVersionController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryVersionController';
    import { ResourceLibraryController } from 'sk/service/data/logic/warehouse/controller/ResourceLibraryController';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { WarehouseDatabaseDataspaceController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDataspaceController';
    import { WarehouseDatabaseDto } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDto';
    import { ModuleLibraryUnit } from 'sk/service/data/logic/warehouse/logic/ModuleLibraryUnit';
    import { ResourceLibraryUnit } from 'sk/service/data/logic/warehouse/logic/ResourceLibraryUnit';
    import { WarehouseUnit } from 'sk/service/data/logic/warehouse/logic/WarehouseUnit';
    export type LibraryCreateParameter = {
        type: LibraryTypeEnum;
        baseDbId: string;
        baseDatabaseName: string;
        tenantId: string;
        libraryId: string;
        databaseName: string;
        dataSpaces: Array<string>;
        businessType?: LibraryBusinessTypeEnum;
    };
    export class WarehouseLibraryInitializeService extends Service {
        protected _environmentService: EnvironmentService;
        protected _logicInterfaceService: LogicInterfaceService;
        protected _datasetLogicService: DatasetLogicService;
        protected _warehouseService: ServerWarehouseService;
        protected _warehouseController: WarehouseController;
        protected _databaseController: WarehouseDatabaseController;
        protected _dataSpaceController: WarehouseDatabaseDataspaceController;
        protected _moduleLibraryController: ModuleLibraryController;
        protected _resourceLibraryController: ResourceLibraryController;
        protected _moduleLibraryStructureController: ModuleLibraryStructureController;
        protected _moduleLibraryVersionController: ModuleLibraryVersionController;
        private _moduleDatabaseName;
        private _resourceDatabaseName;
        private readonly _randomChars;
        private readonly _minLength;
        private readonly _maxLength;
        private readonly _warehouseCodeLength;
        private readonly _maxWarehouseCode;
        private readonly _libraryCodeLength;
        private readonly _maxLibraryCode;
        private readonly _codeReg;
        private readonly _moduleStructureCode;
        private _baseDatabaseNames;
        initializeConfig(jconfig: any): void;
        insertWarehouseAsync(context: MessageRouterContext, request: WarehouseInsertRequest): Promise<ResultObject<WarehouseUnit>>;
        private insertDatabaseAsync;
        private insertDataSpacesAsync;
        createLibraryAsync(context: MessageRouterContext, request: WarehouseInsertRequest, response: WarehouseInsertResponse): Promise<ResultObject>;
        createModuleLibraryAsync(context: DataContext, warehouseUnit: WarehouseUnit, libraryName: string, libraryTypeCode: string, data?: ModuleLibraryInsertRequestVo | LibraryCreateRequestVo): Promise<ResultObject<ModuleLibraryUnit>>;
        private insertModuleLibraryVersionAsync;
        createResourceLibraryAsync(context: DataContext, warehouseUnit: WarehouseUnit, libraryName: string, data?: ResourceLibraryInsertRequestVo | LibraryCreateRequestVo): Promise<ResultObject<ResourceLibraryUnit>>;
        private getModuleLibraryStructureAsync;
        private insertModuleLibraryAsync;
        private insertResourceLibraryAsync;
        buildLibraryDatabaseCreateParameterAsync(context: DataContext, warehouseUnit: WarehouseUnit, libraryId: string, type: LibraryTypeEnum, libraryCode: string, businessType?: LibraryBusinessTypeEnum): Promise<ResultObject<LibraryCreateParameter>>;
        upgradeLibraryAsync(context: MessageRouterContext, libraryId: string, type: LibraryTypeEnum): Promise<ResultObject>;
        initPhysicalDatabaseAsync(context: MessageRouterContext, parameters: Array<LibraryCreateParameter>): Promise<ResultObject>;
        private randString;
        buildLatestWarehouseCodeAsync(context: MessageRouterContext): Promise<ResultObject<string>>;
        buildLatestLibraryCodeAsync(context: DataContext, fieldCode: FieldMeta, controller: DatasetController, warehouseCode: string): Promise<ResultObject<string>>;
        private compareLibraryCode;
        getLibraryType(database: WarehouseDatabaseDto): LibraryTypeEnum;
        processErrorResult(response: MessageResponse, result: ResultObject): void;
        private buildCode;
    }
}
declare module "sk/service/logic/module/service/SymbolSynchronizationService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { ConfigureController } from 'sk/data/family/element/config/configure/ConfigureController';
    import { DecorateController } from 'sk/data/family/element/config/decorate/DecorateController';
    import { ColorSymbolElement } from 'sk/data/family/element/config/symbol/ColorSymbolElement';
    import { ColorSymbolItemElement } from 'sk/data/family/element/config/symbol/ColorSymbolItemElement';
    import { ConfigureSymbolElement } from 'sk/data/family/element/config/symbol/ConfigureSymbolElement';
    import { DecorateSymbolElement } from 'sk/data/family/element/config/symbol/DecorateSymbolElement';
    import { LogicSymbolElement } from 'sk/data/family/element/config/symbol/LogicSymbolElement';
    import { SizeLengthSymbolElement } from 'sk/data/family/element/config/symbol/SizeLengthSymbolElement';
    import { SizeSymbolElement } from 'sk/data/family/element/config/symbol/SizeSymbolElement';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { SymbolConverterService } from 'sk/data/family/symbol/SymbolConverterService';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { FamilySymbolUnit } from 'sk/service/data/logic/module/logic/FamilySymbolUnit';
    import { ProductSymbolUnit } from 'sk/service/data/logic/module/logic/ProductSymbolUnit';
    export class SymbolLogicSign {
        frequency: number;
        index: number;
        count: number;
        static create(index: number, count: number, frequency: number): SymbolLogicSign;
    }
    export enum SymbolLogicType {
        All = 0,
        Size = 1,
        Configure = 2,
        Decorate = 3,
        Features = 4,
        Length = 5,
        Logic = 6,
        Color = 7
    }
    export class SymbolSynchronizationService extends Service {
        protected _symbolConverterService: SymbolConverterService;
        protected _datasetLogicService: DatasetLogicService;
        protected _familyInfoController: PublishFamilyInfoController;
        buildSymbolsAsync(context: DataContext, familyDocument: FamilyDataDocument, familyDto: FamilyDto): Promise<ResultObject>;
        private buildSymbolFeaturesAsync;
        private updateSymbolsAsync;
        updateSymbolsStatusAsync(context: DataContext, familyDto: FamilyDto, familyDocument: FamilyDataDocument, familySymbols: Types<FamilySymbolUnit>, productSymbols: Types<ProductSymbolUnit>, libraryVersion?: string): Promise<ResultObject>;
        private fixSymbolFeatures;
        private findFamilySymbolUnitAsync;
        private insertSymbolAsync;
        private insertProductSymbolAsync;
        private updateFamilySymbolAsync;
        private updateSymbolStatusAsync;
        private updateProductSymbolStatusAsync;
        makeHandleSize(symbolsFeatures: Array<any>, bool: boolean): boolean;
        makeHandleSizeSymbol(childList: Array<any>, bool: boolean): boolean;
        getSizeFreeGroupOption(document: FamilyDataDocument): boolean;
        buildSizeLengthSymbols(sizeLengthSymbolElements: Array<SizeLengthSymbolElement>): Array<any>;
        private buildSizeLengthSymbolJsonObject;
        private buildFamilySymbolUnit;
        convertColorSymbolName(features: string): string;
        private buildProductSymbolListAsync;
        private getSourceItemLength;
        private makeSignMap;
        private buildSymbolFeaturesByType;
        private buildSymbolFeatureItems;
        private makeSymbolItems;
        private combineSymbolFeatures;
        private buildSizeSymbolJsonObject;
        buildColorSymbolJsonObject(symbolElement: ColorSymbolElement, symbolItemElement: ColorSymbolItemElement): any;
        private buildLogicSymbolJsonObject;
        private buildConfigureSymbolJsonObject;
        private buildDecorateSymbolJsonObject;
        private buildConfigureElementByDtoAsync;
        private buildConfigureOptionElement;
        private buildDecorateElementByDtoAsync;
        private buildDecorateItemElement;
        convertToIdentifyCode(features: string): string;
        buildSymbolsFeatures(sizeSymbols: Array<any>, configureSymbols: Array<any>, decorateSymbols: Array<any>, featureSymbols: Array<any>, sizeLengthXSymbols?: Array<any>, sizeLengthYSymbols?: Array<any>, sizeLengthZSymbols?: Array<any>, colorSymbols?: Array<any>, logicSymbols?: Array<any>): Array<string>;
        buildSymbolIdentifyCodeList(symbolsFeatures: Array<string>): Array<string>;
        buildSizeSymbols(sizeSymbolElements: Array<SizeSymbolElement>): Array<any>;
        buildColorSymbolsAsync(symbolElements: Array<ColorSymbolElement>): Promise<Array<any>>;
        buildLogicSymbols(symbolElements: Array<LogicSymbolElement>): Array<any>;
        buildConfigureElementSymbolsAsync(context: DataContext, controller: ConfigureController, symbolElements: Array<ConfigureSymbolElement>): Promise<Array<any>>;
        buildDecorateElementSymbolsAsync(context: DataContext, controller: DecorateController, symbolElements: Array<DecorateSymbolElement>): Promise<Array<any>>;
    }
}
declare module "sk/service/logic/module/symbol/structure/SymbolAttributeStructure" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    export class SymbolAttributeStructure {
        attributeCode: string;
        attributeName: string;
        type: number;
        symbolType: string;
        optionExpand: boolean;
        loadJson(jconfig: any): void;
        saveJson(): any;
        static parseToMap(features: string): TypeMap<string, SymbolAttributeStructure>;
    }
}
declare module "sk/service/logic/module/symbol/structure/SymbolValueStructure" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export abstract class SymbolValueStructure extends InstanceObject {
        id: string;
        name: string;
        abstract loadJson(jconfig: any): void;
        abstract saveJson(): any;
        abstract compare(target: SymbolValueStructure): boolean;
    }
}
declare module "sk/service/logic/module/symbol/structure/SymbolStructure" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DecorateSymbolElement } from 'sk/data/family/element/config/symbol/DecorateSymbolElement';
    import { SymbolElement } from 'sk/data/family/element/config/symbol/SymbolElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyCategoryDto } from 'sk/service/data/logic/module/controller/FamilyCategoryDto';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { FamilyTypeDto } from 'sk/service/data/logic/module/controller/FamilyTypeDto';
    import { SymbolAttributeStructure } from "sk/service/logic/module/symbol/structure/SymbolAttributeStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export abstract class SymbolStructure extends InstanceObject {
        type: string;
        id: string;
        code: string;
        name: string;
        optionExpand: boolean;
        value: SymbolValueStructure | Array<SymbolValueStructure>;
        loadJson(jconfig: any): void;
        saveJson(): any;
        abstract compare(target: SymbolStructure): boolean;
        formatBusinessStructure(attribute: SymbolAttributeStructure, unitMap?: TypeMap<string, string>): SymbolBusinessStructure;
    }
    export type SymbolBuilderConfig = {
        type: string;
        elements: Types<SymbolElement>;
        document: FamilyDocument;
        familyDto: FamilyDto;
        linkType?: DecorateSymbolLinkType;
        textureConfigs?: TypeMap<string, TextureDecorateSymbolConfig>;
    };
    export type SymbolResultStructure<S extends SymbolStructure, V extends SymbolValueStructure> = {
        expandStructures: Types<S>;
        valueStructures: Array<V>;
    };
    export class FamilySymbolConfigureData extends InstanceObject {
        id: string;
        code: string;
        name: string;
        features: string;
        parentId?: string;
        static create<T extends FamilyCategoryDto | FamilyTypeDto>(unit: T): FamilySymbolConfigureData;
    }
    export type FamilySymbolConfigure = {
        categories: Map<string, FamilySymbolConfigureData>;
        types: Map<string, FamilySymbolConfigureData>;
    };
    export enum DecorateSymbolLinkType {
        Decorate = "decorate",
        Resource = "resource"
    }
    export type TextureDecorateSymbolConfig = {
        materialId?: string;
        materialItemId?: string;
    };
    export type DecorateSymbolConfig = {
        type: string;
        linkType: DecorateSymbolLinkType;
        decorateSymbolElements: Types<DecorateSymbolElement>;
        textureConfigs?: TypeMap<string, TextureDecorateSymbolConfig>;
    };
    export type SymbolBusinessStructure = {
        id: string;
        type: string;
        code: string;
        name: string;
        showValue: string;
        unit?: string;
        value?: string;
    };
}
declare module "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DecorateSymbolElement } from 'sk/data/family/element/config/symbol/DecorateSymbolElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { DecorateSymbolConfig, FamilySymbolConfigureData } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    export abstract class DecorateSymbolHandler {
        protected _documentService: FamilyDocumentService;
        abstract processAsync(context: DataContext, document: FamilyDocument, familyDto?: FamilyDto, configData?: FamilySymbolConfigureData): Promise<ResultObject<DecorateSymbolConfig>>;
        protected buildDecorateSymbolElements(document: FamilyDocument): Types<DecorateSymbolElement>;
    }
}
declare module "sk/service/logic/module/symbol/decorate/common/DecorateSymbolLogicDeclareInfo" {
    import { DecorateSymbolHandler } from "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler";
    export class DecorateSymbolLogicDeclareInfo {
        code: string;
        type: string;
        handler: DecorateSymbolHandler;
    }
}
declare module "sk/service/logic/module/symbol/decorate/service/DecorateSymbolLogicService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    import { SymbolDimensionStructure } from 'sk/data/family/attribute/feature/symbol/SymbolDimensionStructure';
    import { DecorateSymbolLogicDeclareInfo } from "sk/service/logic/module/symbol/decorate/common/DecorateSymbolLogicDeclareInfo";
    import { DecorateSymbolHandler } from "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler";
    export class DecorateSymbolLogicService extends Service {
        protected _declareInfos: TypeMap<string, Types<DecorateSymbolLogicDeclareInfo>>;
        register(info: DecorateSymbolLogicDeclareInfo): void;
        findHandlers(code: string, dimensions: Types<SymbolDimensionStructure>): Types<DecorateSymbolHandler>;
    }
}
declare module "sk/service/logic/module/symbol/builder/SymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { SymbolBuilderConfig, SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    export abstract class SymbolBuilder {
        protected _optionEntire: boolean;
        constructor();
        abstract buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<SymbolStructure>>>;
        compare(source: SymbolStructure, target: SymbolStructure): boolean;
    }
}
declare module "sk/service/logic/module/symbol/common/SymbolBuilderDeclareInfo" {
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class SymbolBuilderDeclareInfo {
        type: string;
        clazz: any;
        structureClazz: any;
        builder: SymbolBuilder;
    }
}
declare module "sk/service/logic/module/symbol/service/FamilySymbolBuildService" {
    import { Service } from 'cross/runtime/module/Service';
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    import { SymbolBuilderDeclareInfo } from "sk/service/logic/module/symbol/common/SymbolBuilderDeclareInfo";
    import { SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    export class FamilySymbolBuildService extends Service {
        private _declareInfos;
        register(info: SymbolBuilderDeclareInfo): void;
        findBuilder(type: string): SymbolBuilder;
        createStructure<S extends SymbolStructure>(type: string, feature: any): S;
    }
}
declare module "sk/service/logic/module/symbol/structure/ColorSymbolStructure" {
    import { PaletteColorElement } from 'sk/data/family/element/config/palette/PaletteColorElement';
    import { PaletteColorGroupElement } from 'sk/data/family/element/config/palette/PaletteColorGroupElement';
    import { ColorSymbolElement } from 'sk/data/family/element/config/symbol/ColorSymbolElement';
    import { ColorSymbolItemElement } from 'sk/data/family/element/config/symbol/ColorSymbolItemElement';
    import { ConfigPaletteUnit } from 'sk/service/data/logic/module/logic/ConfigPaletteUnit';
    import { SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class ColorSymbolStructure extends SymbolStructure {
        value: ColorSymbolValueStructure | Array<ColorSymbolValueStructure>;
        static createExpandStructure(paletteUnit: ConfigPaletteUnit, group: PaletteColorGroupElement, color: PaletteColorElement): ColorSymbolStructure;
        static createExpandStructureBySymbolElement(element: ColorSymbolElement, itemElement: ColorSymbolItemElement): ColorSymbolStructure;
        static createEntiretyStructure(values: Array<ColorSymbolValueStructure>): ColorSymbolStructure;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: ColorSymbolStructure): boolean;
    }
    export class ColorSymbolValueStructure extends SymbolValueStructure {
        referenceConfigId: string;
        referenceConfigName: string;
        groupId: string;
        groupName: string;
        referenceGroupItemId: string;
        red: number;
        green: number;
        blue: number;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: ColorSymbolValueStructure): boolean;
        static create(paletteUnit: ConfigPaletteUnit, group?: PaletteColorGroupElement, color?: PaletteColorElement): ColorSymbolValueStructure;
        static createBySymbolElement(element: ColorSymbolElement, itemElement: ColorSymbolItemElement): ColorSymbolValueStructure;
    }
}
declare module "sk/service/logic/module/symbol/structure/MaterialSymbolStructure" {
    import { ConfigDecorateItemDto } from 'sk/service/data/logic/module/controller/ConfigDecorateItemDto';
    import { ConfigDecorateUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateUnit';
    import { SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class MaterialSymbolStructure extends SymbolStructure {
        static createExpandStructureByMaterial(materialDto: ConfigDecorateUnit, materialItemDto: ConfigDecorateItemDto): MaterialSymbolStructure;
        static createEntiretyStructure(values: Array<MaterialSymbolValueStructure>): MaterialSymbolStructure;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: MaterialSymbolStructure): boolean;
    }
    export class MaterialSymbolValueStructure extends SymbolValueStructure {
        code: string;
        materialItemId: string;
        materialItemCode: string;
        materialItemName: string;
        materialItemBindingId: string;
        materialItemBindingCd: number;
        materialItemOptionDefault: boolean;
        static createByMaterial(materialDto: ConfigDecorateUnit, materialItemDto: ConfigDecorateItemDto): MaterialSymbolValueStructure;
        compare(target: MaterialSymbolValueStructure): boolean;
        loadJson(jconfig: any): void;
        saveJson(): any;
    }
}
declare module "sk/service/logic/module/symbol/structure/SizeSymbolStructure" {
    import { SizeSymbolItemElement } from 'sk/data/family/element/config/symbol/SizeSymbolItemElement';
    import { SymbolAttributeStructure } from "sk/service/logic/module/symbol/structure/SymbolAttributeStructure";
    import { SymbolBusinessStructure, SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class SizeSymbolStructure extends SymbolStructure {
        static createExpandStructure(item: SizeSymbolItemElement): SizeSymbolStructure;
        static createEntiretyStructure(values: Array<SizeSymbolValueStructure>): SizeSymbolStructure;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: SizeSymbolStructure): boolean;
        formatBusinessStructure(attribute: SymbolAttributeStructure): SymbolBusinessStructure;
    }
    export class SizeSymbolValueStructure extends SymbolValueStructure {
        lengthMinX: number;
        lengthMinY: number;
        lengthMinZ: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        lengthMaxX: number;
        lengthMaxY: number;
        lengthMaxZ: number;
        lockCd: boolean;
        optionDefault: boolean;
        static create(item: SizeSymbolItemElement): SizeSymbolValueStructure;
        compare(target: SizeSymbolValueStructure): boolean;
        loadJson(jconfig: any): void;
        saveJson(): any;
        format(): string;
        formatLength(fieldName: string, minFieldName: string, maxFieldName: string): string;
    }
    export type DefaultSizeStructure = {
        lengthX: number;
        lengthY: number;
        lengthZ: number;
    };
}
declare module "sk/service/logic/module/symbol/structure/TextureSymbolStructure" {
    import { ConfigDecorateItemUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateItemUnit';
    import { ConfigDecorateUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateUnit';
    import { ResourceDto } from 'sk/service/data/logic/resource/controller/ResourceDto';
    import { DecorateSymbolLinkType, SymbolStructure, TextureDecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class TextureSymbolStructure extends SymbolStructure {
        linkType: DecorateSymbolLinkType;
        static createExpandStructureByDecorate(textureUnit: ConfigDecorateUnit, textureItemUnit: ConfigDecorateItemUnit, textureConfig: TextureDecorateSymbolConfig): TextureSymbolStructure;
        static createExpandStructureByResource(resourceDto: ResourceDto): TextureSymbolStructure;
        static createEntiretyStructure(values: Array<TextureSymbolValueStructure>, linkType: DecorateSymbolLinkType): TextureSymbolStructure;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: TextureSymbolStructure): boolean;
    }
    export class TextureSymbolValueStructure extends SymbolValueStructure {
        code: string;
        itemId?: string;
        itemCode?: string;
        itemName?: string;
        itemOptionDefault?: boolean;
        itemBindingId?: string;
        itemBindingCd?: number;
        materialId?: string;
        materialItemId?: string;
        static createByDecorate(textureUnit: ConfigDecorateUnit, textureConfig: TextureDecorateSymbolConfig, textureItemUnit: ConfigDecorateItemUnit): TextureSymbolValueStructure;
        static createByResource(resourceDto: ResourceDto): TextureSymbolValueStructure;
        compare(target: TextureSymbolValueStructure): boolean;
        loadJson(jconfig: any): void;
        saveJson(): any;
    }
}
declare module "sk/service/logic/module/symbol/util/SymbolLogicUtil" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { IDataContext } from 'foundation/service/common/database/IDataContext';
    import { SpecificationSymbolTypeEnum } from 'sk/data/specification/enumeration/SpecificationSymbolTypeEnum';
    import { SymbolDimensionStructure } from 'sk/data/family/attribute/feature/symbol/SymbolDimensionStructure';
    import { SymbolStateTypeEnum } from 'sk/data/family/enumeration/SymbolStateTypeEnum';
    import { ConfigDecorateController } from 'sk/service/data/logic/module/controller/ConfigDecorateController';
    import { FamilyCategoryDto } from 'sk/service/data/logic/module/controller/FamilyCategoryDto';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { FamilyTypeDto } from 'sk/service/data/logic/module/controller/FamilyTypeDto';
    import { FamilySymbolUnit } from 'sk/service/data/logic/module/logic/FamilySymbolUnit';
    import { ProductSymbolUnit } from 'sk/service/data/logic/module/logic/ProductSymbolUnit';
    import { ProductUnit } from 'sk/service/data/logic/module/logic/ProductUnit';
    import { ResourceController } from 'sk/service/data/logic/resource/controller/ResourceController';
    import { FamilySymbolBuildService } from "sk/service/logic/module/symbol/service/FamilySymbolBuildService";
    import { DefaultSizeStructure } from "sk/service/logic/module/symbol/structure/SizeSymbolStructure";
    import { SymbolAttributeStructure } from "sk/service/logic/module/symbol/structure/SymbolAttributeStructure";
    import { FamilySymbolConfigure, SymbolBusinessStructure, SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class SymbolLogicUtil {
        protected static _buildService: FamilySymbolBuildService;
        protected static _decorateController: ConfigDecorateController;
        protected static _resourceController: ResourceController;
        protected static _familyController: FamilyController;
        static computeCartesianProductsSymbols(symbolStructures: TypeMap<string, Types<SymbolStructure>>, targetTypes?: Array<string>): Array<Array<SymbolStructure>>;
        private static matchCombinationTypes;
        static computeSymbolCartesianProductSymbol(symbolStructures: Types<Types<SymbolStructure>>, index: number, result?: Array<Array<SymbolStructure>>, cache?: Array<SymbolStructure>): Array<Array<SymbolStructure>>;
        private static checkStructures;
        static computeSymbolCombinationTypes(symbolTypes: Array<string>): Array<Array<string>>;
        static computeSymbolCombinationType(items: Array<string>, indexes: Array<number>, start: number, count: number, result?: Array<Array<string>>): Array<Array<string>>;
        static findFamilySymbolUnit(structures: Array<SymbolStructure>, units: Types<FamilySymbolUnit>): FamilySymbolUnit;
        static findStructures(unit: FamilySymbolUnit, symbolStructures: Array<Array<SymbolStructure>>): Array<SymbolStructure>;
        static matchFeatures(structures: Array<SymbolStructure>, features: Array<any>): boolean;
        static findFeatureByType(type: string, features: Array<any>): any;
        static getSymbolExpandOption(type: string, dimensions: Types<SymbolDimensionStructure>): boolean;
        static parseFamilySymbolDimensions(familyDto: FamilyDto, configure: FamilySymbolConfigure): Types<SymbolDimensionStructure>;
        private static parseSymbolDimensionsByConfigMap;
        static parseSymbolDimensions(strFeatures: string): Types<SymbolDimensionStructure>;
        private static getSymbolDimensionsFromFeatures;
        static getSymbolDimensionsConfigs(type: FamilyTypeDto, category: FamilyCategoryDto): FamilySymbolConfigure;
        private static buildSizeSymbolDimension;
        static buildFamilySymbolUnit(familyDto: FamilyDto, structures: Array<SymbolStructure>, defaultSize: DefaultSizeStructure): FamilySymbolUnit;
        static buildIdentifyCode(structures: Array<SymbolStructure>): string;
        static buildFamilySymbolName(familyDto: FamilyDto, structures: Array<SymbolStructure>): string;
        static formatSymbolFeatures(structures: Array<SymbolStructure>): string;
        static findSymbolByType<S extends SymbolStructure>(type: string, features: Array<SymbolStructure>): S;
        static fetchFamilySymbolsAsync(context: DataContext, familyId: string, statusCd?: SymbolStateTypeEnum): Promise<Types<FamilySymbolUnit>>;
        static fetchProductSymbolsAsync(context: DataContext, productUnit: ProductUnit, statusCd?: SymbolStateTypeEnum): Promise<Types<ProductSymbolUnit>>;
        static getDefaultSizeSymbol(structures: Array<Array<SymbolStructure>>): DefaultSizeStructure;
        static buildProductSymbolDto(symbolDto: FamilySymbolUnit, productId: string): ProductSymbolUnit;
        static hexToRgb(hex: string): {
            r: number;
            g: number;
            b: number;
        };
        static buildEntiretyName(values: Array<SymbolValueStructure>, fieldName?: string): string;
        static formatBusinessSymbolAsync(context: IDataContext, features: string, attributeMap: TypeMap<string, SymbolAttributeStructure>, unitMap: TypeMap<string, string>): Promise<Array<SymbolBusinessStructure>>;
        private static updateStructureNamesAsync;
        private static updateMaterialStructureNamesAsync;
        private static updateTextureStructureNamesAsync;
        private static updateTextureStructuresNameByDecorateAsync;
        private static getDecorateBindingFamilyAsync;
        private static getDecorateEntiretyNameAsync;
        private static updateTextureStructuresNameByResourceAsync;
        private static getResourceEntiretyNameAsync;
        static createSymbolStructuresByFeatures(strFeatures: string): Array<SymbolStructure>;
        static createSymbolStructureMap(symbolStructures: Array<SymbolStructure>, filterType?: SpecificationSymbolTypeEnum): TypeMap<string, Types<SymbolStructure>>;
        static matchBySymbolStructures(sourceStructures: Array<SymbolStructure>, targetStructures: Array<SymbolStructure>, filterType?: SpecificationSymbolTypeEnum): boolean;
        static buildColorSymbolDataInfo(unit: ProductSymbolUnit): any;
        private static createDataSymbolColorInfo;
        private static createColorDataInfo;
        private static createColorDataInfoFeature;
    }
}
declare module "sk/service/logic/module/symbol/service/FamilySymbolLogicService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { SymbolDimensionStructure } from 'sk/data/family/attribute/feature/symbol/SymbolDimensionStructure';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { SymbolSynchronizationService } from "sk/service/logic/module/service/SymbolSynchronizationService";
    import { DecorateSymbolLogicService } from "sk/service/logic/module/symbol/decorate/service/DecorateSymbolLogicService";
    import { FamilySymbolConfigure, SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { FamilySymbolBuildService } from "sk/service/logic/module/symbol/service/FamilySymbolBuildService";
    export class FamilySymbolLogicService extends Service {
        private _elementConfigs;
        protected _documentService: FamilyDocumentService;
        protected _buildService: FamilySymbolBuildService;
        protected _symbolSyncService: SymbolSynchronizationService;
        protected _decorateLogicService: DecorateSymbolLogicService;
        protected _familyCategoryController: FamilyCategoryController;
        protected _familyTypeController: FamilyTypeController;
        protected _familySymbolController: FamilySymbolController;
        protected _productSymbolController: ProductSymbolController;
        expandAsync(context: DataContext, familyDto: FamilyDto, document?: FamilyDocument): Promise<ResultObject>;
        computeSymbolsAsync(context: DataContext, familyDto: FamilyDto, document: FamilyDocument, configure: FamilySymbolConfigure, dimensions: Types<SymbolDimensionStructure>): Promise<ResultObject<Array<Array<SymbolStructure>>>>;
        private checkSymbolStructuresByDimensions;
        private buildSymbolStructuresAsync;
        private buildSymbolStructuresByConfigsAsync;
        private buildSymbolStructuresByConfigAsync;
        private buildSymbolBuilderConfigsAsync;
        private buildDecorateBuilderConfigAsync;
        private buildSymbolBuilderConfig;
        private buildDecorateBuilderConfigByCategoryAsync;
        private updateSymbolsAsync;
        private updateSymbolsStatusAsync;
        private updateSymbolStatusAsync;
        private fetchProductSymbolsAsync;
    }
}
declare module "sk/service/logic/module/service/ContainerFamilyCreateService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigVariableController } from 'sk/service/data/logic/module/controller/ConfigVariableController';
    import { FamilyAndContentDto } from 'sk/service/data/logic/module/controller/FamilyAndContentDto';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilySymbolDto } from 'sk/service/data/logic/module/controller/FamilySymbolDto';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { VariableAttributeService } from 'sk/service/data/logic/module/service/VariableAttributeService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    import { SymbolSynchronizationService } from "sk/service/logic/module/service/SymbolSynchronizationService";
    export class ContainerFamilyCreateService extends Service {
        protected _familyController: FamilyController;
        protected _moduleStorageService: ModuleStorageService;
        protected _symbolSynchService: SymbolSynchronizationService;
        protected _variableAttriService: VariableAttributeService;
        protected _familySymbolController: FamilySymbolController;
        protected _familyTypeController: FamilyTypeController;
        protected _familyCategoryController: FamilyCategoryController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        _variableController: ConfigVariableController;
        createFurnitureChildPlankFamilyAsync(context: MessageRouterContext, libraryId: string, tenantId: string, categoryId: string, typeCode: string): Promise<ResultObject<any>>;
        createFurnitureDoorFamilyAsync(context: MessageRouterContext, familyDto: FamilyAndContentDto): Promise<ResultObject<any>>;
        createFurnitureCountertopFamilyAsync(context: MessageRouterContext, familyDto: FamilyAndContentDto): Promise<ResultObject<any>>;
        refreshFamilySymbolUpdateIdentifyCode(familySymbolDto: FamilySymbolDto): void;
    }
}
declare module "sk/service/logic/module/service/MaterialRuleSynchronizationService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { BusinessTypeController } from 'sk/service/data/logic/module/controller/BusinessTypeController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { MaterialFamilyController } from 'sk/service/data/logic/module/controller/MaterialFamilyController';
    import { MaterialRuleController } from 'sk/service/data/logic/module/controller/MaterialRuleController';
    import { MaterialRuleDto } from 'sk/service/data/logic/module/controller/MaterialRuleDto';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    export class MaterialRuleSynchronizationService extends Service {
        protected _familyController: FamilyController;
        protected _ruleController: RuleController;
        protected _materialFamilyController: MaterialFamilyController;
        protected _businessTypeController: BusinessTypeController;
        protected _materialRuleController: MaterialRuleController;
        processMaterialRuleInsertOrUpdateAsync(context: MessageRouterContext, materialRuleSyncDto: MaterialRuleSyncDto): Promise<ResultObject>;
        private materialRuleSyncAsync;
        private addNewMaterialRuleAsync;
        deleteByMaterialIdAsync(context: any, materialId: string): Promise<ResultObject>;
        processNotExistMaterialRuleDeleteAsync(context: MessageRouterContext, materialRuleDtoList: DatasetResult<MaterialRuleDto>, ruleIdList: Array<string>): Promise<ResultObject>;
        getBusniessTypeIdAsync(context: MessageRouterContext): Promise<ResultObject>;
    }
    export type MaterialRuleSyncDto = {
        businessTypeId?: string;
        familyId: string;
    };
}
declare module "sk/service/logic/module/service/MaterialSynchronizationService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { BusinessTypeController } from 'sk/service/data/logic/module/controller/BusinessTypeController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilySymbolDto } from 'sk/service/data/logic/module/controller/FamilySymbolDto';
    import { MaterialCategoryController } from 'sk/service/data/logic/module/controller/MaterialCategoryController';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { MaterialFamilyController } from 'sk/service/data/logic/module/controller/MaterialFamilyController';
    import { MaterialFamilyDto } from 'sk/service/data/logic/module/controller/MaterialFamilyDto';
    import { MaterialTypeController } from 'sk/service/data/logic/module/controller/MaterialTypeController';
    import { MaterialRuleSynchronizationService } from "sk/service/logic/module/service/MaterialRuleSynchronizationService";
    export class MaterialSynchronizationService extends Service {
        protected _familyController: FamilyController;
        protected _familySymbolController: FamilySymbolController;
        protected _materialFamilyController: MaterialFamilyController;
        protected _materialController: MaterialController;
        protected _materialTypeController: MaterialTypeController;
        protected _materialCategoryController: MaterialCategoryController;
        protected _businessTypeController: BusinessTypeController;
        protected _materialRuleSyncService: MaterialRuleSynchronizationService;
        processMaterialInsertOrUpdateAsync(context: MessageRouterContext, materialSyncDto: MaterialSyncDto): Promise<ResultObject>;
        private familySymbolSyncToMaterialAsync;
        private addNewMaterialFamilyAsync;
        private addNewMaterialAsync;
        processNotExistMaterialDeleteAsync(context: MessageRouterContext, familySymbolDtoList: DatasetResult<FamilySymbolDto>, materialFamilyDtoList: DatasetResult<MaterialFamilyDto>): Promise<ResultObject>;
        deleteMaterialByFamailyIdAsync(context: MessageRouterContext, familyId: string): Promise<ResultObject>;
        deleteAsync(context: MessageRouterContext, materialFamilyDto: MaterialFamilyDto): Promise<ResultObject>;
    }
    export type MaterialSyncDto = {
        businessTypeId?: string;
        familyId: string;
        familySymbolId?: string;
        materialId?: string;
        materialCode?: string;
        materialName?: string;
        familyDocument?: FamilyDataDocument;
        features?: string;
    };
}
declare module "sk/service/logic/module/router/ModuleFamilyRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SearchCondition } from 'cross/data/module/dataset/SearchCondition';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { ServiceProcessService } from 'foundation/service/common/process/ServiceProcessService';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyRelation } from 'sk/data/family/util/FamilyDataDocumentRelationUtil';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { FamilyBatchProcessDataRequest } from 'sk/data/logic/module/message/FamilyBatchProcessDataRequest';
    import { FamilyBatchProcessDataResponse } from 'sk/data/logic/module/message/FamilyBatchProcessDataResponse';
    import { FamilyChangeRequest } from 'sk/data/logic/module/message/FamilyChangeRequest';
    import { FamilyChangeResponse } from 'sk/data/logic/module/message/FamilyChangeResponse';
    import { FamilyCheckRequest } from 'sk/data/logic/module/message/FamilyCheckRequest';
    import { FamilyCheckResponse } from 'sk/data/logic/module/message/FamilyCheckResponse';
    import { FamilyDeleteRequest } from 'sk/data/logic/module/message/FamilyDeleteRequest';
    import { FamilyDeleteResponse } from 'sk/data/logic/module/message/FamilyDeleteResponse';
    import { FamilyDoorFilterPageRequest } from 'sk/data/logic/module/message/FamilyDoorFilterPageRequest';
    import { FamilyDoorFilterPageResponse } from 'sk/data/logic/module/message/FamilyDoorFilterPageResponse';
    import { FamilyDoorTypeGetRequest } from 'sk/data/logic/module/message/FamilyDoorTypeGetRequest';
    import { FamilyDoorTypeGetResponse } from 'sk/data/logic/module/message/FamilyDoorTypeGetResponse';
    import { FamilyDoorTypeSyncRequest } from 'sk/data/logic/module/message/FamilyDoorTypeSyncRequest';
    import { FamilyDoorTypeSyncResponse } from 'sk/data/logic/module/message/FamilyDoorTypeSyncResponse';
    import { FamilyGetCategorysRequest } from 'sk/data/logic/module/message/FamilyGetCategorysRequest';
    import { FamilyGetCategorysResponse } from 'sk/data/logic/module/message/FamilyGetCategorysResponse';
    import { FamilyGetConfigureRequest } from 'sk/data/logic/module/message/FamilyGetConfigureRequest';
    import { FamilyGetConfigureResponse } from 'sk/data/logic/module/message/FamilyGetConfigureResponse';
    import { FamilyGetFeaturesRequest } from 'sk/data/logic/module/message/FamilyGetFeaturesRequest';
    import { FamilyGetFeaturesResponse } from 'sk/data/logic/module/message/FamilyGetFeaturesResponse';
    import { FamilyGetFeaturesvalueRequest } from 'sk/data/logic/module/message/FamilyGetFeaturesvalueRequest';
    import { FamilyGetFeaturesvalueResponse } from 'sk/data/logic/module/message/FamilyGetFeaturesvalueResponse';
    import { FamilyGetListRequest } from 'sk/data/logic/module/message/FamilyGetListRequest';
    import { FamilyGetListResponse } from 'sk/data/logic/module/message/FamilyGetListResponse';
    import { FamilyGetPropertyDeclareRequest } from 'sk/data/logic/module/message/FamilyGetPropertyDeclareRequest';
    import { FamilyGetPropertyDeclareResponse } from 'sk/data/logic/module/message/FamilyGetPropertyDeclareResponse';
    import { FamilyGetPublishInfoRequest } from 'sk/data/logic/module/message/FamilyGetPublishInfoRequest';
    import { FamilyGetPublishInfoResponse } from 'sk/data/logic/module/message/FamilyGetPublishInfoResponse';
    import { FamilyGetRequest } from 'sk/data/logic/module/message/FamilyGetRequest';
    import { FamilyGetResponse } from 'sk/data/logic/module/message/FamilyGetResponse';
    import { FamilyInsertCompleteRequest } from 'sk/data/logic/module/message/FamilyInsertCompleteRequest';
    import { FamilyInsertCompleteResponse } from 'sk/data/logic/module/message/FamilyInsertCompleteResponse';
    import { FamilyInsertContainerCompleteRequest } from 'sk/data/logic/module/message/FamilyInsertContainerCompleteRequest';
    import { FamilyInsertContainerCompleteResponse } from 'sk/data/logic/module/message/FamilyInsertContainerCompleteResponse';
    import { FamilyInsertRequest } from 'sk/data/logic/module/message/FamilyInsertRequest';
    import { FamilyInsertResponse } from 'sk/data/logic/module/message/FamilyInsertResponse';
    import { FamilyMoveRequest } from 'sk/data/logic/module/message/FamilyMoveRequest';
    import { FamilyMoveResponse } from 'sk/data/logic/module/message/FamilyMoveResponse';
    import { FamilyPageRequest } from 'sk/data/logic/module/message/FamilyPageRequest';
    import { FamilyPageResponse } from 'sk/data/logic/module/message/FamilyPageResponse';
    import { FamilyPasteRequest } from 'sk/data/logic/module/message/FamilyPasteRequest';
    import { FamilyPasteResponse } from 'sk/data/logic/module/message/FamilyPasteResponse';
    import { FamilyProcessPlankMaterialRequest } from 'sk/data/logic/module/message/FamilyProcessPlankMaterialRequest';
    import { FamilyProcessPlankMaterialResponse } from 'sk/data/logic/module/message/FamilyProcessPlankMaterialResponse';
    import { FamilyProcessRuleRequest } from 'sk/data/logic/module/message/FamilyProcessRuleRequest';
    import { FamilyProcessRuleResponse } from 'sk/data/logic/module/message/FamilyProcessRuleResponse';
    import { FamilyProcessTechnologyRequest } from 'sk/data/logic/module/message/FamilyProcessTechnologyRequest';
    import { FamilyProcessTechnologyResponse } from 'sk/data/logic/module/message/FamilyProcessTechnologyResponse';
    import { FamilyPublishRequest } from 'sk/data/logic/module/message/FamilyPublishRequest';
    import { FamilyPublishResponse } from 'sk/data/logic/module/message/FamilyPublishResponse';
    import { FamilyRenderRequest } from 'sk/data/logic/module/message/FamilyRenderRequest';
    import { FamilyRenderResponse } from 'sk/data/logic/module/message/FamilyRenderResponse';
    import { FamilySearchRequest } from 'sk/data/logic/module/message/FamilySearchRequest';
    import { FamilySearchResponse } from 'sk/data/logic/module/message/FamilySearchResponse';
    import { FamilySyncFeaturesRequest } from 'sk/data/logic/module/message/FamilySyncFeaturesRequest';
    import { FamilySyncFeaturesResponse } from 'sk/data/logic/module/message/FamilySyncFeaturesResponse';
    import { FamilySyncFeaturesvalueRequest } from 'sk/data/logic/module/message/FamilySyncFeaturesvalueRequest';
    import { FamilySyncFeaturesvalueResponse } from 'sk/data/logic/module/message/FamilySyncFeaturesvalueResponse';
    import { FamilyUpdateCompleteRequest } from 'sk/data/logic/module/message/FamilyUpdateCompleteRequest';
    import { FamilyUpdateCompleteResponse } from 'sk/data/logic/module/message/FamilyUpdateCompleteResponse';
    import { FamilyUpdateContentRequest } from 'sk/data/logic/module/message/FamilyUpdateContentRequest';
    import { FamilyUpdateContentResponse } from 'sk/data/logic/module/message/FamilyUpdateContentResponse';
    import { FamilyUpdateDocumentRequest } from 'sk/data/logic/module/message/FamilyUpdateDocumentRequest';
    import { FamilyUpdateDocumentResponse } from 'sk/data/logic/module/message/FamilyUpdateDocumentResponse';
    import { FamilyUpdatePictureRequest } from 'sk/data/logic/module/message/FamilyUpdatePictureRequest';
    import { FamilyUpdatePictureResponse } from 'sk/data/logic/module/message/FamilyUpdatePictureResponse';
    import { FamilyUpdateRequest } from 'sk/data/logic/module/message/FamilyUpdateRequest';
    import { FamilyUpdateResponse } from 'sk/data/logic/module/message/FamilyUpdateResponse';
    import { EventController } from 'sk/service/data/logic/control/controller/EventController';
    import { EventTypeController } from 'sk/service/data/logic/control/controller/EventTypeController';
    import { ConfigDecorateItemController } from 'sk/service/data/logic/module/controller/ConfigDecorateItemController';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { FamilyTypeDto } from 'sk/service/data/logic/module/controller/FamilyTypeDto';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { MaterialFamilyController } from 'sk/service/data/logic/module/controller/MaterialFamilyController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { VariableAttributeService } from 'sk/service/data/logic/module/service/VariableAttributeService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    import { ModuleLibraryController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryController';
    import { ModuleLibraryVersionController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryVersionController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { DatasetCheckLogicService } from "sk/service/logic/warehouse/check/service/DatasetCheckLogicService";
    import { WarehouseLibraryInitializeService } from "sk/service/logic/warehouse/service/WarehouseLibraryInitializeService";
    import { FamilySymbolLogicService } from "sk/service/logic/module/symbol/service/FamilySymbolLogicService";
    import { ContainerFamilyCreateService } from "sk/service/logic/module/service/ContainerFamilyCreateService";
    import { MaterialSynchronizationService } from "sk/service/logic/module/service/MaterialSynchronizationService";
    export class ModuleFamilyRouter extends MessageRouter {
        processCode: string;
        private referenceCd;
        private _maxRecursionCount;
        protected _moduleStorageService: ModuleStorageService;
        protected _familyController: FamilyController;
        protected _familySymbolController: FamilySymbolController;
        protected _familyTypeController: FamilyTypeController;
        protected _familyCategoryController: FamilyCategoryController;
        private _featureController;
        private _attributeController;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _serviceProcessService: ServiceProcessService;
        protected _eventTypeController: EventTypeController;
        protected _eventController: EventController;
        protected _libraryController: ModuleLibraryController;
        protected _libraryVersionController: ModuleLibraryVersionController;
        protected _databaseController: WarehouseDatabaseController;
        protected _materialFamilyController: MaterialFamilyController;
        protected _materialController: MaterialController;
        protected _schemeConfigService: SchemeConfigService;
        protected _schemeDocumentService: SchemeDocumentService;
        protected _familyDocumentService: FamilyDocumentService;
        protected _calculatorService: CalculatorService;
        protected _familySymbolService: FamilySymbolLogicService;
        protected _materialSyncService: MaterialSynchronizationService;
        protected _datasetCheckService: DatasetCheckLogicService;
        protected _logicRelationService: LogicRelationService;
        protected _logicHistoryService: LogicHistoryService;
        protected _containerFamilyCreateService: ContainerFamilyCreateService;
        protected _ossService: OssConnectionService;
        protected _logicInterfaceService: LogicInterfaceService;
        protected _libraryInitializeService: WarehouseLibraryInitializeService;
        protected _variableAttrService: VariableAttributeService;
        protected _datasetLogicService: DatasetLogicService;
        protected _configDecorateItemController: ConfigDecorateItemController;
        private recursiveFilterOldCategoryDataAsync;
        private makeFamilyPageResponseDataAsync;
        private buildCategoryNamesAsync;
        private searchMaterialAsync;
        private searchProductAsync;
        private addDataPathAsync;
        private buildFamilyFeaturesListAsync;
        private buildFamilyConfigureListAsync;
        updateRelationAsync(context: MessageRouterContext, familyDto: FamilyDto, familyDocument?: FamilyDataDocument): Promise<ResultObject>;
        getFeaturesRelation(context: IContext, familyDto: FamilyDto, target?: Array<FamilyRelation>): FamilyRelation[];
        judgeCodeAsync(context: MessageRouterContext, code: string, rootCategoryId: string, categoryId: string): Promise<boolean>;
        checkCodeAsync(context: MessageRouterContext, code: string, rootCategoryId: string, categoryId: string): Promise<string>;
        pasteDoorAsync(context: MessageRouterContext, familyId: string): Promise<ResultObject<any>>;
        createRenderEventAsync(context: RouterContext, parameter: any): Promise<ResultObject>;
        private saveFeaturesToDocumentAsync;
        onFamilyBatchProcessDataRequestAsync(context: MessageRouterContext, request: FamilyBatchProcessDataRequest, response: FamilyBatchProcessDataResponse): Promise<MessageResultType>;
        onFamilyCheckRequestAsync(context: MessageRouterContext, request: FamilyCheckRequest, response: FamilyCheckResponse): Promise<MessageResultType>;
        onFamilyUpdatePictureRequestAsync(context: MessageRouterContext, request: FamilyUpdatePictureRequest, response: FamilyUpdatePictureResponse): Promise<MessageResultType>;
        onFamilyRenderRequestAsync(context: MessageRouterContext, request: FamilyRenderRequest, response: FamilyRenderResponse): Promise<MessageResultType>;
        onFamilyPublishRequestAsync(context: MessageRouterContext, request: FamilyPublishRequest, response: FamilyPublishResponse): Promise<MessageResultType>;
        onFamilyGetPublishInfoRequestAsync(context: MessageRouterContext, request: FamilyGetPublishInfoRequest, response: FamilyGetPublishInfoResponse): Promise<MessageResultType>;
        onFamilyGetCategorysRequestAsync(context: MessageRouterContext, request: FamilyGetCategorysRequest, response: FamilyGetCategorysResponse): Promise<MessageResultType>;
        onFamilyGetListRequestAsync(context: MessageRouterContext, request: FamilyGetListRequest, response: FamilyGetListResponse): Promise<MessageResultType>;
        onFamilyMoveRequestAsync(context: MessageRouterContext, request: FamilyMoveRequest, response: FamilyMoveResponse): Promise<MessageResultType>;
        onFamilyGetRequestAsync(context: MessageRouterContext, request: FamilyGetRequest, response: FamilyGetResponse): Promise<MessageResultType>;
        onFamilyGetPropertyDeclareRequestAsync(context: MessageRouterContext, request: FamilyGetPropertyDeclareRequest, response: FamilyGetPropertyDeclareResponse): Promise<MessageResultType>;
        onFamilyUpdateCompleteRequestAsync(context: MessageRouterContext, request: FamilyUpdateCompleteRequest, response: FamilyUpdateCompleteResponse): Promise<MessageResultType>;
        onFamilyUpdateRequestAsync(context: MessageRouterContext, request: FamilyUpdateRequest, response: FamilyUpdateResponse): Promise<MessageResultType>;
        onFamilyPageRequestAsync(context: MessageRouterContext, request: FamilyPageRequest, response: FamilyPageResponse): Promise<MessageResultType>;
        onFamilyGetConfigureRequestAsync(context: MessageRouterContext, request: FamilyGetConfigureRequest, response: FamilyGetConfigureResponse): Promise<MessageResultType>;
        onFamilyGetFeaturesRequestAsync(context: MessageRouterContext, request: FamilyGetFeaturesRequest, response: FamilyGetFeaturesResponse): Promise<MessageResultType>;
        onFamilyGetFeaturesvalueRequestAsync(context: MessageRouterContext, request: FamilyGetFeaturesvalueRequest, response: FamilyGetFeaturesvalueResponse): Promise<MessageResultType>;
        onFamilyDeleteRequestAsync(context: MessageRouterContext, request: FamilyDeleteRequest, response: FamilyDeleteResponse): Promise<MessageResultType>;
        onFamilySearchRequestAsync(context: MessageRouterContext, request: FamilySearchRequest, response: FamilySearchResponse): Promise<MessageResultType>;
        onFamilyInsertCompleteRequestAsync(context: MessageRouterContext, request: FamilyInsertCompleteRequest, response: FamilyInsertCompleteResponse): Promise<MessageResultType>;
        onFamilyInsertContainerCompleteRequestAsync(context: MessageRouterContext, request: FamilyInsertContainerCompleteRequest, response: FamilyInsertContainerCompleteResponse): Promise<MessageResultType>;
        onFamilyPasteRequestAsync(context: MessageRouterContext, request: FamilyPasteRequest, response: FamilyPasteResponse): Promise<MessageResultType>;
        onFamilyInsertRequestAsync(context: MessageRouterContext, request: FamilyInsertRequest, response: FamilyInsertResponse): Promise<MessageResultType>;
        onFamilyUpdateContentRequestAsync(context: MessageRouterContext, request: FamilyUpdateContentRequest, response: FamilyUpdateContentResponse): Promise<MessageResultType>;
        onFamilyChangeRequestAsync(context: MessageRouterContext, request: FamilyChangeRequest, response: FamilyChangeResponse): Promise<MessageResultType>;
        onFamilyUpdateDocumentRequestAsync(context: MessageRouterContext, request: FamilyUpdateDocumentRequest, response: FamilyUpdateDocumentResponse): Promise<MessageResultType>;
        onFamilyProcessRuleRequestAsync(context: MessageRouterContext, request: FamilyProcessRuleRequest, response: FamilyProcessRuleResponse): Promise<MessageResultType>;
        onFamilyProcessPlankMaterialRequestAsync(context: MessageRouterContext, request: FamilyProcessPlankMaterialRequest, response: FamilyProcessPlankMaterialResponse): Promise<MessageResultType>;
        onFamilyProcessTechnologyRequestAsync(context: MessageRouterContext, request: FamilyProcessTechnologyRequest, response: FamilyProcessTechnologyResponse): Promise<MessageResultType>;
        onFamilySyncFeaturesRequestAsync(context: MessageRouterContext, request: FamilySyncFeaturesRequest, response: FamilySyncFeaturesResponse): Promise<MessageResultType>;
        onFamilySyncFeaturesvalueRequestAsync(context: MessageRouterContext, request: FamilySyncFeaturesvalueRequest, response: FamilySyncFeaturesvalueResponse): Promise<MessageResultType>;
        onFamilyDoorTypeSyncRequestAsync(context: MessageRouterContext, request: FamilyDoorTypeSyncRequest, response: FamilyDoorTypeSyncResponse): Promise<MessageResultType>;
        onFamilyDoorTypeGetRequestAsync(context: MessageRouterContext, request: FamilyDoorTypeGetRequest, response: FamilyDoorTypeGetResponse): Promise<MessageResultType>;
        onFamilyDoorFilterPageRequestAsync(context: MessageRouterContext, request: FamilyDoorFilterPageRequest, response: FamilyDoorFilterPageResponse): Promise<MessageResultType>;
        protected buildSearchConditionBySearchCategoryAsync(context: MessageRouterContext, request: FamilyGetCategorysRequest): Promise<SearchCondition>;
        protected findTypeByCodeAsync(context: MessageRouterContext, code: string): Promise<FamilyTypeDto>;
        createMakePreviewEventAsync(context: MessageRouterContext, familyId: string, libraryId: string, param?: any): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyRuleRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyRuleGetRuleIdRequest } from 'sk/data/logic/module/message/FamilyRuleGetRuleIdRequest';
    import { FamilyRuleGetRuleIdResponse } from 'sk/data/logic/module/message/FamilyRuleGetRuleIdResponse';
    import { FamilyRuleGetRuleRequest } from 'sk/data/logic/module/message/FamilyRuleGetRuleRequest';
    import { FamilyRuleGetRuleResponse } from 'sk/data/logic/module/message/FamilyRuleGetRuleResponse';
    import { FamilyRuleController } from 'sk/service/data/logic/module/controller/FamilyRuleController';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    export class ModuleFamilyRuleRouter extends MessageRouter {
        processCode: string;
        protected _familyRuleController: FamilyRuleController;
        protected _ruleController: RuleController;
        onFamilyRuleGetRuleIdRequestAsync(context: MessageRouterContext, request: FamilyRuleGetRuleIdRequest, response: FamilyRuleGetRuleIdResponse): Promise<MessageResultType>;
        onFamilyRuleGetRuleRequestAsync(context: MessageRouterContext, request: FamilyRuleGetRuleRequest, response: FamilyRuleGetRuleResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilySymbolRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilySymbolGetRequest } from 'sk/data/logic/module/message/FamilySymbolGetRequest';
    import { FamilySymbolGetResponse } from 'sk/data/logic/module/message/FamilySymbolGetResponse';
    import { FamilySymbolListRequest } from 'sk/data/logic/module/message/FamilySymbolListRequest';
    import { FamilySymbolListResponse } from 'sk/data/logic/module/message/FamilySymbolListResponse';
    import { FamilySymbolPageRequest } from 'sk/data/logic/module/message/FamilySymbolPageRequest';
    import { FamilySymbolPageResponse } from 'sk/data/logic/module/message/FamilySymbolPageResponse';
    import { FamilySymbolSearchRequest } from 'sk/data/logic/module/message/FamilySymbolSearchRequest';
    import { FamilySymbolSearchResponse } from 'sk/data/logic/module/message/FamilySymbolSearchResponse';
    import { FamilySymbolSyncAllRequest } from 'sk/data/logic/module/message/FamilySymbolSyncAllRequest';
    import { FamilySymbolSyncAllResponse } from 'sk/data/logic/module/message/FamilySymbolSyncAllResponse';
    import { FamilySymbolSyncRequest } from 'sk/data/logic/module/message/FamilySymbolSyncRequest';
    import { FamilySymbolSyncResponse } from 'sk/data/logic/module/message/FamilySymbolSyncResponse';
    import { FamilySymbolUpdateIdentifyCodeRequest } from 'sk/data/logic/module/message/FamilySymbolUpdateIdentifyCodeRequest';
    import { FamilySymbolUpdateIdentifyCodeResponse } from 'sk/data/logic/module/message/FamilySymbolUpdateIdentifyCodeResponse';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { FamilySymbolLogicService } from "sk/service/logic/module/symbol/service/FamilySymbolLogicService";
    import { SymbolSynchronizationService } from "sk/service/logic/module/service/SymbolSynchronizationService";
    export class ModuleFamilySymbolRouter extends MessageRouter {
        processCode: string;
        protected _familyController: FamilyController;
        protected _familySymbolController: FamilySymbolController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _familyDocumentService: FamilyDocumentService;
        protected _symbolSyncService: SymbolSynchronizationService;
        protected _familySymbolService: FamilySymbolLogicService;
        protected _logicHistoryService: LogicHistoryService;
        private makeFamilySymbolListResponseData;
        private makeFamilySymbolPageResponseData;
        private refreshFamilySymbolUpdateIdentifyCode;
        onFamilySymbolListRequestAsync(context: MessageRouterContext, request: FamilySymbolListRequest, response: FamilySymbolListResponse): Promise<MessageResultType>;
        onFamilySymbolPageRequestAsync(context: MessageRouterContext, request: FamilySymbolPageRequest, response: FamilySymbolPageResponse): Promise<MessageResultType>;
        onFamilySymbolGetRequestAsync(context: MessageRouterContext, request: FamilySymbolGetRequest, response: FamilySymbolGetResponse): Promise<MessageResultType>;
        onFamilySymbolSyncRequestAsync(context: MessageRouterContext, request: FamilySymbolSyncRequest, response: FamilySymbolSyncResponse): Promise<MessageResultType>;
        onFamilySymbolSyncAllRequestAsync(context: MessageRouterContext, request: FamilySymbolSyncAllRequest, response: FamilySymbolSyncAllResponse): Promise<MessageResultType>;
        onFamilySymbolUpdateIdentifyCodeRequestAsync(context: MessageRouterContext, request: FamilySymbolUpdateIdentifyCodeRequest, response: FamilySymbolUpdateIdentifyCodeResponse): Promise<MessageResultType>;
        onFamilySymbolSearchRequestAsync(context: MessageRouterContext, request: FamilySymbolSearchRequest, response: FamilySymbolSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyTypeGetListRequest } from 'sk/data/logic/module/message/FamilyTypeGetListRequest';
    import { FamilyTypeGetListResponse } from 'sk/data/logic/module/message/FamilyTypeGetListResponse';
    import { FamilyTypeGetRequest } from 'sk/data/logic/module/message/FamilyTypeGetRequest';
    import { FamilyTypeGetResponse } from 'sk/data/logic/module/message/FamilyTypeGetResponse';
    import { FamilyTypeSearchRequest } from 'sk/data/logic/module/message/FamilyTypeSearchRequest';
    import { FamilyTypeSearchResponse } from 'sk/data/logic/module/message/FamilyTypeSearchResponse';
    import { FamilyTypeTreeRequest } from 'sk/data/logic/module/message/FamilyTypeTreeRequest';
    import { FamilyTypeTreeResponse, FamilyTypeTreeResponseItemsVo } from 'sk/data/logic/module/message/FamilyTypeTreeResponse';
    import { FamilyTypeUpdateContentRequest } from 'sk/data/logic/module/message/FamilyTypeUpdateContentRequest';
    import { FamilyTypeUpdateContentResponse } from 'sk/data/logic/module/message/FamilyTypeUpdateContentResponse';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { FamilyTypeDto } from 'sk/service/data/logic/module/controller/FamilyTypeDto';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleFamilyTypeRouter extends MessageRouter {
        processCode: string;
        private _units;
        protected _storageService: ModuleStorageService;
        protected _familyTypeController: FamilyTypeController;
        protected _logicHistoryService: LogicHistoryService;
        createNode(unit: FamilyTypeDto, items: StructureTypes<FamilyTypeTreeResponseItemsVo>): void;
        onFamilyTypeGetListRequestAsync(context: MessageRouterContext, request: FamilyTypeGetListRequest, response: FamilyTypeGetListResponse): Promise<MessageResultType>;
        onFamilyTypeTreeRequestAsync(context: MessageRouterContext, request: FamilyTypeTreeRequest, response: FamilyTypeTreeResponse): Promise<MessageResultType>;
        onFamilyTypeGetRequestAsync(context: MessageRouterContext, request: FamilyTypeGetRequest, response: FamilyTypeGetResponse): Promise<MessageResultType>;
        onFamilyTypeSearchRequestAsync(context: MessageRouterContext, request: FamilyTypeSearchRequest, response: FamilyTypeSearchResponse): Promise<MessageResultType>;
        onFamilyTypeUpdateContentRequestAsync(context: MessageRouterContext, request: FamilyTypeUpdateContentRequest, response: FamilyTypeUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyTypeRuleRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyTypeRuleGetRuleIdRequest } from 'sk/data/logic/module/message/FamilyTypeRuleGetRuleIdRequest';
    import { FamilyTypeRuleGetRuleIdResponse } from 'sk/data/logic/module/message/FamilyTypeRuleGetRuleIdResponse';
    import { FamilyTypeRuleGetRuleRequest } from 'sk/data/logic/module/message/FamilyTypeRuleGetRuleRequest';
    import { FamilyTypeRuleGetRuleResponse } from 'sk/data/logic/module/message/FamilyTypeRuleGetRuleResponse';
    import { FamilyTypeRuleController } from 'sk/service/data/logic/module/controller/FamilyTypeRuleController';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    export class ModuleFamilyTypeRuleRouter extends MessageRouter {
        processCode: string;
        protected _familyTypeRuleController: FamilyTypeRuleController;
        protected _ruleController: RuleController;
        onFamilyTypeRuleGetRuleIdRequestAsync(context: MessageRouterContext, request: FamilyTypeRuleGetRuleIdRequest, response: FamilyTypeRuleGetRuleIdResponse): Promise<MessageResultType>;
        onFamilyTypeRuleGetRuleRequestAsync(context: MessageRouterContext, request: FamilyTypeRuleGetRuleRequest, response: FamilyTypeRuleGetRuleResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyValuationConfigRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyValuationConfigDeleteRequest } from 'sk/data/logic/module/message/FamilyValuationConfigDeleteRequest';
    import { FamilyValuationConfigDeleteResponse } from 'sk/data/logic/module/message/FamilyValuationConfigDeleteResponse';
    import { FamilyValuationConfigGetRequest } from 'sk/data/logic/module/message/FamilyValuationConfigGetRequest';
    import { FamilyValuationConfigGetResponse } from 'sk/data/logic/module/message/FamilyValuationConfigGetResponse';
    import { FamilyValuationConfigInsertRequest } from 'sk/data/logic/module/message/FamilyValuationConfigInsertRequest';
    import { FamilyValuationConfigInsertResponse } from 'sk/data/logic/module/message/FamilyValuationConfigInsertResponse';
    import { FamilyValuationConfigPageRequest } from 'sk/data/logic/module/message/FamilyValuationConfigPageRequest';
    import { FamilyValuationConfigPageResponse } from 'sk/data/logic/module/message/FamilyValuationConfigPageResponse';
    import { FamilyValuationConfigUpdateRequest } from 'sk/data/logic/module/message/FamilyValuationConfigUpdateRequest';
    import { FamilyValuationConfigUpdateResponse } from 'sk/data/logic/module/message/FamilyValuationConfigUpdateResponse';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyValuationConfigController } from 'sk/service/data/logic/module/controller/FamilyValuationConfigController';
    import { ValuationRuleController } from 'sk/service/data/logic/module/controller/ValuationRuleController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleFamilyValuationConfigRouter extends MessageRouter {
        processCode: string;
        protected _familyValuationConfigController: FamilyValuationConfigController;
        protected _valuationRuleController: ValuationRuleController;
        protected _familyController: FamilyController;
        protected _logicHistoryService: LogicHistoryService;
        private buildCustomDataAsync;
        private makePageResponseDataAsync;
        onFamilyValuationConfigPageRequestAsync(context: MessageRouterContext, request: FamilyValuationConfigPageRequest, response: FamilyValuationConfigPageResponse): Promise<MessageResultType>;
        onFamilyValuationConfigGetRequestAsync(context: MessageRouterContext, request: FamilyValuationConfigGetRequest, response: FamilyValuationConfigGetResponse): Promise<MessageResultType>;
        onFamilyValuationConfigInsertRequestAsync(context: MessageRouterContext, request: FamilyValuationConfigInsertRequest, response: FamilyValuationConfigInsertResponse): Promise<MessageResultType>;
        onFamilyValuationConfigUpdateRequestAsync(context: MessageRouterContext, request: FamilyValuationConfigUpdateRequest, response: FamilyValuationConfigUpdateResponse): Promise<MessageResultType>;
        onFamilyValuationConfigDeleteRequestAsync(context: MessageRouterContext, request: FamilyValuationConfigDeleteRequest, response: FamilyValuationConfigDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleFamilyValuationSystemRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyValuationSystemDeleteRequest } from 'sk/data/logic/module/message/FamilyValuationSystemDeleteRequest';
    import { FamilyValuationSystemDeleteResponse } from 'sk/data/logic/module/message/FamilyValuationSystemDeleteResponse';
    import { FamilyValuationSystemGetRequest } from 'sk/data/logic/module/message/FamilyValuationSystemGetRequest';
    import { FamilyValuationSystemGetResponse } from 'sk/data/logic/module/message/FamilyValuationSystemGetResponse';
    import { FamilyValuationSystemInsertRequest } from 'sk/data/logic/module/message/FamilyValuationSystemInsertRequest';
    import { FamilyValuationSystemInsertResponse } from 'sk/data/logic/module/message/FamilyValuationSystemInsertResponse';
    import { FamilyValuationSystemPageRequest } from 'sk/data/logic/module/message/FamilyValuationSystemPageRequest';
    import { FamilyValuationSystemPageResponse } from 'sk/data/logic/module/message/FamilyValuationSystemPageResponse';
    import { FamilyValuationSystemUpdateRequest } from 'sk/data/logic/module/message/FamilyValuationSystemUpdateRequest';
    import { FamilyValuationSystemUpdateResponse } from 'sk/data/logic/module/message/FamilyValuationSystemUpdateResponse';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyValuationSystemController } from 'sk/service/data/logic/module/controller/FamilyValuationSystemController';
    import { ValuationSystemController } from 'sk/service/data/logic/module/controller/ValuationSystemController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleFamilyValuationSystemRouter extends MessageRouter {
        processCode: string;
        protected _familyValuationSystemController: FamilyValuationSystemController;
        protected _valuationSystemController: ValuationSystemController;
        protected _familyController: FamilyController;
        protected _logicHistoryService: LogicHistoryService;
        private makePageResponseDataAsync;
        onFamilyValuationSystemPageRequestAsync(context: MessageRouterContext, request: FamilyValuationSystemPageRequest, response: FamilyValuationSystemPageResponse): Promise<MessageResultType>;
        onFamilyValuationSystemGetRequestAsync(context: MessageRouterContext, request: FamilyValuationSystemGetRequest, response: FamilyValuationSystemGetResponse): Promise<MessageResultType>;
        onFamilyValuationSystemInsertRequestAsync(context: MessageRouterContext, request: FamilyValuationSystemInsertRequest, response: FamilyValuationSystemInsertResponse): Promise<MessageResultType>;
        onFamilyValuationSystemUpdateRequestAsync(context: MessageRouterContext, request: FamilyValuationSystemUpdateRequest, response: FamilyValuationSystemUpdateResponse): Promise<MessageResultType>;
        onFamilyValuationSystemDeleteRequestAsync(context: MessageRouterContext, request: FamilyValuationSystemDeleteRequest, response: FamilyValuationSystemDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleLayoutRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StructureLayoutUpdateContentRequest } from 'sk/data/logic/module/message/StructureLayoutUpdateContentRequest';
    import { StructureLayoutUpdateContentResponse } from 'sk/data/logic/module/message/StructureLayoutUpdateContentResponse';
    import { StructureController } from 'sk/service/data/logic/module/controller/StructureController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleLayoutRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ModuleStorageService;
        protected _layoutController: StructureController;
        protected _logicHistoryService: LogicHistoryService;
        onStructureLayoutUpdateContentRequestAsync(context: MessageRouterContext, request: StructureLayoutUpdateContentRequest, response: StructureLayoutUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleLibraryHistoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { LibraryHistoryPageRequest } from 'sk/data/logic/module/message/LibraryHistoryPageRequest';
    import { LibraryHistoryPageResponse } from 'sk/data/logic/module/message/LibraryHistoryPageResponse';
    export class ModuleLibraryHistoryRouter extends MessageRouter {
        processCode: string;
        private _historyController;
        onLibraryHistoryPageRequestAsync(context: MessageRouterContext, request: LibraryHistoryPageRequest, response: LibraryHistoryPageResponse): Promise<MessageResultType>;
        private makePageResponseData;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleLibraryRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { LibraryDeleteRequest } from 'sk/data/logic/module/message/LibraryDeleteRequest';
    import { LibraryDeleteResponse } from 'sk/data/logic/module/message/LibraryDeleteResponse';
    import { LibraryGetRequest } from 'sk/data/logic/module/message/LibraryGetRequest';
    import { LibraryGetResponse } from 'sk/data/logic/module/message/LibraryGetResponse';
    import { LibraryInsertRequest } from 'sk/data/logic/module/message/LibraryInsertRequest';
    import { LibraryInsertResponse } from 'sk/data/logic/module/message/LibraryInsertResponse';
    import { LibraryPageRequest } from 'sk/data/logic/module/message/LibraryPageRequest';
    import { LibraryPageResponse } from 'sk/data/logic/module/message/LibraryPageResponse';
    import { LibraryPublishRequest } from 'sk/data/logic/module/message/LibraryPublishRequest';
    import { LibraryPublishResponse } from 'sk/data/logic/module/message/LibraryPublishResponse';
    import { LibraryUpdateRequest } from 'sk/data/logic/module/message/LibraryUpdateRequest';
    import { LibraryUpdateResponse } from 'sk/data/logic/module/message/LibraryUpdateResponse';
    import { LibraryController } from 'sk/service/data/logic/module/controller/LibraryController';
    import { LibraryVersionController } from 'sk/service/data/logic/module/controller/LibraryVersionController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleLibraryRouter extends MessageRouter {
        processCode: string;
        protected _libraryVersionController: LibraryVersionController;
        protected _libraryController: LibraryController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _environmentService: EnvironmentService;
        protected _jsonService: JsonService;
        protected _logicHistoryService: LogicHistoryService;
        onLibraryPageRequestAsync(context: MessageRouterContext, request: LibraryPageRequest, response: LibraryPageResponse): Promise<MessageResultType>;
        onLibraryGetRequestAsync(context: MessageRouterContext, request: LibraryGetRequest, response: LibraryGetResponse): Promise<MessageResultType>;
        onLibraryInsertRequestAsync(context: MessageRouterContext, request: LibraryInsertRequest, response: LibraryInsertResponse): Promise<MessageResultType>;
        onLibraryUpdateRequestAsync(context: MessageRouterContext, request: LibraryUpdateRequest, response: LibraryUpdateResponse): Promise<MessageResultType>;
        onLibraryDeleteRequestAsync(context: MessageRouterContext, request: LibraryDeleteRequest, response: LibraryDeleteResponse): Promise<MessageResultType>;
        onLibraryPublishRequestAsync(context: MessageRouterContext, request: LibraryPublishRequest, response: LibraryPublishResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleLibraryVersionRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { LibraryVersionUpdateContentRequest } from 'sk/data/logic/module/message/LibraryVersionUpdateContentRequest';
    import { LibraryVersionUpdateContentResponse } from 'sk/data/logic/module/message/LibraryVersionUpdateContentResponse';
    import { LibraryController } from 'sk/service/data/logic/module/controller/LibraryController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleLibraryVersionRouter extends MessageRouter {
        processCode: string;
        protected _environmentService: EnvironmentService;
        protected _logicInterfaceService: LogicInterfaceService;
        protected _libraryController: LibraryController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _logicHistoryService: LogicHistoryService;
        onLibraryVersionUpdateContentRequestAsync(context: MessageRouterContext, request: LibraryVersionUpdateContentRequest, response: LibraryVersionUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialCategoryDeleteRequest } from 'sk/data/logic/module/message/MaterialCategoryDeleteRequest';
    import { MaterialCategoryDeleteResponse } from 'sk/data/logic/module/message/MaterialCategoryDeleteResponse';
    import { MaterialCategoryGetRequest } from 'sk/data/logic/module/message/MaterialCategoryGetRequest';
    import { MaterialCategoryGetResponse } from 'sk/data/logic/module/message/MaterialCategoryGetResponse';
    import { MaterialCategoryInsertRequest } from 'sk/data/logic/module/message/MaterialCategoryInsertRequest';
    import { MaterialCategoryInsertResponse } from 'sk/data/logic/module/message/MaterialCategoryInsertResponse';
    import { MaterialCategorySearchRequest } from 'sk/data/logic/module/message/MaterialCategorySearchRequest';
    import { MaterialCategorySearchResponse } from 'sk/data/logic/module/message/MaterialCategorySearchResponse';
    import { MaterialCategorySortRequest } from 'sk/data/logic/module/message/MaterialCategorySortRequest';
    import { MaterialCategorySortResponse } from 'sk/data/logic/module/message/MaterialCategorySortResponse';
    import { MaterialCategoryTreeRequest } from 'sk/data/logic/module/message/MaterialCategoryTreeRequest';
    import { MaterialCategoryTreeResponse } from 'sk/data/logic/module/message/MaterialCategoryTreeResponse';
    import { MaterialCategoryUpdateRequest } from 'sk/data/logic/module/message/MaterialCategoryUpdateRequest';
    import { MaterialCategoryUpdateResponse } from 'sk/data/logic/module/message/MaterialCategoryUpdateResponse';
    import { MaterialCategoryController } from 'sk/service/data/logic/module/controller/MaterialCategoryController';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleMaterialCategoryRouter extends MessageRouter {
        processCode: string;
        protected _categoryId: any;
        protected _materialCategoryController: MaterialCategoryController;
        protected _materialController: MaterialController;
        protected _logicHistoryService: LogicHistoryService;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        onMaterialCategoryInsertRequestAsync(context: MessageRouterContext, request: MaterialCategoryInsertRequest, response: MaterialCategoryInsertResponse): Promise<MessageResultType>;
        onMaterialCategoryUpdateRequestAsync(context: MessageRouterContext, request: MaterialCategoryUpdateRequest, response: MaterialCategoryUpdateResponse): Promise<MessageResultType>;
        onMaterialCategoryGetRequestAsync(context: MessageRouterContext, request: MaterialCategoryGetRequest, response: MaterialCategoryGetResponse): Promise<MessageResultType>;
        onMaterialCategorySortRequestAsync(context: MessageRouterContext, request: MaterialCategorySortRequest, response: MaterialCategorySortResponse): Promise<MessageResultType>;
        onMaterialCategoryTreeRequestAsync(context: MessageRouterContext, request: MaterialCategoryTreeRequest, response: MaterialCategoryTreeResponse): Promise<MessageResultType>;
        onMaterialCategoryDeleteRequestAsync(context: MessageRouterContext, request: MaterialCategoryDeleteRequest, response: MaterialCategoryDeleteResponse): Promise<MessageResultType>;
        onMaterialCategorySearchRequestAsync(context: MessageRouterContext, request: MaterialCategorySearchRequest, response: MaterialCategorySearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialFamilyRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialFamilyDeleteRequest } from 'sk/data/logic/module/message/MaterialFamilyDeleteRequest';
    import { MaterialFamilyDeleteResponse } from 'sk/data/logic/module/message/MaterialFamilyDeleteResponse';
    import { MaterialFamilyGetFamilyRequest } from 'sk/data/logic/module/message/MaterialFamilyGetFamilyRequest';
    import { MaterialFamilyGetFamilyResponse } from 'sk/data/logic/module/message/MaterialFamilyGetFamilyResponse';
    import { MaterialFamilyGetMaterialRequest } from 'sk/data/logic/module/message/MaterialFamilyGetMaterialRequest';
    import { MaterialFamilyGetMaterialResponse } from 'sk/data/logic/module/message/MaterialFamilyGetMaterialResponse';
    import { MaterialFamilyGetUnitRequest } from 'sk/data/logic/module/message/MaterialFamilyGetUnitRequest';
    import { MaterialFamilyGetUnitResponse } from 'sk/data/logic/module/message/MaterialFamilyGetUnitResponse';
    import { MaterialFamilyInsertRequest } from 'sk/data/logic/module/message/MaterialFamilyInsertRequest';
    import { MaterialFamilyInsertResponse } from 'sk/data/logic/module/message/MaterialFamilyInsertResponse';
    import { MaterialFamilyPageRequest } from 'sk/data/logic/module/message/MaterialFamilyPageRequest';
    import { MaterialFamilyPageResponse } from 'sk/data/logic/module/message/MaterialFamilyPageResponse';
    import { MaterialFamilySearchMaterialRequest } from 'sk/data/logic/module/message/MaterialFamilySearchMaterialRequest';
    import { MaterialFamilySearchMaterialResponse } from 'sk/data/logic/module/message/MaterialFamilySearchMaterialResponse';
    import { MaterialFamilyUpdateRequest } from 'sk/data/logic/module/message/MaterialFamilyUpdateRequest';
    import { MaterialFamilyUpdateResponse } from 'sk/data/logic/module/message/MaterialFamilyUpdateResponse';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { MaterialFamilyController } from 'sk/service/data/logic/module/controller/MaterialFamilyController';
    import { MaterialRelationController } from 'sk/service/data/logic/module/controller/MaterialRelationController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleMaterialFamilyRouter extends MessageRouter {
        processCode: string;
        protected _materialFamilyController: MaterialFamilyController;
        protected _materialController: MaterialController;
        protected _familyController: FamilyController;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _materialRelationController: MaterialRelationController;
        protected _logicHistoryService: LogicHistoryService;
        private makeMaterialFamilyPageResponseDataAsync;
        onMaterialFamilyGetFamilyRequestAsync(context: MessageRouterContext, request: MaterialFamilyGetFamilyRequest, response: MaterialFamilyGetFamilyResponse): Promise<MessageResultType>;
        onMaterialFamilyGetMaterialRequestAsync(context: MessageRouterContext, request: MaterialFamilyGetMaterialRequest, response: MaterialFamilyGetMaterialResponse): Promise<MessageResultType>;
        onMaterialFamilySearchMaterialRequestAsync(context: MessageRouterContext, request: MaterialFamilySearchMaterialRequest, response: MaterialFamilySearchMaterialResponse): Promise<MessageResultType>;
        onMaterialFamilyGetUnitRequestAsync(context: MessageRouterContext, request: MaterialFamilyGetUnitRequest, response: MaterialFamilyGetUnitResponse): Promise<MessageResultType>;
        onMaterialFamilyInsertRequestAsync(context: MessageRouterContext, request: MaterialFamilyInsertRequest, response: MaterialFamilyInsertResponse): Promise<MessageResultType>;
        onMaterialFamilyDeleteRequestAsync(context: MessageRouterContext, request: MaterialFamilyDeleteRequest, response: MaterialFamilyDeleteResponse): Promise<MessageResultType>;
        onMaterialFamilyUpdateRequestAsync(context: MessageRouterContext, request: MaterialFamilyUpdateRequest, response: MaterialFamilyUpdateResponse): Promise<MessageResultType>;
        onMaterialFamilyPageRequestAsync(context: MessageRouterContext, request: MaterialFamilyPageRequest, response: MaterialFamilyPageResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialPatternRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialPatternGetMaterialRequest } from 'sk/data/logic/module/message/MaterialPatternGetMaterialRequest';
    import { MaterialPatternGetMaterialResponse } from 'sk/data/logic/module/message/MaterialPatternGetMaterialResponse';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { MaterialPatternController } from 'sk/service/data/logic/module/controller/MaterialPatternController';
    import { MaterialRelationController } from 'sk/service/data/logic/module/controller/MaterialRelationController';
    export class ModuleMaterialPatternRouter extends MessageRouter {
        processCode: string;
        protected _materialPatternController: MaterialPatternController;
        protected _materialController: MaterialController;
        protected _materialRelationController: MaterialRelationController;
        onMaterialPatternGetMaterialRequestAsync(context: MessageRouterContext, request: MaterialPatternGetMaterialRequest, response: MaterialPatternGetMaterialResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialRelationRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialRelationDeleteRequest } from 'sk/data/logic/module/message/MaterialRelationDeleteRequest';
    import { MaterialRelationDeleteResponse } from 'sk/data/logic/module/message/MaterialRelationDeleteResponse';
    import { MaterialRelationGetRequest } from 'sk/data/logic/module/message/MaterialRelationGetRequest';
    import { MaterialRelationGetResponse } from 'sk/data/logic/module/message/MaterialRelationGetResponse';
    import { MaterialRelationInsertRequest } from 'sk/data/logic/module/message/MaterialRelationInsertRequest';
    import { MaterialRelationInsertResponse } from 'sk/data/logic/module/message/MaterialRelationInsertResponse';
    import { MaterialRelationPageRequest } from 'sk/data/logic/module/message/MaterialRelationPageRequest';
    import { MaterialRelationPageResponse } from 'sk/data/logic/module/message/MaterialRelationPageResponse';
    import { MaterialRelationUpdateRequest } from 'sk/data/logic/module/message/MaterialRelationUpdateRequest';
    import { MaterialRelationUpdateResponse } from 'sk/data/logic/module/message/MaterialRelationUpdateResponse';
    import { MaterialRelationController } from 'sk/service/data/logic/module/controller/MaterialRelationController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleMaterialRelationRouter extends MessageRouter {
        processCode: string;
        protected _materialRelationController: MaterialRelationController;
        protected _logicHistoryService: LogicHistoryService;
        private makeMaterialPageResponseDataAsync;
        onMaterialRelationGetRequestAsync(context: MessageRouterContext, request: MaterialRelationGetRequest, response: MaterialRelationGetResponse): Promise<MessageResultType>;
        onMaterialRelationInsertRequestAsync(context: MessageRouterContext, request: MaterialRelationInsertRequest, response: MaterialRelationInsertResponse): Promise<MessageResultType>;
        onMaterialRelationDeleteRequestAsync(context: MessageRouterContext, request: MaterialRelationDeleteRequest, response: MaterialRelationDeleteResponse): Promise<MessageResultType>;
        onMaterialRelationUpdateRequestAsync(context: MessageRouterContext, request: MaterialRelationUpdateRequest, response: MaterialRelationUpdateResponse): Promise<MessageResultType>;
        onMaterialRelationPageRequestAsync(context: MessageRouterContext, request: MaterialRelationPageRequest, response: MaterialRelationPageResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialDeleteRequest } from 'sk/data/logic/module/message/MaterialDeleteRequest';
    import { MaterialDeleteResponse } from 'sk/data/logic/module/message/MaterialDeleteResponse';
    import { MaterialFindRequest } from 'sk/data/logic/module/message/MaterialFindRequest';
    import { MaterialFindResponse } from 'sk/data/logic/module/message/MaterialFindResponse';
    import { MaterialGetFeaturesDeclareRequest } from 'sk/data/logic/module/message/MaterialGetFeaturesDeclareRequest';
    import { MaterialGetFeaturesDeclareResponse } from 'sk/data/logic/module/message/MaterialGetFeaturesDeclareResponse';
    import { MaterialGetRequest } from 'sk/data/logic/module/message/MaterialGetRequest';
    import { MaterialGetResponse } from 'sk/data/logic/module/message/MaterialGetResponse';
    import { MaterialInsertCompleteRequest } from 'sk/data/logic/module/message/MaterialInsertCompleteRequest';
    import { MaterialInsertCompleteResponse } from 'sk/data/logic/module/message/MaterialInsertCompleteResponse';
    import { MaterialInsertRequest } from 'sk/data/logic/module/message/MaterialInsertRequest';
    import { MaterialInsertResponse } from 'sk/data/logic/module/message/MaterialInsertResponse';
    import { MaterialListRequest } from 'sk/data/logic/module/message/MaterialListRequest';
    import { MaterialListResponse } from 'sk/data/logic/module/message/MaterialListResponse';
    import { MaterialPageRequest } from 'sk/data/logic/module/message/MaterialPageRequest';
    import { MaterialPageResponse } from 'sk/data/logic/module/message/MaterialPageResponse';
    import { MaterialUpdateRequest } from 'sk/data/logic/module/message/MaterialUpdateRequest';
    import { MaterialUpdateResponse } from 'sk/data/logic/module/message/MaterialUpdateResponse';
    import { MaterialCategoryController } from 'sk/service/data/logic/module/controller/MaterialCategoryController';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { MaterialFamilyController } from 'sk/service/data/logic/module/controller/MaterialFamilyController';
    import { MaterialRelationController } from 'sk/service/data/logic/module/controller/MaterialRelationController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleMaterialRouter extends MessageRouter {
        processCode: string;
        protected _materialController: MaterialController;
        protected _materialCategoryController: MaterialCategoryController;
        protected _materialRelationController: MaterialRelationController;
        protected _materialFamilyController: MaterialFamilyController;
        protected _logicHistoryService: LogicHistoryService;
        private makeMaterialPageResponseDataAsync;
        onMaterialInsertCompleteRequestAsync(context: MessageRouterContext, request: MaterialInsertCompleteRequest, response: MaterialInsertCompleteResponse): Promise<MessageResultType>;
        onMaterialInsertRequestAsync(context: MessageRouterContext, request: MaterialInsertRequest, response: MaterialInsertResponse): Promise<MessageResultType>;
        onMaterialUpdateRequestAsync(context: MessageRouterContext, request: MaterialUpdateRequest, response: MaterialUpdateResponse): Promise<MessageResultType>;
        onMaterialDeleteRequestAsync(context: MessageRouterContext, request: MaterialDeleteRequest, response: MaterialDeleteResponse): Promise<MessageResultType>;
        onMaterialFindRequestAsync(context: MessageRouterContext, request: MaterialFindRequest, response: MaterialFindResponse): Promise<MessageResultType>;
        onMaterialGetRequestAsync(context: MessageRouterContext, request: MaterialGetRequest, response: MaterialGetResponse): Promise<MessageResultType>;
        onMaterialPageRequestAsync(context: MessageRouterContext, request: MaterialPageRequest, response: MaterialPageResponse): Promise<MessageResultType>;
        onMaterialListRequestAsync(context: MessageRouterContext, request: MaterialListRequest, response: MaterialListResponse): Promise<MessageResultType>;
        onMaterialGetFeaturesDeclareRequestAsync(context: MessageRouterContext, request: MaterialGetFeaturesDeclareRequest, response: MaterialGetFeaturesDeclareResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialRuleRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialRuleGetMeteringRuleRequest } from 'sk/data/logic/module/message/MaterialRuleGetMeteringRuleRequest';
    import { MaterialRuleGetMeteringRuleResponse } from 'sk/data/logic/module/message/MaterialRuleGetMeteringRuleResponse';
    import { MaterialRuleGetRuleRequest } from 'sk/data/logic/module/message/MaterialRuleGetRuleRequest';
    import { MaterialRuleGetRuleResponse } from 'sk/data/logic/module/message/MaterialRuleGetRuleResponse';
    import { MaterialRuleInsertRequest } from 'sk/data/logic/module/message/MaterialRuleInsertRequest';
    import { MaterialRuleInsertResponse } from 'sk/data/logic/module/message/MaterialRuleInsertResponse';
    import { MaterialRuleSearchRequest } from 'sk/data/logic/module/message/MaterialRuleSearchRequest';
    import { MaterialRuleSearchResponse } from 'sk/data/logic/module/message/MaterialRuleSearchResponse';
    import { MaterialRuleUpdateRequest } from 'sk/data/logic/module/message/MaterialRuleUpdateRequest';
    import { MaterialRuleUpdateResponse } from 'sk/data/logic/module/message/MaterialRuleUpdateResponse';
    import { MaterialMeteringTypeController } from 'sk/service/data/logic/module/controller/MaterialMeteringTypeController';
    import { MaterialRuleController } from 'sk/service/data/logic/module/controller/MaterialRuleController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleMaterialRuleRouter extends MessageRouter {
        processCode: string;
        protected _materialRuleController: MaterialRuleController;
        protected _meteringTypeController: MaterialMeteringTypeController;
        protected _logicHistoryService: LogicHistoryService;
        onMaterialRuleGetRuleRequestAsync(context: MessageRouterContext, request: MaterialRuleGetRuleRequest, response: MaterialRuleGetRuleResponse): Promise<MessageResultType>;
        onMaterialRuleGetMeteringRuleRequestAsync(context: MessageRouterContext, request: MaterialRuleGetMeteringRuleRequest, response: MaterialRuleGetMeteringRuleResponse): Promise<MessageResultType>;
        onMaterialRuleInsertRequestAsync(context: MessageRouterContext, request: MaterialRuleInsertRequest, response: MaterialRuleInsertResponse): Promise<MessageResultType>;
        onMaterialRuleUpdateRequestAsync(context: MessageRouterContext, request: MaterialRuleUpdateRequest, response: MaterialRuleUpdateResponse): Promise<MessageResultType>;
        onMaterialRuleSearchRequestAsync(context: MessageRouterContext, request: MaterialRuleSearchRequest, response: MaterialRuleSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialTypeGetListRequest } from 'sk/data/logic/module/message/MaterialTypeGetListRequest';
    import { MaterialTypeGetListResponse } from 'sk/data/logic/module/message/MaterialTypeGetListResponse';
    import { MaterialTypeSearchRequest } from 'sk/data/logic/module/message/MaterialTypeSearchRequest';
    import { MaterialTypeSearchResponse } from 'sk/data/logic/module/message/MaterialTypeSearchResponse';
    import { MaterialTypeController } from 'sk/service/data/logic/module/controller/MaterialTypeController';
    export class ModuleMaterialTypeRouter extends MessageRouter {
        processCode: string;
        protected _materialCategoryController: MaterialTypeController;
        onMaterialTypeGetListRequestAsync(context: MessageRouterContext, request: MaterialTypeGetListRequest, response: MaterialTypeGetListResponse): Promise<MessageResultType>;
        onMaterialTypeSearchRequestAsync(context: MessageRouterContext, request: MaterialTypeSearchRequest, response: MaterialTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleMaterialTypeRuleRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MaterialTypeRuleGetRuleRequest } from 'sk/data/logic/module/message/MaterialTypeRuleGetRuleRequest';
    import { MaterialTypeRuleGetRuleResponse } from 'sk/data/logic/module/message/MaterialTypeRuleGetRuleResponse';
    import { MaterialTypeRuleController } from 'sk/service/data/logic/module/controller/MaterialTypeRuleController';
    export class ModuleMaterialTypeRuleRouter extends MessageRouter {
        processCode: string;
        protected _materialTypeRuleController: MaterialTypeRuleController;
        onMaterialTypeRuleGetRuleRequestAsync(context: MessageRouterContext, request: MaterialTypeRuleGetRuleRequest, response: MaterialTypeRuleGetRuleResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModulePatternCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternCategoryDeleteRequest } from 'sk/data/logic/module/message/PatternCategoryDeleteRequest';
    import { PatternCategoryDeleteResponse } from 'sk/data/logic/module/message/PatternCategoryDeleteResponse';
    import { PatternCategoryGetRequest } from 'sk/data/logic/module/message/PatternCategoryGetRequest';
    import { PatternCategoryGetResponse } from 'sk/data/logic/module/message/PatternCategoryGetResponse';
    import { PatternCategoryInsertRequest } from 'sk/data/logic/module/message/PatternCategoryInsertRequest';
    import { PatternCategoryInsertResponse } from 'sk/data/logic/module/message/PatternCategoryInsertResponse';
    import { PatternCategorySearchRequest } from 'sk/data/logic/module/message/PatternCategorySearchRequest';
    import { PatternCategorySearchResponse } from 'sk/data/logic/module/message/PatternCategorySearchResponse';
    import { PatternCategorySortRequest } from 'sk/data/logic/module/message/PatternCategorySortRequest';
    import { PatternCategorySortResponse } from 'sk/data/logic/module/message/PatternCategorySortResponse';
    import { PatternCategoryTreeRequest } from 'sk/data/logic/module/message/PatternCategoryTreeRequest';
    import { PatternCategoryTreeResponse } from 'sk/data/logic/module/message/PatternCategoryTreeResponse';
    import { PatternCategoryUpdateRequest } from 'sk/data/logic/module/message/PatternCategoryUpdateRequest';
    import { PatternCategoryUpdateResponse } from 'sk/data/logic/module/message/PatternCategoryUpdateResponse';
    import { PatternCategoryController } from 'sk/service/data/logic/module/controller/PatternCategoryController';
    import { PatternController } from 'sk/service/data/logic/module/controller/PatternController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModulePatternCategoryRouter extends MessageRouter {
        processCode: string;
        private _categoryId;
        protected _patternCategoryController: PatternCategoryController;
        protected _patternController: PatternController;
        protected _logicHistoryService: LogicHistoryService;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        onPatternCategoryInsertRequestAsync(context: MessageRouterContext, request: PatternCategoryInsertRequest, response: PatternCategoryInsertResponse): Promise<MessageResultType>;
        onPatternCategoryUpdateRequestAsync(context: MessageRouterContext, request: PatternCategoryUpdateRequest, response: PatternCategoryUpdateResponse): Promise<MessageResultType>;
        onPatternCategorySortRequestAsync(context: MessageRouterContext, request: PatternCategorySortRequest, response: PatternCategorySortResponse): Promise<MessageResultType>;
        onPatternCategoryGetRequestAsync(context: MessageRouterContext, request: PatternCategoryGetRequest, response: PatternCategoryGetResponse): Promise<MessageResultType>;
        onPatternCategoryTreeRequestAsync(context: MessageRouterContext, request: PatternCategoryTreeRequest, response: PatternCategoryTreeResponse): Promise<MessageResultType>;
        onPatternCategoryDeleteRequestAsync(context: MessageRouterContext, request: PatternCategoryDeleteRequest, response: PatternCategoryDeleteResponse): Promise<MessageResultType>;
        onPatternCategorySearchRequestAsync(context: MessageRouterContext, request: PatternCategorySearchRequest, response: PatternCategorySearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModulePatternInfoRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PublishPatternInfoGetBySymbolIdRequest } from 'sk/data/logic/module/message/PublishPatternInfoGetBySymbolIdRequest';
    import { PublishPatternInfoGetBySymbolIdResponse } from 'sk/data/logic/module/message/PublishPatternInfoGetBySymbolIdResponse';
    import { PublishPatternInfoGetRequest } from 'sk/data/logic/module/message/PublishPatternInfoGetRequest';
    import { PublishPatternInfoGetResponse } from 'sk/data/logic/module/message/PublishPatternInfoGetResponse';
    import { PublishPatternInfoListRequest } from 'sk/data/logic/module/message/PublishPatternInfoListRequest';
    import { PublishPatternInfoListResponse } from 'sk/data/logic/module/message/PublishPatternInfoListResponse';
    import { PublishPatternInfoPatternRequest } from 'sk/data/logic/module/message/PublishPatternInfoPatternRequest';
    import { PublishPatternInfoPatternResponse } from 'sk/data/logic/module/message/PublishPatternInfoPatternResponse';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    export class ModulePatternInfoRouter extends MessageRouter {
        processCode: string;
        private _patternController;
        private _patternInfoController;
        private _patternTypeController;
        private _patternCategoryController;
        protected _productSymbolController: ProductSymbolController;
        onPublishPatternInfoListRequestAsync(context: MessageRouterContext, request: PublishPatternInfoListRequest, response: PublishPatternInfoListResponse): Promise<MessageResultType>;
        onPublishPatternInfoGetRequestAsync(context: MessageRouterContext, request: PublishPatternInfoGetRequest, response: PublishPatternInfoGetResponse): Promise<MessageResultType>;
        onPublishPatternInfoGetBySymbolIdRequestAsync(context: MessageRouterContext, request: PublishPatternInfoGetBySymbolIdRequest, response: PublishPatternInfoGetBySymbolIdResponse): Promise<MessageResultType>;
        onPublishPatternInfoPatternRequestAsync(context: MessageRouterContext, request: PublishPatternInfoPatternRequest, response: PublishPatternInfoPatternResponse): Promise<MessageResultType>;
        private buildGetResponseDataAsync;
        private buildListResponseVoAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModulePatternRoomRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternDataDocument } from 'sk/data/family/pattern/PatternDataDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { PatternRoomDeleteBathroomRequest } from 'sk/data/logic/module/message/PatternRoomDeleteBathroomRequest';
    import { PatternRoomDeleteBathroomResponse } from 'sk/data/logic/module/message/PatternRoomDeleteBathroomResponse';
    import { PatternRoomDeleteRequest } from 'sk/data/logic/module/message/PatternRoomDeleteRequest';
    import { PatternRoomDeleteResponse } from 'sk/data/logic/module/message/PatternRoomDeleteResponse';
    import { PatternRoomInsertBathroomRequest } from 'sk/data/logic/module/message/PatternRoomInsertBathroomRequest';
    import { PatternRoomInsertBathroomResponse } from 'sk/data/logic/module/message/PatternRoomInsertBathroomResponse';
    import { PatternRoomInsertRequest } from 'sk/data/logic/module/message/PatternRoomInsertRequest';
    import { PatternRoomInsertResponse } from 'sk/data/logic/module/message/PatternRoomInsertResponse';
    import { PatternRoomUpdateBathroomRequest } from 'sk/data/logic/module/message/PatternRoomUpdateBathroomRequest';
    import { PatternRoomUpdateBathroomResponse } from 'sk/data/logic/module/message/PatternRoomUpdateBathroomResponse';
    import { PatternRoomUpdateRequest } from 'sk/data/logic/module/message/PatternRoomUpdateRequest';
    import { PatternRoomUpdateResponse } from 'sk/data/logic/module/message/PatternRoomUpdateResponse';
    import { PatternController } from 'sk/service/data/logic/module/controller/PatternController';
    import { PatternDto } from 'sk/service/data/logic/module/controller/PatternDto';
    import { PatternSymbolController } from 'sk/service/data/logic/module/controller/PatternSymbolController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { PublishPatternInfoController } from 'sk/service/data/logic/module/controller/PublishPatternInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    import { SymbolSynchronizationService } from "sk/service/logic/module/service/SymbolSynchronizationService";
    export class ModulePatternRoomRouter extends MessageRouter {
        processCode: string;
        protected _patternController: PatternController;
        protected _moduleStorageService: ModuleStorageService;
        protected _symbolSyncService: SymbolSynchronizationService;
        protected _patternSymbolController: PatternSymbolController;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _patternInfoController: PublishPatternInfoController;
        protected _patternDocumentService: PatternDocumentService;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        updateRelationAsync(context: MessageRouterContext, patternDocument: PatternDataDocument, patternDto: PatternDto): Promise<ResultObject>;
        onPatternRoomUpdateBathroomRequestAsync(context: MessageRouterContext, request: PatternRoomUpdateBathroomRequest, response: PatternRoomUpdateBathroomResponse): Promise<MessageResultType>;
        onPatternRoomUpdateRequestAsync(context: MessageRouterContext, request: PatternRoomUpdateRequest, response: PatternRoomUpdateResponse): Promise<MessageResultType>;
        onPatternRoomInsertBathroomRequestAsync(context: MessageRouterContext, request: PatternRoomInsertBathroomRequest, response: PatternRoomInsertBathroomResponse): Promise<MessageResultType>;
        onPatternRoomInsertRequestAsync(context: MessageRouterContext, request: PatternRoomInsertRequest, response: PatternRoomInsertResponse): Promise<MessageResultType>;
        onPatternRoomDeleteBathroomRequestAsync(context: MessageRouterContext, request: PatternRoomDeleteBathroomRequest, response: PatternRoomDeleteBathroomResponse): Promise<MessageResultType>;
        onPatternRoomDeleteRequestAsync(context: MessageRouterContext, request: PatternRoomDeleteRequest, response: PatternRoomDeleteResponse): Promise<MessageResultType>;
        private buildSymbolsAsync;
        private buildFamilySymbolDto;
        private refreshFamilySymbolUpdateIdentifyCode;
        private updateSymbolsAsync;
        private buildProductSymbolListAsync;
        private getProductSymbolListAsync;
        private deleteSymbolRecordAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/symbol/service/PatternSymbolLogicService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternDataDocument } from 'sk/data/family/pattern/PatternDataDocument';
    import { PatternDto } from 'sk/service/data/logic/module/controller/PatternDto';
    import { PatternSymbolController } from 'sk/service/data/logic/module/controller/PatternSymbolController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { PublishPatternInfoController } from 'sk/service/data/logic/module/controller/PublishPatternInfoController';
    import { SymbolSynchronizationService } from "sk/service/logic/module/service/SymbolSynchronizationService";
    export class PatternSymbolLogicService extends Service {
        protected _symbolSynchService: SymbolSynchronizationService;
        protected _patternSymbolController: PatternSymbolController;
        protected _productSymbolController: ProductSymbolController;
        protected _productController: ProductController;
        protected _patternInfoController: PublishPatternInfoController;
        buildSymbolsAsync(context: MessageRouterContext, patternDoc: PatternDataDocument, patternDto: PatternDto): Promise<ResultObject>;
        private buildPatternSymbolDto;
        private refreshPatternSymbolUpdateIdentifyCode;
        private buildProductSymbolListAsync;
        private getProductSymbolListAsync;
        private deleteSymbolRecordAsync;
    }
}
declare module "sk/service/logic/module/router/ModulePatternRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternDataDocument } from 'sk/data/family/pattern/PatternDataDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { PatternCheckRequest } from 'sk/data/logic/module/message/PatternCheckRequest';
    import { PatternCheckResponse } from 'sk/data/logic/module/message/PatternCheckResponse';
    import { PatternDeleteRequest } from 'sk/data/logic/module/message/PatternDeleteRequest';
    import { PatternDeleteResponse } from 'sk/data/logic/module/message/PatternDeleteResponse';
    import { PatternGetRequest } from 'sk/data/logic/module/message/PatternGetRequest';
    import { PatternGetResponse } from 'sk/data/logic/module/message/PatternGetResponse';
    import { PatternInsertCompleteRequest } from 'sk/data/logic/module/message/PatternInsertCompleteRequest';
    import { PatternInsertCompleteResponse } from 'sk/data/logic/module/message/PatternInsertCompleteResponse';
    import { PatternInsertRequest } from 'sk/data/logic/module/message/PatternInsertRequest';
    import { PatternInsertResponse } from 'sk/data/logic/module/message/PatternInsertResponse';
    import { PatternPageRequest } from 'sk/data/logic/module/message/PatternPageRequest';
    import { PatternPageResponse } from 'sk/data/logic/module/message/PatternPageResponse';
    import { PatternPasteRequest } from 'sk/data/logic/module/message/PatternPasteRequest';
    import { PatternPasteResponse } from 'sk/data/logic/module/message/PatternPasteResponse';
    import { PatternPublishRequest } from 'sk/data/logic/module/message/PatternPublishRequest';
    import { PatternPublishResponse } from 'sk/data/logic/module/message/PatternPublishResponse';
    import { PatternSearchRequest } from 'sk/data/logic/module/message/PatternSearchRequest';
    import { PatternSearchResponse } from 'sk/data/logic/module/message/PatternSearchResponse';
    import { PatternUpdateCompleteRequest } from 'sk/data/logic/module/message/PatternUpdateCompleteRequest';
    import { PatternUpdateCompleteResponse } from 'sk/data/logic/module/message/PatternUpdateCompleteResponse';
    import { PatternUpdateContentRequest } from 'sk/data/logic/module/message/PatternUpdateContentRequest';
    import { PatternUpdateContentResponse } from 'sk/data/logic/module/message/PatternUpdateContentResponse';
    import { PatternUpdateRequest } from 'sk/data/logic/module/message/PatternUpdateRequest';
    import { PatternUpdateResponse } from 'sk/data/logic/module/message/PatternUpdateResponse';
    import { PatternCategoryController } from 'sk/service/data/logic/module/controller/PatternCategoryController';
    import { PatternController } from 'sk/service/data/logic/module/controller/PatternController';
    import { PatternDto } from 'sk/service/data/logic/module/controller/PatternDto';
    import { PublishPatternInfoController } from 'sk/service/data/logic/module/controller/PublishPatternInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    import { DatasetCheckLogicService } from "sk/service/logic/warehouse/check/service/DatasetCheckLogicService";
    import { PatternSymbolLogicService } from "sk/service/logic/module/symbol/service/PatternSymbolLogicService";
    export class ModulePatternRouter extends MessageRouter {
        processCode: string;
        protected _patternController: PatternController;
        protected _moduleStorageService: ModuleStorageService;
        protected _datasetCheckService: DatasetCheckLogicService;
        protected _patternCategoryController: PatternCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        protected _patternDocumentService: PatternDocumentService;
        protected _publishPatternInfoController: PublishPatternInfoController;
        protected _patternSymbolService: PatternSymbolLogicService;
        onPatternUpdateContentRequestAsync(context: MessageRouterContext, request: PatternUpdateContentRequest, response: PatternUpdateContentResponse): Promise<MessageResultType>;
        onPatternCheckRequestAsync(context: MessageRouterContext, request: PatternCheckRequest, response: PatternCheckResponse): Promise<MessageResultType>;
        onPatternGetRequestAsync(context: MessageRouterContext, request: PatternGetRequest, response: PatternGetResponse): Promise<MessageResultType>;
        onPatternPageRequestAsync(context: MessageRouterContext, request: PatternPageRequest, response: PatternPageResponse): Promise<MessageResultType>;
        onPatternSearchRequestAsync(context: MessageRouterContext, request: PatternSearchRequest, response: PatternSearchResponse): Promise<MessageResultType>;
        onPatternUpdateCompleteRequestAsync(context: MessageRouterContext, request: PatternUpdateCompleteRequest, response: PatternUpdateCompleteResponse): Promise<MessageResultType>;
        onPatternUpdateRequestAsync(context: MessageRouterContext, request: PatternUpdateRequest, response: PatternUpdateResponse): Promise<MessageResultType>;
        onPatternDeleteRequestAsync(context: MessageRouterContext, request: PatternDeleteRequest, response: PatternDeleteResponse): Promise<MessageResultType>;
        onPatternInsertCompleteRequestAsync(context: MessageRouterContext, request: PatternInsertCompleteRequest, response: PatternInsertCompleteResponse): Promise<MessageResultType>;
        onPatternPasteRequestAsync(context: MessageRouterContext, request: PatternPasteRequest, response: PatternPasteResponse): Promise<MessageResultType>;
        onPatternInsertRequestAsync(context: MessageRouterContext, request: PatternInsertRequest, response: PatternInsertResponse): Promise<MessageResultType>;
        onPatternPublishRequestAsync(context: MessageRouterContext, request: PatternPublishRequest, response: PatternPublishResponse): Promise<MessageResultType>;
        private makePatternPageResponseDataAsync;
        checkCodeAsync(context: MessageRouterContext, code: string, rootCategoryId: string, categoryId: string): Promise<string>;
        judgeCodeAsync(context: MessageRouterContext, code: string, rootCategoryId: string, categoryId: string): Promise<boolean>;
        updateRelationAsync(context: MessageRouterContext, patternDto: PatternDto, patternDocument?: PatternDataDocument): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModulePatternSymbolRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { PatternSymbolListRequest } from 'sk/data/logic/module/message/PatternSymbolListRequest';
    import { PatternSymbolListResponse } from 'sk/data/logic/module/message/PatternSymbolListResponse';
    import { PatternSymbolPageRequest } from 'sk/data/logic/module/message/PatternSymbolPageRequest';
    import { PatternSymbolPageResponse } from 'sk/data/logic/module/message/PatternSymbolPageResponse';
    import { PatternSymbolSyncRequest } from 'sk/data/logic/module/message/PatternSymbolSyncRequest';
    import { PatternSymbolSyncResponse } from 'sk/data/logic/module/message/PatternSymbolSyncResponse';
    import { PatternController } from 'sk/service/data/logic/module/controller/PatternController';
    import { PatternSymbolController } from 'sk/service/data/logic/module/controller/PatternSymbolController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { PublishPatternInfoController } from 'sk/service/data/logic/module/controller/PublishPatternInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { PatternSymbolLogicService } from "sk/service/logic/module/symbol/service/PatternSymbolLogicService";
    import { SymbolSynchronizationService } from "sk/service/logic/module/service/SymbolSynchronizationService";
    export class ModulePatternSymbolRouter extends MessageRouter {
        processCode: string;
        protected _patternController: PatternController;
        protected _patternSymbolController: PatternSymbolController;
        protected _patternInfoController: PublishPatternInfoController;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _patternDocumentService: PatternDocumentService;
        protected _symbolSynchService: SymbolSynchronizationService;
        protected _logicHistoryService: LogicHistoryService;
        protected _patternSymbolService: PatternSymbolLogicService;
        private buildPatternSymbolDto;
        private buildProductSymbolListAsync;
        private getProductSymbolListAsync;
        private buildSymbolsAsync;
        private deleteSymbolRecordAsync;
        private refreshPatternSymbolUpdateIdentifyCode;
        private makePatternSymbolListResponseData;
        onPatternSymbolListRequestAsync(context: MessageRouterContext, request: PatternSymbolListRequest, response: PatternSymbolListResponse): Promise<MessageResultType>;
        onPatternSymbolPageRequestAsync(context: MessageRouterContext, request: PatternSymbolPageRequest, response: PatternSymbolPageResponse): Promise<MessageResultType>;
        onPatternSymbolSyncRequestAsync(context: MessageRouterContext, request: PatternSymbolSyncRequest, response: PatternSymbolSyncResponse): Promise<MessageResultType>;
        private makePatternSymbolPageResponseData;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModulePatternTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternTypeGetRequest } from 'sk/data/logic/module/message/PatternTypeGetRequest';
    import { PatternTypeGetResponse } from 'sk/data/logic/module/message/PatternTypeGetResponse';
    import { PatternTypeSearchRequest } from 'sk/data/logic/module/message/PatternTypeSearchRequest';
    import { PatternTypeSearchResponse } from 'sk/data/logic/module/message/PatternTypeSearchResponse';
    import { PatternTypeController } from 'sk/service/data/logic/module/controller/PatternTypeController';
    export class ModulePatternTypeRouter extends MessageRouter {
        processCode: string;
        protected _patternTypeController: PatternTypeController;
        onPatternTypeGetRequestAsync(context: MessageRouterContext, request: PatternTypeGetRequest, response: PatternTypeGetResponse): Promise<MessageResultType>;
        onPatternTypeSearchRequestAsync(context: MessageRouterContext, request: PatternTypeSearchRequest, response: PatternTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModulePatternTypeRuleRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternTypeRuleGetRuleRequest } from 'sk/data/logic/module/message/PatternTypeRuleGetRuleRequest';
    import { PatternTypeRuleGetRuleResponse } from 'sk/data/logic/module/message/PatternTypeRuleGetRuleResponse';
    import { PatternTypeRuleController } from 'sk/service/data/logic/module/controller/PatternTypeRuleController';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    export class ModulePatternTypeRuleRouter extends MessageRouter {
        processCode: string;
        protected _patternTypeRuleController: PatternTypeRuleController;
        protected _ruleController: RuleController;
        onPatternTypeRuleGetRuleRequestAsync(context: MessageRouterContext, request: PatternTypeRuleGetRuleRequest, response: PatternTypeRuleGetRuleResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleProductSymbolRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductSymbolDeleteRequest } from 'sk/data/logic/module/message/ProductSymbolDeleteRequest';
    import { ProductSymbolDeleteResponse } from 'sk/data/logic/module/message/ProductSymbolDeleteResponse';
    import { ProductSymbolGetRequest } from 'sk/data/logic/module/message/ProductSymbolGetRequest';
    import { ProductSymbolGetResponse } from 'sk/data/logic/module/message/ProductSymbolGetResponse';
    import { ProductSymbolInfoListRequest } from 'sk/data/logic/module/message/ProductSymbolInfoListRequest';
    import { ProductSymbolInfoListResponse } from 'sk/data/logic/module/message/ProductSymbolInfoListResponse';
    import { ProductSymbolInsertRequest } from 'sk/data/logic/module/message/ProductSymbolInsertRequest';
    import { ProductSymbolInsertResponse } from 'sk/data/logic/module/message/ProductSymbolInsertResponse';
    import { ProductSymbolListRequest } from 'sk/data/logic/module/message/ProductSymbolListRequest';
    import { ProductSymbolListResponse } from 'sk/data/logic/module/message/ProductSymbolListResponse';
    import { ProductSymbolPageRequest } from 'sk/data/logic/module/message/ProductSymbolPageRequest';
    import { ProductSymbolPageResponse } from 'sk/data/logic/module/message/ProductSymbolPageResponse';
    import { ProductSymbolUpdateRequest } from 'sk/data/logic/module/message/ProductSymbolUpdateRequest';
    import { ProductSymbolUpdateResponse } from 'sk/data/logic/module/message/ProductSymbolUpdateResponse';
    import { ProductCategoryController } from 'sk/service/data/logic/module/controller/ProductCategoryController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { CodeController } from 'sk/service/data/logic/system/controller/CodeController';
    export class ModuleProductSymbolRouter extends MessageRouter {
        processCode: string;
        private readonly _unitTypeCodes;
        protected _logicHistoryService: LogicHistoryService;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _productCategoryController: ProductCategoryController;
        protected _codeController: CodeController;
        private makeProductSymbolPageResponseDataAsync;
        private buildProductPageResponseContentVoAsync;
        onProductSymbolListRequestAsync(context: MessageRouterContext, request: ProductSymbolListRequest, response: ProductSymbolListResponse): Promise<MessageResultType>;
        onProductSymbolInfoListRequestAsync(context: MessageRouterContext, request: ProductSymbolInfoListRequest, response: ProductSymbolInfoListResponse): Promise<MessageResultType>;
        onProductSymbolPageRequestAsync(context: MessageRouterContext, request: ProductSymbolPageRequest, response: ProductSymbolPageResponse): Promise<MessageResultType>;
        onProductSymbolGetRequestAsync(context: MessageRouterContext, request: ProductSymbolGetRequest, response: ProductSymbolGetResponse): Promise<MessageResultType>;
        onProductSymbolInsertRequestAsync(context: MessageRouterContext, request: ProductSymbolInsertRequest, response: ProductSymbolInsertResponse): Promise<MessageResultType>;
        onProductSymbolUpdateRequestAsync(context: MessageRouterContext, request: ProductSymbolUpdateRequest, response: ProductSymbolUpdateResponse): Promise<MessageResultType>;
        onProductSymbolDeleteRequestAsync(context: MessageRouterContext, request: ProductSymbolDeleteRequest, response: ProductSymbolDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleProfileRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StructureProfileUpdateContentRequest } from 'sk/data/logic/module/message/StructureProfileUpdateContentRequest';
    import { StructureProfileUpdateContentResponse } from 'sk/data/logic/module/message/StructureProfileUpdateContentResponse';
    import { StructureController } from 'sk/service/data/logic/module/controller/StructureController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleProfileRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ModuleStorageService;
        protected _profileController: StructureController;
        protected _logicHistoryService: LogicHistoryService;
        onStructureProfileUpdateContentRequestAsync(context: MessageRouterContext, request: StructureProfileUpdateContentRequest, response: StructureProfileUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleRelationRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { RelationGetMasterRequest } from 'sk/data/logic/module/message/RelationGetMasterRequest';
    import { RelationGetMasterResponse } from 'sk/data/logic/module/message/RelationGetMasterResponse';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    export class ModuleRelationRouter extends MessageRouter {
        processCode: string;
        protected _logicRelationService: LogicRelationService;
        onRelationGetMasterRequestAsync(context: MessageRouterContext, request: RelationGetMasterRequest, response: RelationGetMasterResponse): Promise<MessageResultType>;
        private buildResponse;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleRuleCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { RuleCategoryDeleteRequest } from 'sk/data/logic/module/message/RuleCategoryDeleteRequest';
    import { RuleCategoryDeleteResponse } from 'sk/data/logic/module/message/RuleCategoryDeleteResponse';
    import { RuleCategoryGetRequest } from 'sk/data/logic/module/message/RuleCategoryGetRequest';
    import { RuleCategoryGetResponse } from 'sk/data/logic/module/message/RuleCategoryGetResponse';
    import { RuleCategoryInsertRequest } from 'sk/data/logic/module/message/RuleCategoryInsertRequest';
    import { RuleCategoryInsertResponse } from 'sk/data/logic/module/message/RuleCategoryInsertResponse';
    import { RuleCategorySearchRequest } from 'sk/data/logic/module/message/RuleCategorySearchRequest';
    import { RuleCategorySearchResponse } from 'sk/data/logic/module/message/RuleCategorySearchResponse';
    import { RuleCategorySortRequest } from 'sk/data/logic/module/message/RuleCategorySortRequest';
    import { RuleCategorySortResponse } from 'sk/data/logic/module/message/RuleCategorySortResponse';
    import { RuleCategoryTreeRequest } from 'sk/data/logic/module/message/RuleCategoryTreeRequest';
    import { RuleCategoryTreeResponse } from 'sk/data/logic/module/message/RuleCategoryTreeResponse';
    import { RuleCategoryUpdateRequest } from 'sk/data/logic/module/message/RuleCategoryUpdateRequest';
    import { RuleCategoryUpdateResponse } from 'sk/data/logic/module/message/RuleCategoryUpdateResponse';
    import { RuleCategoryController } from 'sk/service/data/logic/module/controller/RuleCategoryController';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleRuleCategoryRouter extends MessageRouter {
        processCode: string;
        private _categoryId;
        protected _ruleCategoryController: RuleCategoryController;
        protected _ruleController: RuleController;
        protected _logicHistoryService: LogicHistoryService;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        onRuleCategoryGetRequestAsync(context: MessageRouterContext, request: RuleCategoryGetRequest, response: RuleCategoryGetResponse): Promise<MessageResultType>;
        onRuleCategoryInsertRequestAsync(context: MessageRouterContext, request: RuleCategoryInsertRequest, response: RuleCategoryInsertResponse): Promise<MessageResultType>;
        onRuleCategorySortRequestAsync(context: MessageRouterContext, request: RuleCategorySortRequest, response: RuleCategorySortResponse): Promise<MessageResultType>;
        onRuleCategoryUpdateRequestAsync(context: MessageRouterContext, request: RuleCategoryUpdateRequest, response: RuleCategoryUpdateResponse): Promise<MessageResultType>;
        onRuleCategoryTreeRequestAsync(context: MessageRouterContext, request: RuleCategoryTreeRequest, response: RuleCategoryTreeResponse): Promise<MessageResultType>;
        onRuleCategoryDeleteRequestAsync(context: MessageRouterContext, request: RuleCategoryDeleteRequest, response: RuleCategoryDeleteResponse): Promise<MessageResultType>;
        onRuleCategorySearchRequestAsync(context: MessageRouterContext, request: RuleCategorySearchRequest, response: RuleCategorySearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleRuleConfigRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { RuleConfigGetRequest } from 'sk/data/logic/module/message/RuleConfigGetRequest';
    import { RuleConfigGetResponse } from 'sk/data/logic/module/message/RuleConfigGetResponse';
    import { RuleConfigPageRequest } from 'sk/data/logic/module/message/RuleConfigPageRequest';
    import { RuleConfigPageResponse } from 'sk/data/logic/module/message/RuleConfigPageResponse';
    import { RuleConfigUpdateContentRequest } from 'sk/data/logic/module/message/RuleConfigUpdateContentRequest';
    import { RuleConfigUpdateContentResponse } from 'sk/data/logic/module/message/RuleConfigUpdateContentResponse';
    import { RuleConfigController } from 'sk/service/data/logic/module/controller/RuleConfigController';
    import { RuleConfigTypeController } from 'sk/service/data/logic/module/controller/RuleConfigTypeController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleRuleConfigRouter extends MessageRouter {
        processCode: string;
        protected _ruleConfigController: RuleConfigController;
        protected _ruleConfigTypeController: RuleConfigTypeController;
        protected _storageService: ModuleStorageService;
        protected _logicHistoryService: LogicHistoryService;
        private buildRuleConfigGetResponseVo;
        private makeRuleConfigPageResponseData;
        private buildRuleConfigPageResponseContentVo;
        onRuleConfigPageRequestAsync(context: MessageRouterContext, request: RuleConfigPageRequest, response: RuleConfigPageResponse): Promise<MessageResultType>;
        onRuleConfigGetRequestAsync(context: MessageRouterContext, request: RuleConfigGetRequest, response: RuleConfigGetResponse): Promise<MessageResultType>;
        onRuleConfigUpdateContentRequestAsync(context: MessageRouterContext, request: RuleConfigUpdateContentRequest, response: RuleConfigUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleRuleProcessRouter" {
    import { PersistentService } from 'cross/runtime/module/persistent/PersistentService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { RuleProcessParametersValidateRequest } from 'sk/data/logic/module/message/RuleProcessParametersValidateRequest';
    import { RuleProcessParametersValidateResponse } from 'sk/data/logic/module/message/RuleProcessParametersValidateResponse';
    import { RuleProcessUpdateContentRequest } from 'sk/data/logic/module/message/RuleProcessUpdateContentRequest';
    import { RuleProcessUpdateContentResponse } from 'sk/data/logic/module/message/RuleProcessUpdateContentResponse';
    import { RuleProcessController } from 'sk/service/data/logic/module/controller/RuleProcessController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleRuleProcessRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ModuleStorageService;
        protected _ruleProcessController: RuleProcessController;
        protected _persistentService: PersistentService;
        protected _familyDocumentService: FamilyDocumentService;
        protected _logicHistoryService: LogicHistoryService;
        onRuleProcessUpdateContentRequestAsync(context: MessageRouterContext, request: RuleProcessUpdateContentRequest, response: RuleProcessUpdateContentResponse): Promise<MessageResultType>;
        onRuleProcessParametersValidateRequestAsync(context: MessageRouterContext, request: RuleProcessParametersValidateRequest, response: RuleProcessParametersValidateResponse): Promise<MessageResultType>;
        private createInstance;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleRuleRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleChangeRequest } from 'sk/data/logic/module/message/RuleChangeRequest';
    import { RuleChangeResponse } from 'sk/data/logic/module/message/RuleChangeResponse';
    import { RuleDeepDuplicateRequest } from 'sk/data/logic/module/message/RuleDeepDuplicateRequest';
    import { RuleDeepDuplicateResponse } from 'sk/data/logic/module/message/RuleDeepDuplicateResponse';
    import { RuleDeleteRequest } from 'sk/data/logic/module/message/RuleDeleteRequest';
    import { RuleDeleteResponse } from 'sk/data/logic/module/message/RuleDeleteResponse';
    import { RuleGetRequest } from 'sk/data/logic/module/message/RuleGetRequest';
    import { RuleGetResponse } from 'sk/data/logic/module/message/RuleGetResponse';
    import { RuleInsertRequest } from 'sk/data/logic/module/message/RuleInsertRequest';
    import { RuleInsertResponse } from 'sk/data/logic/module/message/RuleInsertResponse';
    import { RulePageRequest } from 'sk/data/logic/module/message/RulePageRequest';
    import { RulePageResponse } from 'sk/data/logic/module/message/RulePageResponse';
    import { RulePasteRequest } from 'sk/data/logic/module/message/RulePasteRequest';
    import { RulePasteResponse } from 'sk/data/logic/module/message/RulePasteResponse';
    import { RuleSearchRequest } from 'sk/data/logic/module/message/RuleSearchRequest';
    import { RuleSearchResponse } from 'sk/data/logic/module/message/RuleSearchResponse';
    import { RuleUpdateContentRequest } from 'sk/data/logic/module/message/RuleUpdateContentRequest';
    import { RuleUpdateContentResponse } from 'sk/data/logic/module/message/RuleUpdateContentResponse';
    import { RuleUpdateRequest } from 'sk/data/logic/module/message/RuleUpdateRequest';
    import { RuleUpdateResponse } from 'sk/data/logic/module/message/RuleUpdateResponse';
    import { RuleCategoryController } from 'sk/service/data/logic/module/controller/RuleCategoryController';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    import { RuleDto } from 'sk/service/data/logic/module/controller/RuleDto';
    import { RuleTypeController } from 'sk/service/data/logic/module/controller/RuleTypeController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleRuleRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ModuleStorageService;
        protected _ruleController: RuleController;
        protected _ruleTypeController: RuleTypeController;
        protected _ruleCategoryController: RuleCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        protected _ruleDocumentService: RuleDocumentService;
        private buildCategoryNamesAsync;
        private makeRulePageResponseDatAsync;
        judgeCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<boolean>;
        checkCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<string>;
        updateRelationAsync(context: MessageRouterContext, ruleDto: RuleDto): Promise<ResultObject>;
        onRuleChangeRequestAsync(context: MessageRouterContext, request: RuleChangeRequest, response: RuleChangeResponse): Promise<MessageResultType>;
        onRuleUpdateContentRequestAsync(context: MessageRouterContext, request: RuleUpdateContentRequest, response: RuleUpdateContentResponse): Promise<MessageResultType>;
        onRulePageRequestAsync(context: MessageRouterContext, request: RulePageRequest, response: RulePageResponse): Promise<MessageResultType>;
        onRuleGetRequestAsync(context: MessageRouterContext, request: RuleGetRequest, response: RuleGetResponse): Promise<MessageResultType>;
        onRuleDeepDuplicateRequestAsync(context: MessageRouterContext, request: RuleDeepDuplicateRequest, response: RuleDeepDuplicateResponse): Promise<MessageResultType>;
        onRuleInsertRequestAsync(context: MessageRouterContext, request: RuleInsertRequest, response: RuleInsertResponse): Promise<MessageResultType>;
        onRuleUpdateRequestAsync(context: MessageRouterContext, request: RuleUpdateRequest, response: RuleUpdateResponse): Promise<MessageResultType>;
        onRuleDeleteRequestAsync(context: MessageRouterContext, request: RuleDeleteRequest, response: RuleDeleteResponse): Promise<MessageResultType>;
        onRuleSearchRequestAsync(context: MessageRouterContext, request: RuleSearchRequest, response: RuleSearchResponse): Promise<MessageResultType>;
        onRulePasteRequestAsync(context: MessageRouterContext, request: RulePasteRequest, response: RulePasteResponse): Promise<MessageResultType>;
        private deepDuplicateAsync;
        private fetchRuleElements;
        private createRuleElementAsync;
        private cloneRuleAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleRuleTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { RuleTypeGetRequest } from 'sk/data/logic/module/message/RuleTypeGetRequest';
    import { RuleTypeGetResponse } from 'sk/data/logic/module/message/RuleTypeGetResponse';
    import { RuleTypePageRequest } from 'sk/data/logic/module/message/RuleTypePageRequest';
    import { RuleTypePageResponse } from 'sk/data/logic/module/message/RuleTypePageResponse';
    import { RuleTypeSearchRequest } from 'sk/data/logic/module/message/RuleTypeSearchRequest';
    import { RuleTypeSearchResponse } from 'sk/data/logic/module/message/RuleTypeSearchResponse';
    import { RuleTypeUpdateContentRequest } from 'sk/data/logic/module/message/RuleTypeUpdateContentRequest';
    import { RuleTypeUpdateContentResponse } from 'sk/data/logic/module/message/RuleTypeUpdateContentResponse';
    import { RuleTypeController } from 'sk/service/data/logic/module/controller/RuleTypeController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleRuleTypeRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ModuleStorageService;
        protected _ruleTypeController: RuleTypeController;
        protected _logicHistoryService: LogicHistoryService;
        private makeRuleTypePageResponseDataAsync;
        onRuleTypeUpdateContentRequestAsync(context: MessageRouterContext, request: RuleTypeUpdateContentRequest, response: RuleTypeUpdateContentResponse): Promise<MessageResultType>;
        onRuleTypePageRequestAsync(context: MessageRouterContext, request: RuleTypePageRequest, response: RuleTypePageResponse): Promise<MessageResultType>;
        onRuleTypeGetRequestAsync(context: MessageRouterContext, request: RuleTypeGetRequest, response: RuleTypeGetResponse): Promise<MessageResultType>;
        onRuleTypeSearchRequestAsync(context: MessageRouterContext, request: RuleTypeSearchRequest, response: RuleTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleSectionRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StructureSectionUpdateContentRequest } from 'sk/data/logic/module/message/StructureSectionUpdateContentRequest';
    import { StructureSectionUpdateContentResponse } from 'sk/data/logic/module/message/StructureSectionUpdateContentResponse';
    import { StructureController } from 'sk/service/data/logic/module/controller/StructureController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleSectionRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ModuleStorageService;
        protected _sectionController: StructureController;
        protected _logicHistoryService: LogicHistoryService;
        onStructureSectionUpdateContentRequestAsync(context: MessageRouterContext, request: StructureSectionUpdateContentRequest, response: StructureSectionUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleStructureCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StructureCategoryDeleteRequest } from 'sk/data/logic/module/message/StructureCategoryDeleteRequest';
    import { StructureCategoryDeleteResponse } from 'sk/data/logic/module/message/StructureCategoryDeleteResponse';
    import { StructureCategoryGetRequest } from 'sk/data/logic/module/message/StructureCategoryGetRequest';
    import { StructureCategoryGetResponse } from 'sk/data/logic/module/message/StructureCategoryGetResponse';
    import { StructureCategoryInsertRequest } from 'sk/data/logic/module/message/StructureCategoryInsertRequest';
    import { StructureCategoryInsertResponse } from 'sk/data/logic/module/message/StructureCategoryInsertResponse';
    import { StructureCategoryPageRequest } from 'sk/data/logic/module/message/StructureCategoryPageRequest';
    import { StructureCategoryPageResponse } from 'sk/data/logic/module/message/StructureCategoryPageResponse';
    import { StructureCategorySearchRequest } from 'sk/data/logic/module/message/StructureCategorySearchRequest';
    import { StructureCategorySearchResponse } from 'sk/data/logic/module/message/StructureCategorySearchResponse';
    import { StructureCategorySortRequest } from 'sk/data/logic/module/message/StructureCategorySortRequest';
    import { StructureCategorySortResponse } from 'sk/data/logic/module/message/StructureCategorySortResponse';
    import { StructureCategoryTreeRequest } from 'sk/data/logic/module/message/StructureCategoryTreeRequest';
    import { StructureCategoryTreeResponse } from 'sk/data/logic/module/message/StructureCategoryTreeResponse';
    import { StructureCategoryUpdateRequest } from 'sk/data/logic/module/message/StructureCategoryUpdateRequest';
    import { StructureCategoryUpdateResponse } from 'sk/data/logic/module/message/StructureCategoryUpdateResponse';
    import { StructureCategoryController } from 'sk/service/data/logic/module/controller/StructureCategoryController';
    import { StructureController } from 'sk/service/data/logic/module/controller/StructureController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ModuleStructureCategoryRouter extends MessageRouter {
        processCode: string;
        private _parentId;
        protected _structureCategoryController: StructureCategoryController;
        protected _structureController: StructureController;
        protected _logicHistoryService: LogicHistoryService;
        onStructureCategoryInsertRequestAsync(context: MessageRouterContext, request: StructureCategoryInsertRequest, response: StructureCategoryInsertResponse): Promise<MessageResultType>;
        onStructureCategoryUpdateRequestAsync(context: MessageRouterContext, request: StructureCategoryUpdateRequest, response: StructureCategoryUpdateResponse): Promise<MessageResultType>;
        onStructureCategoryGetRequestAsync(context: MessageRouterContext, request: StructureCategoryGetRequest, response: StructureCategoryGetResponse): Promise<MessageResultType>;
        onStructureCategorySortRequestAsync(context: MessageRouterContext, request: StructureCategorySortRequest, response: StructureCategorySortResponse): Promise<MessageResultType>;
        onStructureCategoryPageRequestAsync(context: MessageRouterContext, request: StructureCategoryPageRequest, response: StructureCategoryPageResponse): Promise<MessageResultType>;
        onStructureCategoryTreeRequestAsync(context: MessageRouterContext, request: StructureCategoryTreeRequest, response: StructureCategoryTreeResponse): Promise<MessageResultType>;
        onStructureCategoryDeleteRequestAsync(context: MessageRouterContext, request: StructureCategoryDeleteRequest, response: StructureCategoryDeleteResponse): Promise<MessageResultType>;
        onStructureCategorySearchRequestAsync(context: MessageRouterContext, request: StructureCategorySearchRequest, response: StructureCategorySearchResponse): Promise<MessageResultType>;
        private makeFamilyPageResponseDataAsync;
        private makeCategoryTreeResponseData;
        private loopBuildCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleStructureRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StructureGetRequest } from 'sk/data/logic/module/message/StructureGetRequest';
    import { StructureGetResponse } from 'sk/data/logic/module/message/StructureGetResponse';
    import { StructureController } from 'sk/service/data/logic/module/controller/StructureController';
    export class ModuleStructureRouter extends MessageRouter {
        processCode: string;
        protected _structureController: StructureController;
        onStructureGetRequestAsync(context: MessageRouterContext, request: StructureGetRequest, response: StructureGetResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleStructureTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StructureTypeGetRequest } from 'sk/data/logic/module/message/StructureTypeGetRequest';
    import { StructureTypeGetResponse } from 'sk/data/logic/module/message/StructureTypeGetResponse';
    import { StructureTypeSearchRequest } from 'sk/data/logic/module/message/StructureTypeSearchRequest';
    import { StructureTypeSearchResponse } from 'sk/data/logic/module/message/StructureTypeSearchResponse';
    import { StructureTypeController } from 'sk/service/data/logic/module/controller/StructureTypeController';
    export class ModuleStructureTypeRouter extends MessageRouter {
        processCode: string;
        protected _structureTypeController: StructureTypeController;
        onStructureTypeGetRequestAsync(context: MessageRouterContext, request: StructureTypeGetRequest, response: StructureTypeGetResponse): Promise<MessageResultType>;
        onStructureTypeSearchRequestAsync(context: MessageRouterContext, request: StructureTypeSearchRequest, response: StructureTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleValuationConfigRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ValuationConfigDeleteRequest } from 'sk/data/logic/module/message/ValuationConfigDeleteRequest';
    import { ValuationConfigDeleteResponse } from 'sk/data/logic/module/message/ValuationConfigDeleteResponse';
    import { ValuationConfigFindRequest } from 'sk/data/logic/module/message/ValuationConfigFindRequest';
    import { ValuationConfigFindResponse } from 'sk/data/logic/module/message/ValuationConfigFindResponse';
    import { ValuationConfigGetRequest } from 'sk/data/logic/module/message/ValuationConfigGetRequest';
    import { ValuationConfigGetResponse } from 'sk/data/logic/module/message/ValuationConfigGetResponse';
    import { ValuationConfigInsertRequest } from 'sk/data/logic/module/message/ValuationConfigInsertRequest';
    import { ValuationConfigInsertResponse } from 'sk/data/logic/module/message/ValuationConfigInsertResponse';
    import { ValuationConfigPageRequest } from 'sk/data/logic/module/message/ValuationConfigPageRequest';
    import { ValuationConfigPageResponse } from 'sk/data/logic/module/message/ValuationConfigPageResponse';
    import { ValuationConfigUpdateRequest } from 'sk/data/logic/module/message/ValuationConfigUpdateRequest';
    import { ValuationConfigUpdateResponse } from 'sk/data/logic/module/message/ValuationConfigUpdateResponse';
    import { AttributeController } from 'sk/service/data/logic/module/controller/AttributeController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { MaterialCategoryController } from 'sk/service/data/logic/module/controller/MaterialCategoryController';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { ValuationConfigController } from 'sk/service/data/logic/module/controller/ValuationConfigController';
    import { ValuationRuleController } from 'sk/service/data/logic/module/controller/ValuationRuleController';
    import { ValuationSystemController } from 'sk/service/data/logic/module/controller/ValuationSystemController';
    export enum MaterialType {
        All = 0,
        Hardware = 1,
        Plank = 2
    }
    export class ModuleValuationConfigRouter extends MessageRouter {
        processCode: string;
        protected _valuationConfigController: ValuationConfigController;
        protected _valuationSystemController: ValuationSystemController;
        protected _valuationRuleController: ValuationRuleController;
        protected _materialController: MaterialController;
        protected _materialCategoryController: MaterialCategoryController;
        protected _attributeController: AttributeController;
        protected _familySymbolController: FamilySymbolController;
        private readonly _hardwareAttrCode;
        private readonly _planeAttrCode;
        private readonly _edgeSurfaceAttrCode;
        private readonly _substrateSurfaceAttrCode;
        private readonly _planeSurfaceAttrCode;
        private makePageResponseDataAsync;
        private buildCustomDataAsync;
        private filterHardwareMaterial;
        private checkByFamilyId;
        private filterPlankMaterialAsync;
        private checkByFamilySymbolIdAsync;
        private getMaterialTypeAsync;
        onValuationConfigFindRequestAsync(context: MessageRouterContext, request: ValuationConfigFindRequest, response: ValuationConfigFindResponse): Promise<MessageResultType>;
        onValuationConfigGetRequestAsync(context: MessageRouterContext, request: ValuationConfigGetRequest, response: ValuationConfigGetResponse): Promise<MessageResultType>;
        onValuationConfigInsertRequestAsync(context: MessageRouterContext, request: ValuationConfigInsertRequest, response: ValuationConfigInsertResponse): Promise<MessageResultType>;
        onValuationConfigUpdateRequestAsync(context: MessageRouterContext, request: ValuationConfigUpdateRequest, response: ValuationConfigUpdateResponse): Promise<MessageResultType>;
        onValuationConfigPageRequestAsync(context: MessageRouterContext, request: ValuationConfigPageRequest, response: ValuationConfigPageResponse): Promise<MessageResultType>;
        onValuationConfigDeleteRequestAsync(context: MessageRouterContext, request: ValuationConfigDeleteRequest, response: ValuationConfigDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleValuationRuleRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ValuationRuleDeleteRequest } from 'sk/data/logic/module/message/ValuationRuleDeleteRequest';
    import { ValuationRuleDeleteResponse } from 'sk/data/logic/module/message/ValuationRuleDeleteResponse';
    import { ValuationRuleGetRequest } from 'sk/data/logic/module/message/ValuationRuleGetRequest';
    import { ValuationRuleGetResponse } from 'sk/data/logic/module/message/ValuationRuleGetResponse';
    import { ValuationRuleInsertRequest } from 'sk/data/logic/module/message/ValuationRuleInsertRequest';
    import { ValuationRuleInsertResponse } from 'sk/data/logic/module/message/ValuationRuleInsertResponse';
    import { ValuationRulePageRequest } from 'sk/data/logic/module/message/ValuationRulePageRequest';
    import { ValuationRulePageResponse } from 'sk/data/logic/module/message/ValuationRulePageResponse';
    import { ValuationRuleUpdateRequest } from 'sk/data/logic/module/message/ValuationRuleUpdateRequest';
    import { ValuationRuleUpdateResponse } from 'sk/data/logic/module/message/ValuationRuleUpdateResponse';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    import { ValuationRuleController } from 'sk/service/data/logic/module/controller/ValuationRuleController';
    export class ModuleValuationRuleRouter extends MessageRouter {
        processCode: string;
        protected _valuationRuleController: ValuationRuleController;
        protected _ruleController: RuleController;
        private makePageResponseDataAsync;
        onValuationRuleGetRequestAsync(context: MessageRouterContext, request: ValuationRuleGetRequest, response: ValuationRuleGetResponse): Promise<MessageResultType>;
        onValuationRuleInsertRequestAsync(context: MessageRouterContext, request: ValuationRuleInsertRequest, response: ValuationRuleInsertResponse): Promise<MessageResultType>;
        onValuationRuleUpdateRequestAsync(context: MessageRouterContext, request: ValuationRuleUpdateRequest, response: ValuationRuleUpdateResponse): Promise<MessageResultType>;
        onValuationRulePageRequestAsync(context: MessageRouterContext, request: ValuationRulePageRequest, response: ValuationRulePageResponse): Promise<MessageResultType>;
        onValuationRuleDeleteRequestAsync(context: MessageRouterContext, request: ValuationRuleDeleteRequest, response: ValuationRuleDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleValuationSystemRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ValuationSystemDeleteRequest } from 'sk/data/logic/module/message/ValuationSystemDeleteRequest';
    import { ValuationSystemDeleteResponse } from 'sk/data/logic/module/message/ValuationSystemDeleteResponse';
    import { ValuationSystemGetRequest } from 'sk/data/logic/module/message/ValuationSystemGetRequest';
    import { ValuationSystemGetResponse } from 'sk/data/logic/module/message/ValuationSystemGetResponse';
    import { ValuationSystemInsertRequest } from 'sk/data/logic/module/message/ValuationSystemInsertRequest';
    import { ValuationSystemInsertResponse } from 'sk/data/logic/module/message/ValuationSystemInsertResponse';
    import { ValuationSystemPageRequest } from 'sk/data/logic/module/message/ValuationSystemPageRequest';
    import { ValuationSystemPageResponse } from 'sk/data/logic/module/message/ValuationSystemPageResponse';
    import { ValuationSystemUpdateRequest } from 'sk/data/logic/module/message/ValuationSystemUpdateRequest';
    import { ValuationSystemUpdateResponse } from 'sk/data/logic/module/message/ValuationSystemUpdateResponse';
    import { MaterialCategoryController } from 'sk/service/data/logic/module/controller/MaterialCategoryController';
    import { ValuationRuleController } from 'sk/service/data/logic/module/controller/ValuationRuleController';
    import { ValuationSystemController } from 'sk/service/data/logic/module/controller/ValuationSystemController';
    export class ModuleValuationSystemRouter extends MessageRouter {
        processCode: string;
        protected _valuationSystemController: ValuationSystemController;
        protected _materialCategoryController: MaterialCategoryController;
        protected _valuationRuleController: ValuationRuleController;
        private makePageResponseDataAsync;
        onValuationSystemGetRequestAsync(context: MessageRouterContext, request: ValuationSystemGetRequest, response: ValuationSystemGetResponse): Promise<MessageResultType>;
        onValuationSystemInsertRequestAsync(context: MessageRouterContext, request: ValuationSystemInsertRequest, response: ValuationSystemInsertResponse): Promise<MessageResultType>;
        onValuationSystemUpdateRequestAsync(context: MessageRouterContext, request: ValuationSystemUpdateRequest, response: ValuationSystemUpdateResponse): Promise<MessageResultType>;
        onValuationSystemPageRequestAsync(context: MessageRouterContext, request: ValuationSystemPageRequest, response: ValuationSystemPageResponse): Promise<MessageResultType>;
        onValuationSystemDeleteRequestAsync(context: MessageRouterContext, request: ValuationSystemDeleteRequest, response: ValuationSystemDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ModuleWorkflowRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { WorkflowGetContentRequest } from 'sk/data/logic/module/message/WorkflowGetContentRequest';
    import { WorkflowGetContentResponse } from 'sk/data/logic/module/message/WorkflowGetContentResponse';
    import { WorkflowUpdateContentRequest } from 'sk/data/logic/module/message/WorkflowUpdateContentRequest';
    import { WorkflowUpdateContentResponse } from 'sk/data/logic/module/message/WorkflowUpdateContentResponse';
    import { WorkflowController } from 'sk/service/data/logic/module/controller/WorkflowController';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class ModuleWorkflowRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ModuleStorageService;
        protected _workflowController: WorkflowController;
        onWorkflowGetContentRequestAsync(context: MessageRouterContext, request: WorkflowGetContentRequest, response: WorkflowGetContentResponse): Promise<MessageResultType>;
        onWorkflowUpdateContentRequestAsync(context: MessageRouterContext, request: WorkflowUpdateContentRequest, response: WorkflowUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ProductCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductCategoryDeleteRequest } from 'sk/data/logic/module/message/ProductCategoryDeleteRequest';
    import { ProductCategoryDeleteResponse } from 'sk/data/logic/module/message/ProductCategoryDeleteResponse';
    import { ProductCategoryGetRequest } from 'sk/data/logic/module/message/ProductCategoryGetRequest';
    import { ProductCategoryGetResponse } from 'sk/data/logic/module/message/ProductCategoryGetResponse';
    import { ProductCategoryInsertRequest } from 'sk/data/logic/module/message/ProductCategoryInsertRequest';
    import { ProductCategoryInsertResponse } from 'sk/data/logic/module/message/ProductCategoryInsertResponse';
    import { ProductCategorySearchRequest } from 'sk/data/logic/module/message/ProductCategorySearchRequest';
    import { ProductCategorySearchResponse } from 'sk/data/logic/module/message/ProductCategorySearchResponse';
    import { ProductCategorySortRequest } from 'sk/data/logic/module/message/ProductCategorySortRequest';
    import { ProductCategorySortResponse } from 'sk/data/logic/module/message/ProductCategorySortResponse';
    import { ProductCategoryTreeRequest } from 'sk/data/logic/module/message/ProductCategoryTreeRequest';
    import { ProductCategoryTreeResponse } from 'sk/data/logic/module/message/ProductCategoryTreeResponse';
    import { ProductCategoryUpdateRequest } from 'sk/data/logic/module/message/ProductCategoryUpdateRequest';
    import { ProductCategoryUpdateResponse } from 'sk/data/logic/module/message/ProductCategoryUpdateResponse';
    import { ProductCategoryController } from 'sk/service/data/logic/module/controller/ProductCategoryController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ProductCategoryRouter extends MessageRouter {
        processCode: string;
        protected _productCategoryController: ProductCategoryController;
        protected _productController: ProductController;
        protected _categoryId: any;
        protected _logicHistoryService: LogicHistoryService;
        onProductCategoryTreeRequestAsync(context: MessageRouterContext, request: ProductCategoryTreeRequest, response: ProductCategoryTreeResponse): Promise<MessageResultType>;
        onProductCategoryGetRequestAsync(context: MessageRouterContext, request: ProductCategoryGetRequest, response: ProductCategoryGetResponse): Promise<MessageResultType>;
        onProductCategoryInsertRequestAsync(context: MessageRouterContext, request: ProductCategoryInsertRequest, response: ProductCategoryInsertResponse): Promise<MessageResultType>;
        onProductCategorySortRequestAsync(context: MessageRouterContext, request: ProductCategorySortRequest, response: ProductCategorySortResponse): Promise<MessageResultType>;
        onProductCategoryUpdateRequestAsync(context: MessageRouterContext, request: ProductCategoryUpdateRequest, response: ProductCategoryUpdateResponse): Promise<MessageResultType>;
        onProductCategoryDeleteRequestAsync(context: MessageRouterContext, request: ProductCategoryDeleteRequest, response: ProductCategoryDeleteResponse): Promise<MessageResultType>;
        onProductCategorySearchRequestAsync(context: MessageRouterContext, request: ProductCategorySearchRequest, response: ProductCategorySearchResponse): Promise<MessageResultType>;
        private buildProductCategoryTreeItemVo;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ProductConstructorRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductConstructorDeleteRequest } from 'sk/data/logic/module/message/ProductConstructorDeleteRequest';
    import { ProductConstructorDeleteResponse } from 'sk/data/logic/module/message/ProductConstructorDeleteResponse';
    import { ProductConstructorGetRequest } from 'sk/data/logic/module/message/ProductConstructorGetRequest';
    import { ProductConstructorGetResponse } from 'sk/data/logic/module/message/ProductConstructorGetResponse';
    import { ProductConstructorInsertRequest } from 'sk/data/logic/module/message/ProductConstructorInsertRequest';
    import { ProductConstructorInsertResponse } from 'sk/data/logic/module/message/ProductConstructorInsertResponse';
    import { ProductConstructorSearchRequest } from 'sk/data/logic/module/message/ProductConstructorSearchRequest';
    import { ProductConstructorSearchResponse } from 'sk/data/logic/module/message/ProductConstructorSearchResponse';
    import { ProductConstructorTreeRequest } from 'sk/data/logic/module/message/ProductConstructorTreeRequest';
    import { ProductConstructorTreeResponse } from 'sk/data/logic/module/message/ProductConstructorTreeResponse';
    import { ProductConstructorUpdateRequest } from 'sk/data/logic/module/message/ProductConstructorUpdateRequest';
    import { ProductConstructorUpdateResponse } from 'sk/data/logic/module/message/ProductConstructorUpdateResponse';
    export class ProductConstructorRouter extends MessageRouter {
        processCode: string;
        onProductConstructorTreeRequestAsync(context: MessageRouterContext, request: ProductConstructorTreeRequest, response: ProductConstructorTreeResponse): Promise<MessageResultType>;
        onProductConstructorGetRequestAsync(context: MessageRouterContext, request: ProductConstructorGetRequest, response: ProductConstructorGetResponse): Promise<MessageResultType>;
        onProductConstructorSearchRequestAsync(context: MessageRouterContext, request: ProductConstructorSearchRequest, response: ProductConstructorSearchResponse): Promise<MessageResultType>;
        onProductConstructorInsertRequestAsync(context: MessageRouterContext, request: ProductConstructorInsertRequest, response: ProductConstructorInsertResponse): Promise<MessageResultType>;
        onProductConstructorUpdateRequestAsync(context: MessageRouterContext, request: ProductConstructorUpdateRequest, response: ProductConstructorUpdateResponse): Promise<MessageResultType>;
        onProductConstructorDeleteRequestAsync(context: MessageRouterContext, request: ProductConstructorDeleteRequest, response: ProductConstructorDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ProductInfoRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductInfoGetBySymbolIdRequest } from 'sk/data/logic/module/message/ProductInfoGetBySymbolIdRequest';
    import { ProductInfoGetBySymbolIdResponse } from 'sk/data/logic/module/message/ProductInfoGetBySymbolIdResponse';
    import { ProductInfoGetRequest } from 'sk/data/logic/module/message/ProductInfoGetRequest';
    import { ProductInfoGetResponse } from 'sk/data/logic/module/message/ProductInfoGetResponse';
    import { ProductInfoInsertRequest } from 'sk/data/logic/module/message/ProductInfoInsertRequest';
    import { ProductInfoInsertResponse } from 'sk/data/logic/module/message/ProductInfoInsertResponse';
    import { ProductInfoListRequest } from 'sk/data/logic/module/message/ProductInfoListRequest';
    import { ProductInfoListResponse } from 'sk/data/logic/module/message/ProductInfoListResponse';
    import { ProductInfoUpdateRequest } from 'sk/data/logic/module/message/ProductInfoUpdateRequest';
    import { ProductInfoUpdateResponse } from 'sk/data/logic/module/message/ProductInfoUpdateResponse';
    import { ProductInfoController } from 'sk/service/data/logic/module/controller/ProductInfoController';
    export class ProductInfoRouter extends MessageRouter {
        processCode: string;
        protected _productInfoController: ProductInfoController;
        private buildGetResponseVo;
        private buildListResponseVo;
        onProductInfoListRequestAsync(context: MessageRouterContext, request: ProductInfoListRequest, response: ProductInfoListResponse): Promise<MessageResultType>;
        onProductInfoGetRequestAsync(context: MessageRouterContext, request: ProductInfoGetRequest, response: ProductInfoGetResponse): Promise<MessageResultType>;
        onProductInfoGetBySymbolIdRequestAsync(context: MessageRouterContext, request: ProductInfoGetBySymbolIdRequest, response: ProductInfoGetBySymbolIdResponse): Promise<MessageResultType>;
        onProductInfoInsertRequestAsync(context: MessageRouterContext, request: ProductInfoInsertRequest, response: ProductInfoInsertResponse): Promise<MessageResultType>;
        onProductInfoUpdateRequestAsync(context: MessageRouterContext, request: ProductInfoUpdateRequest, response: ProductInfoUpdateResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/symbol/service/ProductSymbolLogicService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { ProductDto } from 'sk/service/data/logic/module/controller/ProductDto';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { FamilySymbolBuildService } from "sk/service/logic/module/symbol/service/FamilySymbolBuildService";
    export class ProductSymbolLogicService extends Service {
        protected _buildService: FamilySymbolBuildService;
        protected _familySymbolController: FamilySymbolController;
        protected _productSymbolController: ProductSymbolController;
        processSymbolsAsync(context: MessageRouterContext, productDto: ProductDto): Promise<ResultObject>;
        parseSymbolConfigs(symbolConfigs: Array<any>): TypeMap<string, Types<SymbolStructure>>;
        private insertProductSymbolsAsync;
        private filterFamilySymbolsAsync;
        private updateFamilySymbolsStatusAsync;
        private updateFamilySymbolStatusAsync;
    }
}
declare module "sk/service/logic/module/router/ProductRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductProductDeleteRequest } from 'sk/data/logic/module/message/ProductProductDeleteRequest';
    import { ProductProductDeleteResponse } from 'sk/data/logic/module/message/ProductProductDeleteResponse';
    import { ProductProductFindRequest } from 'sk/data/logic/module/message/ProductProductFindRequest';
    import { ProductProductFindResponse } from 'sk/data/logic/module/message/ProductProductFindResponse';
    import { ProductProductGetcontentRequest } from 'sk/data/logic/module/message/ProductProductGetcontentRequest';
    import { ProductProductGetcontentResponse } from 'sk/data/logic/module/message/ProductProductGetcontentResponse';
    import { ProductProductGetRequest } from 'sk/data/logic/module/message/ProductProductGetRequest';
    import { ProductProductGetResponse, ProductProductGetResponseFamilyTypeVo } from 'sk/data/logic/module/message/ProductProductGetResponse';
    import { ProductProductInsertRequest } from 'sk/data/logic/module/message/ProductProductInsertRequest';
    import { ProductProductInsertResponse } from 'sk/data/logic/module/message/ProductProductInsertResponse';
    import { ProductProductListRequest } from 'sk/data/logic/module/message/ProductProductListRequest';
    import { ProductProductListResponse } from 'sk/data/logic/module/message/ProductProductListResponse';
    import { ProductProductPageRequest } from 'sk/data/logic/module/message/ProductProductPageRequest';
    import { ProductProductPageResponse } from 'sk/data/logic/module/message/ProductProductPageResponse';
    import { ProductProductSearchRequest } from 'sk/data/logic/module/message/ProductProductSearchRequest';
    import { ProductProductSearchResponse } from 'sk/data/logic/module/message/ProductProductSearchResponse';
    import { ProductProductUpdateRequest } from 'sk/data/logic/module/message/ProductProductUpdateRequest';
    import { ProductProductUpdateResponse } from 'sk/data/logic/module/message/ProductProductUpdateResponse';
    import { ProductShowPerspectiveController } from 'sk/service/data/logic/digitization/controller/ProductShowPerspectiveController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { MaterialController } from 'sk/service/data/logic/module/controller/MaterialController';
    import { PatternController } from 'sk/service/data/logic/module/controller/PatternController';
    import { PatternSymbolController } from 'sk/service/data/logic/module/controller/PatternSymbolController';
    import { PatternTypeController } from 'sk/service/data/logic/module/controller/PatternTypeController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleLibraryVersionController } from 'sk/service/data/logic/publish/controller/ModuleLibraryVersionController';
    import { ProductSymbolLogicService } from "sk/service/logic/module/symbol/service/ProductSymbolLogicService";
    export class ProductRouter extends MessageRouter {
        processCode: string;
        private _maxLoopCount;
        protected _environmentService: EnvironmentService;
        protected _jsonService: JsonService;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _familyController: FamilyController;
        protected _productShowPerspectiveController: ProductShowPerspectiveController;
        protected _patternController: PatternController;
        protected _materialController: MaterialController;
        protected _familyTypeController: FamilyTypeController;
        protected _patternTypeController: PatternTypeController;
        protected _patternSymbolController: PatternSymbolController;
        protected _moduleLibraryVersionController: ModuleLibraryVersionController;
        protected _logicHistoryService: LogicHistoryService;
        protected _productSymbolService: ProductSymbolLogicService;
        private buildProductDto;
        private insertProductSymbolsAsync;
        private makeProductPageResponseData;
        private buildProductProductGetContentResponseVo;
        buildFamilyTypeListAsync(context: MessageRouterContext, typeId: string): Promise<StructureTypes<ProductProductGetResponseFamilyTypeVo>>;
        buildPatternTypeListAsync(context: MessageRouterContext, typeId: string): Promise<StructureTypes<ProductProductGetResponseFamilyTypeVo>>;
        onProductProductListRequestAsync(context: MessageRouterContext, request: ProductProductListRequest, response: ProductProductListResponse): Promise<MessageResultType>;
        onProductProductPageRequestAsync(context: MessageRouterContext, request: ProductProductPageRequest, response: ProductProductPageResponse): Promise<MessageResultType>;
        onProductProductGetRequestAsync(context: MessageRouterContext, request: ProductProductGetRequest, response: ProductProductGetResponse): Promise<MessageResultType>;
        onProductProductGetcontentRequestAsync(context: MessageRouterContext, request: ProductProductGetcontentRequest, response: ProductProductGetcontentResponse): Promise<MessageResultType>;
        onProductProductFindRequestAsync(context: MessageRouterContext, request: ProductProductFindRequest, response: ProductProductFindResponse): Promise<MessageResultType>;
        onProductProductSearchRequestAsync(context: MessageRouterContext, request: ProductProductSearchRequest, response: ProductProductSearchResponse): Promise<MessageResultType>;
        onProductProductInsertRequestAsync(context: MessageRouterContext, request: ProductProductInsertRequest, response: ProductProductInsertResponse): Promise<MessageResultType>;
        onProductProductUpdateRequestAsync(context: MessageRouterContext, request: ProductProductUpdateRequest, response: ProductProductUpdateResponse): Promise<MessageResultType>;
        onProductProductDeleteRequestAsync(context: MessageRouterContext, request: ProductProductDeleteRequest, response: ProductProductDeleteResponse): Promise<MessageResultType>;
        private getFamilyDocJsonAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ProductShowCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductShowCategoryCopyRequest } from 'sk/data/logic/module/message/ProductShowCategoryCopyRequest';
    import { ProductShowCategoryCopyResponse } from 'sk/data/logic/module/message/ProductShowCategoryCopyResponse';
    import { ProductShowCategoryDeleteAllRequest } from 'sk/data/logic/module/message/ProductShowCategoryDeleteAllRequest';
    import { ProductShowCategoryDeleteAllResponse } from 'sk/data/logic/module/message/ProductShowCategoryDeleteAllResponse';
    import { ProductShowCategoryDeleteDeepRequest } from 'sk/data/logic/module/message/ProductShowCategoryDeleteDeepRequest';
    import { ProductShowCategoryDeleteDeepResponse } from 'sk/data/logic/module/message/ProductShowCategoryDeleteDeepResponse';
    import { ProductShowCategoryDeleteRequest } from 'sk/data/logic/module/message/ProductShowCategoryDeleteRequest';
    import { ProductShowCategoryDeleteResponse } from 'sk/data/logic/module/message/ProductShowCategoryDeleteResponse';
    import { ProductShowCategoryGetRelateRequest } from 'sk/data/logic/module/message/ProductShowCategoryGetRelateRequest';
    import { ProductShowCategoryGetRelateResponse } from 'sk/data/logic/module/message/ProductShowCategoryGetRelateResponse';
    import { ProductShowCategoryGetRequest } from 'sk/data/logic/module/message/ProductShowCategoryGetRequest';
    import { ProductShowCategoryGetResponse } from 'sk/data/logic/module/message/ProductShowCategoryGetResponse';
    import { ProductShowCategoryInsertRequest } from 'sk/data/logic/module/message/ProductShowCategoryInsertRequest';
    import { ProductShowCategoryInsertResponse } from 'sk/data/logic/module/message/ProductShowCategoryInsertResponse';
    import { ProductShowCategoryRelateRequest } from 'sk/data/logic/module/message/ProductShowCategoryRelateRequest';
    import { ProductShowCategoryRelateResponse } from 'sk/data/logic/module/message/ProductShowCategoryRelateResponse';
    import { ProductShowCategorySearchRequest } from 'sk/data/logic/module/message/ProductShowCategorySearchRequest';
    import { ProductShowCategorySearchResponse } from 'sk/data/logic/module/message/ProductShowCategorySearchResponse';
    import { ProductShowCategorySortRequest } from 'sk/data/logic/module/message/ProductShowCategorySortRequest';
    import { ProductShowCategorySortResponse } from 'sk/data/logic/module/message/ProductShowCategorySortResponse';
    import { ProductShowCategoryTreeRequest } from 'sk/data/logic/module/message/ProductShowCategoryTreeRequest';
    import { ProductShowCategoryTreeResponse } from 'sk/data/logic/module/message/ProductShowCategoryTreeResponse';
    import { ProductShowCategoryUpdateRequest } from 'sk/data/logic/module/message/ProductShowCategoryUpdateRequest';
    import { ProductShowCategoryUpdateResponse } from 'sk/data/logic/module/message/ProductShowCategoryUpdateResponse';
    import { ProductCategoryController } from 'sk/service/data/logic/module/controller/ProductCategoryController';
    import { ProductShowCategoryController } from 'sk/service/data/logic/module/controller/ProductShowCategoryController';
    import { ProductShowCategoryItemController } from 'sk/service/data/logic/module/controller/ProductShowCategoryItemController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ProductShowCategoryRouter extends MessageRouter {
        processCode: string;
        protected _productCategoryController: ProductCategoryController;
        protected _productShowCategoryController: ProductShowCategoryController;
        protected _productShowCategoryItemController: ProductShowCategoryItemController;
        protected _logicHistoryService: LogicHistoryService;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildProductTypeTreeResponseItemsVo;
        private productShowCategoryCopyRecursioAsync;
        private buildProductCategoryTreeItemVo;
        private rootProductCategoryTreeFilter;
        onProductShowCategoryCopyRequestAsync(context: MessageRouterContext, request: ProductShowCategoryCopyRequest, response: ProductShowCategoryCopyResponse): Promise<MessageResultType>;
        onProductShowCategoryInsertRequestAsync(context: MessageRouterContext, request: ProductShowCategoryInsertRequest, response: ProductShowCategoryInsertResponse): Promise<MessageResultType>;
        onProductShowCategoryUpdateRequestAsync(context: MessageRouterContext, request: ProductShowCategoryUpdateRequest, response: ProductShowCategoryUpdateResponse): Promise<MessageResultType>;
        onProductShowCategoryGetRelateRequestAsync(context: MessageRouterContext, request: ProductShowCategoryGetRelateRequest, response: ProductShowCategoryGetRelateResponse): Promise<MessageResultType>;
        onProductShowCategoryRelateRequestAsync(context: MessageRouterContext, request: ProductShowCategoryRelateRequest, response: ProductShowCategoryRelateResponse): Promise<MessageResultType>;
        onProductShowCategorySortRequestAsync(context: MessageRouterContext, request: ProductShowCategorySortRequest, response: ProductShowCategorySortResponse): Promise<MessageResultType>;
        onProductShowCategorySearchRequestAsync(context: MessageRouterContext, request: ProductShowCategorySearchRequest, response: ProductShowCategorySearchResponse): Promise<MessageResultType>;
        onProductShowCategoryTreeRequestAsync(context: MessageRouterContext, request: ProductShowCategoryTreeRequest, response: ProductShowCategoryTreeResponse): Promise<MessageResultType>;
        onProductShowCategoryGetRequestAsync(context: MessageRouterContext, request: ProductShowCategoryGetRequest, response: ProductShowCategoryGetResponse): Promise<MessageResultType>;
        onProductShowCategoryDeleteAllRequestAsync(context: MessageRouterContext, request: ProductShowCategoryDeleteAllRequest, response: ProductShowCategoryDeleteAllResponse): Promise<MessageResultType>;
        onProductShowCategoryDeleteDeepRequestAsync(context: MessageRouterContext, request: ProductShowCategoryDeleteDeepRequest, response: ProductShowCategoryDeleteDeepResponse): Promise<MessageResultType>;
        onProductShowCategoryDeleteRequestAsync(context: MessageRouterContext, request: ProductShowCategoryDeleteRequest, response: ProductShowCategoryDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ProductShowRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductShowCategoryItemDeleteRequest } from 'sk/data/logic/module/message/ProductShowCategoryItemDeleteRequest';
    import { ProductShowCategoryItemDeleteResponse } from 'sk/data/logic/module/message/ProductShowCategoryItemDeleteResponse';
    import { ProductShowCategoryItemGetRequest } from 'sk/data/logic/module/message/ProductShowCategoryItemGetRequest';
    import { ProductShowCategoryItemGetResponse } from 'sk/data/logic/module/message/ProductShowCategoryItemGetResponse';
    import { ProductShowCategoryItemInsertRequest } from 'sk/data/logic/module/message/ProductShowCategoryItemInsertRequest';
    import { ProductShowCategoryItemInsertResponse } from 'sk/data/logic/module/message/ProductShowCategoryItemInsertResponse';
    import { ProductShowCategoryItemPageItemRequest } from 'sk/data/logic/module/message/ProductShowCategoryItemPageItemRequest';
    import { ProductShowCategoryItemPageItemResponse } from 'sk/data/logic/module/message/ProductShowCategoryItemPageItemResponse';
    import { ProductShowCategoryItemPageRequest } from 'sk/data/logic/module/message/ProductShowCategoryItemPageRequest';
    import { ProductShowCategoryItemPageResponse, ProductShowCategoryItemPageResponseFamilyTypeVo } from 'sk/data/logic/module/message/ProductShowCategoryItemPageResponse';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { ProductShowCategoryController } from 'sk/service/data/logic/module/controller/ProductShowCategoryController';
    import { ProductShowCategoryItemController } from 'sk/service/data/logic/module/controller/ProductShowCategoryItemController';
    import { ProductSymbolController } from 'sk/service/data/logic/module/controller/ProductSymbolController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ModuleProductShowProductController } from 'sk/service/data/logic/perspective/controller/ModuleProductShowProductController';
    export class ProductShowRouter extends MessageRouter {
        processCode: string;
        private _maxLoopCount;
        protected _moduleProductShowProductController: ModuleProductShowProductController;
        protected _productShowCategoryItemController: ProductShowCategoryItemController;
        protected _productShowCategoryController: ProductShowCategoryController;
        protected _productController: ProductController;
        protected _productSymbolController: ProductSymbolController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _familySymbolController: FamilySymbolController;
        protected _familyController: FamilyController;
        protected _familyTypeController: FamilyTypeController;
        protected _logicHistoryService: LogicHistoryService;
        private buildProductShowItemDto;
        private buildPageContentItem;
        private buildPageResponseItemAsync;
        private makeProductShowPageResponseData;
        buildFamilyTypeListAsync(context: MessageRouterContext, typeId: string): Promise<StructureTypes<ProductShowCategoryItemPageResponseFamilyTypeVo>>;
        private makeProductShowItemPageResponseDataAsync;
        onProductShowCategoryItemPageRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemPageRequest, response: ProductShowCategoryItemPageResponse): Promise<MessageResultType>;
        onProductShowCategoryItemPageItemRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemPageItemRequest, response: ProductShowCategoryItemPageItemResponse): Promise<MessageResultType>;
        onProductShowCategoryItemGetRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemGetRequest, response: ProductShowCategoryItemGetResponse): Promise<MessageResultType>;
        onProductShowCategoryItemInsertRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemInsertRequest, response: ProductShowCategoryItemInsertResponse): Promise<MessageResultType>;
        onProductShowCategoryItemDeleteRequestAsync(context: MessageRouterContext, request: ProductShowCategoryItemDeleteRequest, response: ProductShowCategoryItemDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/ProductTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductTypePageRequest } from 'sk/data/logic/module/message/ProductTypePageRequest';
    import { ProductTypePageResponse } from 'sk/data/logic/module/message/ProductTypePageResponse';
    import { ProductTypeSearchRequest } from 'sk/data/logic/module/message/ProductTypeSearchRequest';
    import { ProductTypeSearchResponse } from 'sk/data/logic/module/message/ProductTypeSearchResponse';
    import { ProductTypeController } from 'sk/service/data/logic/module/controller/ProductTypeController';
    export class ProductTypeRouter extends MessageRouter {
        processCode: string;
        protected _productTypeController: ProductTypeController;
        private makeProductTypePageResponseData;
        private buildProductTypePageResponseContentVo;
        onProductTypePageRequestAsync(context: MessageRouterContext, request: ProductTypePageRequest, response: ProductTypePageResponse): Promise<MessageResultType>;
        onProductTypeSearchRequestAsync(context: MessageRouterContext, request: ProductTypeSearchRequest, response: ProductTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/router/StructureRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StructureStructureDeleteRequest } from 'sk/data/logic/module/message/StructureStructureDeleteRequest';
    import { StructureStructureDeleteResponse } from 'sk/data/logic/module/message/StructureStructureDeleteResponse';
    import { StructureStructureGetRequest } from 'sk/data/logic/module/message/StructureStructureGetRequest';
    import { StructureStructureGetResponse } from 'sk/data/logic/module/message/StructureStructureGetResponse';
    import { StructureStructureInsertRequest } from 'sk/data/logic/module/message/StructureStructureInsertRequest';
    import { StructureStructureInsertResponse } from 'sk/data/logic/module/message/StructureStructureInsertResponse';
    import { StructureStructurePageRequest } from 'sk/data/logic/module/message/StructureStructurePageRequest';
    import { StructureStructurePageResponse } from 'sk/data/logic/module/message/StructureStructurePageResponse';
    import { StructureStructurePasteRequest } from 'sk/data/logic/module/message/StructureStructurePasteRequest';
    import { StructureStructurePasteResponse } from 'sk/data/logic/module/message/StructureStructurePasteResponse';
    import { StructureStructureSearchRequest } from 'sk/data/logic/module/message/StructureStructureSearchRequest';
    import { StructureStructureSearchResponse } from 'sk/data/logic/module/message/StructureStructureSearchResponse';
    import { StructureStructureUpdateRequest } from 'sk/data/logic/module/message/StructureStructureUpdateRequest';
    import { StructureStructureUpdateResponse } from 'sk/data/logic/module/message/StructureStructureUpdateResponse';
    import { StructureCategoryController } from 'sk/service/data/logic/module/controller/StructureCategoryController';
    import { StructureController } from 'sk/service/data/logic/module/controller/StructureController';
    import { StructureTypeController } from 'sk/service/data/logic/module/controller/StructureTypeController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class StructureRouter extends MessageRouter {
        processCode: string;
        protected _structureController: StructureController;
        protected _structureTypeController: StructureTypeController;
        protected _structureCategoryController: StructureCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        protected _moduleStorageService: ModuleStorageService;
        onStructureStructureGetRequestAsync(context: MessageRouterContext, request: StructureStructureGetRequest, response: StructureStructureGetResponse): Promise<MessageResultType>;
        onStructureStructureInsertRequestAsync(context: MessageRouterContext, request: StructureStructureInsertRequest, response: StructureStructureInsertResponse): Promise<MessageResultType>;
        onStructureStructureDeleteRequestAsync(context: MessageRouterContext, request: StructureStructureDeleteRequest, response: StructureStructureDeleteResponse): Promise<MessageResultType>;
        onStructureStructurePageRequestAsync(context: MessageRouterContext, request: StructureStructurePageRequest, response: StructureStructurePageResponse): Promise<MessageResultType>;
        onStructureStructureUpdateRequestAsync(context: MessageRouterContext, request: StructureStructureUpdateRequest, response: StructureStructureUpdateResponse): Promise<MessageResultType>;
        onStructureStructureSearchRequestAsync(context: MessageRouterContext, request: StructureStructureSearchRequest, response: StructureStructureSearchResponse): Promise<MessageResultType>;
        onStructureStructurePasteRequestAsync(context: MessageRouterContext, request: StructureStructurePasteRequest, response: StructureStructurePasteResponse): Promise<MessageResultType>;
        private makeFamilyPageResponseDataAsync;
        checkCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<string>;
        judgeCodeAsync(context: MessageRouterContext, hasCodeList: Array<any>, code: string, categoryId: string): Promise<boolean>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/module/service/FamilyConfigLogicService" {
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    export class FamilyConfigLogicService extends FamilyConfigService {
        protected _cacheConnectionService: CacheConnectionService;
    }
}
declare module "sk/service/logic/module/service/SchemeConfigLogicInvoker" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { DataInvoker } from 'foundation/data/common/service/DataInvoker';
    import { DataService } from 'foundation/data/common/service/DataService';
    export class SchemeConfigLogicInvoker extends DataInvoker {
        protected _cacheConnectionService: CacheConnectionService;
        processAsync<T>(context: ContextObject, service: DataService, parameters: any): Promise<ResultObject<T>>;
    }
}
declare module "sk/service/logic/module/service/SchemeConfigLogicService" {
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class SchemeConfigLogicService extends SchemeConfigService {
    }
}
declare module "sk/service/logic/module/symbol/common/SymbolBuilderDeclare" {
    export function SymbolBuilderDeclare(type: string, structureClazz: Function): (target: any) => void;
}
declare module "sk/service/logic/module/symbol/builder/ColorSymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { ConfigPaletteDocumentService } from 'sk/data/family/config/configure/ConfigPaletteDocumentService';
    import { ColorSymbolStructure } from "sk/service/logic/module/symbol/structure/ColorSymbolStructure";
    import { SymbolBuilderConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class ColorSymbolBuilder extends SymbolBuilder {
        protected _paletteDocumentService: ConfigPaletteDocumentService;
        buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<ColorSymbolStructure>>>;
        private buildStructuresAsync;
        private buildStructuresByConfigIdAsync;
        private buildStructuresByColorGroupElement;
        private buildStructuresBySymbolElement;
    }
}
declare module "sk/service/logic/module/symbol/structure/ConfigureSymbolStructure" {
    import { ConfigureElement } from 'sk/data/family/element/config/configure/ConfigureElement';
    import { ConfigureOptionElement } from 'sk/data/family/element/config/configure/ConfigureOptionElement';
    import { ConfigConfigureOptionUnit } from 'sk/service/data/logic/module/logic/ConfigConfigureOptionUnit';
    import { ConfigConfigureUnit } from 'sk/service/data/logic/module/logic/ConfigConfigureUnit';
    import { SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class ConfigureSymbolStructure extends SymbolStructure {
        static createExpandStructureByElement(element: ConfigureElement, optionElement: ConfigureOptionElement): ConfigureSymbolStructure;
        static createExpandStructureByUnit(configureUnit: ConfigConfigureUnit, optionUnit: ConfigConfigureOptionUnit): ConfigureSymbolStructure;
        static createEntiretyStructure(values: Array<ConfigureSymbolValueStructure>): ConfigureSymbolStructure;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: ConfigureSymbolStructure): boolean;
    }
    export class ConfigureSymbolValueStructure extends SymbolValueStructure {
        code: string;
        optionDefault: boolean;
        value?: ConfigureSymbolValueStructure;
        static createByElement(optionElement: ConfigureOptionElement): ConfigureSymbolValueStructure;
        static createValueByElement(element: ConfigureElement, optionElement: ConfigureOptionElement): ConfigureSymbolValueStructure;
        static createByDto(optionDto: ConfigConfigureOptionUnit): ConfigureSymbolValueStructure;
        static createValueByUnit(configConfigureUnit: ConfigConfigureUnit, optionUnit: ConfigConfigureOptionUnit): ConfigureSymbolValueStructure;
        compare(target: ConfigureSymbolValueStructure): boolean;
        loadJson(jconfig: any): void;
        saveJson(): any;
    }
}
declare module "sk/service/logic/module/symbol/builder/ConfigureSymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { ConfigureSymbolStructure } from "sk/service/logic/module/symbol/structure/ConfigureSymbolStructure";
    import { SymbolBuilderConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class ConfigureSymbolBuilder extends SymbolBuilder {
        buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<ConfigureSymbolStructure>>>;
        private getConfigureElementFromDocument;
        private buildStructuresByConfigureElement;
        private buildStructuresByConfigureDtoAsync;
    }
}
declare module "sk/service/logic/module/symbol/structure/DecorateSymbolStructure" {
    import { DecorateElement } from 'sk/data/family/element/config/decorate/DecorateElement';
    import { DecorateItemElement } from 'sk/data/family/element/config/decorate/DecorateItemElement';
    import { ConfigDecorateItemUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateItemUnit';
    import { ConfigDecorateUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateUnit';
    import { SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class DecorateSymbolStructure extends SymbolStructure {
        static createExpandStructureByElement(element: DecorateElement, itemElement: DecorateItemElement): DecorateSymbolStructure;
        static createExpandStructureByUnit(unit: ConfigDecorateUnit, itemUnit: ConfigDecorateItemUnit): DecorateSymbolStructure;
        static createEntiretyStructure(values: Array<DecorateSymbolValueStructure>): DecorateSymbolStructure;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: DecorateSymbolStructure): boolean;
    }
    export class DecorateSymbolValueStructure extends SymbolValueStructure {
        code: string;
        bindingId: string;
        bindingCd: number;
        bindingVersion: string;
        optionDefault: boolean;
        value?: DecorateSymbolValueStructure;
        static createByElement(element: DecorateElement, itemElement: DecorateItemElement): DecorateSymbolValueStructure;
        static createValueByElement(element: DecorateElement, itemElement: DecorateItemElement): DecorateSymbolValueStructure;
        static createByUnit(unit: ConfigDecorateUnit, itemUnit: ConfigDecorateItemUnit): DecorateSymbolValueStructure;
        static createValueByUnit(unit: ConfigDecorateUnit, itemUnit: ConfigDecorateItemUnit): DecorateSymbolValueStructure;
        compare(target: DecorateSymbolValueStructure): boolean;
        loadJson(jconfig: any): void;
        saveJson(): any;
    }
}
declare module "sk/service/logic/module/symbol/builder/DecorateSymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DecorateSymbolStructure } from "sk/service/logic/module/symbol/structure/DecorateSymbolStructure";
    import { SymbolBuilderConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class DecorateSymbolBuilder extends SymbolBuilder {
        buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<DecorateSymbolStructure>>>;
        private getDecorateElementFromDocument;
        private buildStructuresByDecorateElement;
        private buildStructuresByDecorateDtoAsync;
    }
}
declare module "sk/service/logic/module/symbol/builder/MaterialSymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { MaterialSymbolStructure } from "sk/service/logic/module/symbol/structure/MaterialSymbolStructure";
    import { SymbolBuilderConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class MaterialSymbolBuilder extends SymbolBuilder {
        buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<MaterialSymbolStructure>>>;
        private buildStructuresByMaterialDecorateAsync;
    }
}
declare module "sk/service/logic/module/symbol/builder/SizeSymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { SizeSymbolStructure } from "sk/service/logic/module/symbol/structure/SizeSymbolStructure";
    import { SymbolBuilderConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class SizeSymbolBuilder extends SymbolBuilder {
        constructor();
        buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<SizeSymbolStructure>>>;
        private buildStructures;
    }
}
declare module "sk/service/logic/module/symbol/structure/SupplySymbolStructure" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { SymbolAttributeStructure } from "sk/service/logic/module/symbol/structure/SymbolAttributeStructure";
    import { SymbolBusinessStructure, SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolValueStructure } from "sk/service/logic/module/symbol/structure/SymbolValueStructure";
    export class SupplySymbolStructure extends SymbolStructure {
        static createExpandStructure(item: SupplySymbolItem): SupplySymbolStructure;
        static createEntiretyStructure(values: Array<SupplySymbolValueStructure>): SupplySymbolStructure;
        loadJson(jconfig: any): void;
        saveJson(): any;
        compare(target: SupplySymbolStructure): boolean;
        formatBusinessStructure(attribute: SymbolAttributeStructure, unitMap: TypeMap<string, string>): SymbolBusinessStructure;
    }
    export class SupplySymbolValueStructure extends SymbolValueStructure {
        value: string;
        unit: string;
        static create(item: SupplySymbolItem): SupplySymbolValueStructure;
        compare(target: SupplySymbolValueStructure): boolean;
        loadJson(jconfig: any): void;
        saveJson(): any;
    }
    export type SupplySymbolItem = {
        id: string;
        value: string;
        unit: string;
    };
}
declare module "sk/service/logic/module/symbol/builder/SupplySymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { SupplySymbolStructure } from "sk/service/logic/module/symbol/structure/SupplySymbolStructure";
    import { SymbolBuilderConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class SupplySymbolBuilder extends SymbolBuilder {
        constructor();
        buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<SupplySymbolStructure>>>;
        private buildByElement;
    }
}
declare module "sk/service/logic/module/symbol/builder/TextureSymbolBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { SymbolBuilderConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { TextureSymbolStructure } from "sk/service/logic/module/symbol/structure/TextureSymbolStructure";
    import { SymbolBuilder } from "sk/service/logic/module/symbol/builder/SymbolBuilder";
    export class TextureSymbolBuilder extends SymbolBuilder {
        private _resourceController;
        buildAsync(context: DataContext, config: SymbolBuilderConfig): Promise<ResultObject<Types<TextureSymbolStructure>>>;
        private buildStructuresByLinkTypeAsync;
        private buildStructuresByDecorateAsync;
        private buildStructuresByResourceAsync;
        private getResourceUnitAsync;
        private findResourceAsync;
    }
}
declare module "sk/service/logic/module/symbol/decorate/common/DecorateSymbolLogicDeclare" {
    export function DecorateSymbolLogicDeclare(code: string, type: string): (target: any) => void;
}
declare module "sk/service/logic/module/symbol/decorate/handler/MaterialDecorateSymbolComponentHandler" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { DecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { DecorateSymbolHandler } from "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler";
    export class MaterialDecorateSymbolComponentHandler extends DecorateSymbolHandler {
        processAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<DecorateSymbolConfig>>;
    }
}
declare module "sk/service/logic/module/symbol/decorate/handler/MaterialDecorateSymbolInstanceHandler" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DecorateSymbolElement } from 'sk/data/family/element/config/symbol/DecorateSymbolElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { DecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { DecorateSymbolHandler } from "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler";
    export class MaterialDecorateSymbolInstanceHandler extends DecorateSymbolHandler {
        processAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<DecorateSymbolConfig>>;
        protected buildDecorateSymbolElementsAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<Types<DecorateSymbolElement>>>;
    }
}
declare module "sk/service/logic/module/symbol/decorate/util/TextureDecorateSymbolLogicUtil" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DecorateSymbolElement } from 'sk/data/family/element/config/symbol/DecorateSymbolElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { TextureDecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    export class TextureDecorateSymbolLogicUtil {
        protected static _documentService: FamilyDocumentService;
        static buildConfigsByMaterialDecorateAsync(context: DataContext, document: FamilyDocument, configId: string, decorateSymbolElements: Types<DecorateSymbolElement>, textureConfig: TypeMap<string, TextureDecorateSymbolConfig>): Promise<ResultObject>;
        private static buildConfigsByMaterialFamilyAsync;
        private static buildDecorateSymbols;
    }
}
declare module "sk/service/logic/module/symbol/decorate/handler/TextureDecorateSymbolComponentHandler" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { DecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { DecorateSymbolHandler } from "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler";
    export class TextureDecorateSymbolComponentHandler extends DecorateSymbolHandler {
        processAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<DecorateSymbolConfig>>;
    }
}
declare module "sk/service/logic/module/symbol/decorate/handler/TextureDecorateSymbolHandler" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { DecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { DecorateSymbolHandler } from "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler";
    export class TextureDecorateSymbolHandler extends DecorateSymbolHandler {
        processAsync(context: DataContext, document: FamilyDocument, familyDto: FamilyDto): Promise<ResultObject<DecorateSymbolConfig>>;
    }
}
declare module "sk/service/logic/module/symbol/decorate/handler/TextureDecorateSymbolInstanceHandler" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { DecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { MaterialDecorateSymbolInstanceHandler } from "sk/service/logic/module/symbol/decorate/handler/MaterialDecorateSymbolInstanceHandler";
    export class TextureDecorateSymbolInstanceHandler extends MaterialDecorateSymbolInstanceHandler {
        processAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<DecorateSymbolConfig>>;
    }
}
declare module "sk/service/logic/module/symbol/decorate/handler/TextureDecorateSymbolSurfaceHandler" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { FamilyTypeDto } from 'sk/service/data/logic/module/controller/FamilyTypeDto';
    import { DecorateSymbolConfig } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { DecorateSymbolHandler } from "sk/service/logic/module/symbol/decorate/handler/DecorateSymbolHandler";
    export class TextureDecorateSymbolSurfaceHandler extends DecorateSymbolHandler {
        processAsync(context: DataContext, document: FamilyDocument, familyDto: FamilyDto, familyType: FamilyTypeDto): Promise<ResultObject<DecorateSymbolConfig>>;
        private buildDecorateSymbolElementsAsync;
        private buildLayoutDecorateSymbolElements;
        private buildSurfaceDecorateSymbolElements;
    }
}
declare module "sk/service/logic/module/util/FamilyBindingPropertyLogicUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { IDataContext } from 'foundation/service/common/database/IDataContext';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { ConfigVariableController } from 'sk/service/data/logic/module/controller/ConfigVariableController';
    export class FamilyBindingPropertyLogicUtil {
        static buildAssemblyPlaneDocumentBindingPropertyAsync(context: IDataContext, configVariableController: ConfigVariableController, familyDocument: FamilyDocument): Promise<ResultObject>;
        static createReferenceBindingVariablePropertyAsync(context: IDataContext, configVariableController: ConfigVariableController, code: string, componentElement: ComponentElement): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/module/util/ModuleFamilyProcessor" {
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { IDataContext } from 'foundation/service/common/database/IDataContext';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyRelation } from 'sk/data/family/util/FamilyDataDocumentRelationUtil';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { FamilySymbolController } from 'sk/service/data/logic/module/controller/FamilySymbolController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { DecorateSynchronizationService } from 'sk/service/data/logic/module/service/DecorateSynchronizationService';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { VariableAttributeService } from 'sk/service/data/logic/module/service/VariableAttributeService';
    import { FamilySymbolLogicService } from "sk/service/logic/module/symbol/service/FamilySymbolLogicService";
    export type ModuleFamilyProcessInsertData = {
        tenantId: string;
        libraryId: string;
        typeId: string;
        categoryId: string;
    };
    export class ModuleFamilyProcessor extends BaseObject {
        protected _familyController: FamilyController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _familySymbolController: FamilySymbolController;
        protected _logicHistoryService: LogicHistoryService;
        protected _variableAttrService: VariableAttributeService;
        protected _familyDocumentService: FamilyDocumentService;
        protected _logicRelationService: LogicRelationService;
        protected _familySymbolService: FamilySymbolLogicService;
        protected _decorateSyncService: DecorateSynchronizationService;
        getFeaturesRelation(context: MessageRouterContext, familyDto: FamilyDto, target?: Array<FamilyRelation>): FamilyRelation[];
        updateRelationAsync(context: MessageRouterContext, familyDto: FamilyDto, familyDocument?: FamilyDataDocument): Promise<ResultObject>;
        insertFamilyAsync(context: IDataContext, data: ModuleFamilyProcessInsertData): Promise<ResultObject>;
        syncSymbolAsync(context: DataContext, familyDto: FamilyDto, libraryVersion?: string): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/open/router/OpenResourceCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceCategoryDeleteRequest } from 'sk/data/logic/open/message/ResourceCategoryDeleteRequest';
    import { ResourceCategoryDeleteResponse } from 'sk/data/logic/open/message/ResourceCategoryDeleteResponse';
    import { ResourceCategoryInsertRequest } from 'sk/data/logic/open/message/ResourceCategoryInsertRequest';
    import { ResourceCategoryInsertResponse } from 'sk/data/logic/open/message/ResourceCategoryInsertResponse';
    import { ResourceCategoryTreeRequest } from 'sk/data/logic/open/message/ResourceCategoryTreeRequest';
    import { ResourceCategoryTreeResponse } from 'sk/data/logic/open/message/ResourceCategoryTreeResponse';
    import { ResourceCategoryUpdateRequest } from 'sk/data/logic/open/message/ResourceCategoryUpdateRequest';
    import { ResourceCategoryUpdateResponse } from 'sk/data/logic/open/message/ResourceCategoryUpdateResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ResourceCategoryController } from 'sk/service/data/logic/resource/controller/ResourceCategoryController';
    export class OpenResourceCategoryRouter extends MessageRouter {
        processCode: string;
        ResourceCategoryController: any;
        protected _resourceCatedoryController: ResourceCategoryController;
        private _code;
        protected _logicHistoryService: LogicHistoryService;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        onResourceCategoryTreeRequestAsync(context: MessageRouterContext, request: ResourceCategoryTreeRequest, response: ResourceCategoryTreeResponse): Promise<MessageResultType>;
        onResourceCategoryInsertRequestAsync(context: MessageRouterContext, request: ResourceCategoryInsertRequest, response: ResourceCategoryInsertResponse): Promise<MessageResultType>;
        onResourceCategoryUpdateRequestAsync(context: MessageRouterContext, request: ResourceCategoryUpdateRequest, response: ResourceCategoryUpdateResponse): Promise<MessageResultType>;
        onResourceCategoryDeleteRequestAsync(context: MessageRouterContext, request: ResourceCategoryDeleteRequest, response: ResourceCategoryDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/open/router/OpenResourceLibraryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceLibraryListRequest } from 'sk/data/logic/open/message/ResourceLibraryListRequest';
    import { ResourceLibraryListResponse } from 'sk/data/logic/open/message/ResourceLibraryListResponse';
    import { ResourceLibraryController } from 'sk/service/data/logic/warehouse/controller/ResourceLibraryController';
    export class OpenResourceLibraryRouter extends MessageRouter {
        processCode: string;
        protected _resourceLibraryController: ResourceLibraryController;
        private makeFamilySymbolListResponseData;
        onResourceLibraryListRequestAsync(context: MessageRouterContext, request: ResourceLibraryListRequest, response: ResourceLibraryListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/open/router/OpenResourceMaterialCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceMaterialCategoryDeleteRequest } from 'sk/data/logic/open/message/ResourceMaterialCategoryDeleteRequest';
    import { ResourceMaterialCategoryDeleteResponse } from 'sk/data/logic/open/message/ResourceMaterialCategoryDeleteResponse';
    import { ResourceMaterialCategoryInsertRequest } from 'sk/data/logic/open/message/ResourceMaterialCategoryInsertRequest';
    import { ResourceMaterialCategoryInsertResponse } from 'sk/data/logic/open/message/ResourceMaterialCategoryInsertResponse';
    import { ResourceMaterialCategoryTreeRequest } from 'sk/data/logic/open/message/ResourceMaterialCategoryTreeRequest';
    import { ResourceMaterialCategoryTreeResponse } from 'sk/data/logic/open/message/ResourceMaterialCategoryTreeResponse';
    import { ResourceMaterialCategoryUpdateRequest } from 'sk/data/logic/open/message/ResourceMaterialCategoryUpdateRequest';
    import { ResourceMaterialCategoryUpdateResponse } from 'sk/data/logic/open/message/ResourceMaterialCategoryUpdateResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ResourceCategoryController } from 'sk/service/data/logic/resource/controller/ResourceCategoryController';
    export class OpenResourceMaterialCategoryRouter extends MessageRouter {
        processCode: string;
        protected _resourceCatedoryController: ResourceCategoryController;
        protected _logicHistoryService: LogicHistoryService;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        onResourceMaterialCategoryTreeRequestAsync(context: MessageRouterContext, request: ResourceMaterialCategoryTreeRequest, response: ResourceMaterialCategoryTreeResponse): Promise<MessageResultType>;
        onResourceMaterialCategoryInsertRequestAsync(context: MessageRouterContext, request: ResourceMaterialCategoryInsertRequest, response: ResourceMaterialCategoryInsertResponse): Promise<MessageResultType>;
        onResourceMaterialCategoryUpdateRequestAsync(context: MessageRouterContext, request: ResourceMaterialCategoryUpdateRequest, response: ResourceMaterialCategoryUpdateResponse): Promise<MessageResultType>;
        onResourceMaterialCategoryDeleteRequestAsync(context: MessageRouterContext, request: ResourceMaterialCategoryDeleteRequest, response: ResourceMaterialCategoryDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/core/ResourceUtil" {
    import { StorageContentEnum } from 'foundation/data/common/enumeration/StorageContentEnum';
    import { StorageModeEnum } from 'foundation/data/common/enumeration/StorageModeEnum';
    import { StorageResourceTypeEnum } from 'foundation/data/common/enumeration/StorageResourceTypeEnum';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    export class ResourceUtil {
        static parseRemotePath(modeCd: StorageModeEnum, contentCd: StorageContentEnum, typeCd: StorageResourceTypeEnum, id: string, version?: AssetVersionType): string;
    }
}
declare module "sk/service/logic/open/router/OpenResourceMaterialRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { ResourceMaterialDeleteRequest } from 'sk/data/logic/open/message/ResourceMaterialDeleteRequest';
    import { ResourceMaterialDeleteResponse } from 'sk/data/logic/open/message/ResourceMaterialDeleteResponse';
    import { ResourceMaterialGetEffectIdRequest } from 'sk/data/logic/open/message/ResourceMaterialGetEffectIdRequest';
    import { ResourceMaterialGetEffectIdResponse } from 'sk/data/logic/open/message/ResourceMaterialGetEffectIdResponse';
    import { ResourceMaterialGetRequest } from 'sk/data/logic/open/message/ResourceMaterialGetRequest';
    import { ResourceMaterialGetResponse } from 'sk/data/logic/open/message/ResourceMaterialGetResponse';
    import { ResourceMaterialInsertRequest } from 'sk/data/logic/open/message/ResourceMaterialInsertRequest';
    import { ResourceMaterialInsertResponse } from 'sk/data/logic/open/message/ResourceMaterialInsertResponse';
    import { ResourceMaterialPageRequest } from 'sk/data/logic/open/message/ResourceMaterialPageRequest';
    import { ResourceMaterialPageResponse } from 'sk/data/logic/open/message/ResourceMaterialPageResponse';
    import { ResourceMaterialUpdateMaterialRequest } from 'sk/data/logic/open/message/ResourceMaterialUpdateMaterialRequest';
    import { ResourceMaterialUpdateMaterialResponse } from 'sk/data/logic/open/message/ResourceMaterialUpdateMaterialResponse';
    import { ResourceMaterialUpdateRequest } from 'sk/data/logic/open/message/ResourceMaterialUpdateRequest';
    import { ResourceMaterialUpdateResponse } from 'sk/data/logic/open/message/ResourceMaterialUpdateResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ResourceController } from 'sk/service/data/logic/resource/controller/ResourceController';
    import { ResourceMaterialController } from 'sk/service/data/logic/resource/controller/ResourceMaterialController';
    import { ResourceMaterialDto } from 'sk/service/data/logic/resource/controller/ResourceMaterialDto';
    export class OpenResourceMaterialRouter extends MessageRouter {
        processCode: string;
        protected _resourceMaterialController: ResourceMaterialController;
        protected _resourceController: ResourceController;
        protected _ossService: OssConnectionService;
        protected _logicHistoryService: LogicHistoryService;
        onResourceMaterialPageRequestAsync(context: MessageRouterContext, request: ResourceMaterialPageRequest, response: ResourceMaterialPageResponse): Promise<MessageResultType>;
        onResourceMaterialGetEffectIdRequestAsync(context: MessageRouterContext, request: ResourceMaterialGetEffectIdRequest, response: ResourceMaterialGetEffectIdResponse): Promise<MessageResultType>;
        onResourceMaterialGetRequestAsync(context: MessageRouterContext, request: ResourceMaterialGetRequest, response: ResourceMaterialGetResponse): Promise<MessageResultType>;
        onResourceMaterialInsertRequestAsync(context: MessageRouterContext, request: ResourceMaterialInsertRequest, response: ResourceMaterialInsertResponse): Promise<MessageResultType>;
        onResourceMaterialDeleteRequestAsync(context: MessageRouterContext, request: ResourceMaterialDeleteRequest, response: ResourceMaterialDeleteResponse): Promise<MessageResultType>;
        onResourceMaterialUpdateRequestAsync(context: MessageRouterContext, request: ResourceMaterialUpdateRequest, response: ResourceMaterialUpdateResponse): Promise<MessageResultType>;
        onResourceMaterialUpdateMaterialRequestAsync(context: MessageRouterContext, request: ResourceMaterialUpdateMaterialRequest, response: ResourceMaterialUpdateMaterialResponse): Promise<MessageResultType>;
        getResourceMaterialUnitAsync(context: MessageRouterContext, resourceId: string): Promise<ResourceMaterialDto>;
        setEffectResourceIdByResourceIdAsync(context: MessageRouterContext, resourceId: string, effectResourceId: string): Promise<ResultObject>;
        createConvertEventAsync(context: MessageRouterContext, resourceId: string, libraryId: string, param?: any): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/open/router/OpenResourceResourceRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { HttpDeviceService } from 'cross/core/device/http/HttpDeviceService';
    import { MessageRequest } from 'cross/data/module/message/MessageRequest';
    import { MessageResponse } from 'cross/data/module/message/MessageResponse';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageResultEnum } from 'cross/data/module/message/MessageResultEnum';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MessageRouterService } from 'foundation/service/common/router/message/MessageRouterService';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { ResourceResourceDeleteRequest } from 'sk/data/logic/open/message/ResourceResourceDeleteRequest';
    import { ResourceResourceDeleteResponse } from 'sk/data/logic/open/message/ResourceResourceDeleteResponse';
    import { ResourceResourceGetRequest } from 'sk/data/logic/open/message/ResourceResourceGetRequest';
    import { ResourceResourceGetResponse } from 'sk/data/logic/open/message/ResourceResourceGetResponse';
    import { ResourceResourceInsertRequest } from 'sk/data/logic/open/message/ResourceResourceInsertRequest';
    import { ResourceResourceInsertResponse } from 'sk/data/logic/open/message/ResourceResourceInsertResponse';
    import { ResourceResourcePageRequest } from 'sk/data/logic/open/message/ResourceResourcePageRequest';
    import { ResourceResourcePageResponse } from 'sk/data/logic/open/message/ResourceResourcePageResponse';
    import { ResourceResourceUpdateModelRequest } from 'sk/data/logic/open/message/ResourceResourceUpdateModelRequest';
    import { ResourceResourceUpdateModelResponse } from 'sk/data/logic/open/message/ResourceResourceUpdateModelResponse';
    import { ResourceResourceUpdateRequest } from 'sk/data/logic/open/message/ResourceResourceUpdateRequest';
    import { ResourceResourceUpdateResponse } from 'sk/data/logic/open/message/ResourceResourceUpdateResponse';
    import { LibraryVersionController } from 'sk/service/data/logic/module/controller/LibraryVersionController';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ResourceCategoryController } from 'sk/service/data/logic/resource/controller/ResourceCategoryController';
    import { ResourceController } from 'sk/service/data/logic/resource/controller/ResourceController';
    import { ResourceTypeController } from 'sk/service/data/logic/resource/controller/ResourceTypeController';
    export class OpenResourceResourceRouter extends MessageRouter {
        processCode: string;
        protected _httpService: HttpDeviceService;
        protected _ossService: OssConnectionService;
        protected _messageRouterService: MessageRouterService;
        protected _libraryVersionController: LibraryVersionController;
        protected _resourceController: ResourceController;
        protected _resourceTypeController: ResourceTypeController;
        protected _resourceCategoryController: ResourceCategoryController;
        protected _publishFamilyInfoController: PublishFamilyInfoController;
        protected _environmentService: EnvironmentService;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        maxVersionAsync(context: IContext, typeCd: string, id: string): Promise<string>;
        cleanResourceAsync(typeCd: string, id: string, context: MessageRouterContext, request: MessageRequest, response: MessageResponse): Promise<MessageResultEnum>;
        private buildCategoryNamesAsync;
        onResourceResourcePageRequestAsync(context: MessageRouterContext, request: ResourceResourcePageRequest, response: ResourceResourcePageResponse): Promise<MessageResultType>;
        onResourceResourceGetRequestAsync(context: MessageRouterContext, request: ResourceResourceGetRequest, response: ResourceResourceGetResponse): Promise<MessageResultType>;
        onResourceResourceInsertRequestAsync(context: MessageRouterContext, request: ResourceResourceInsertRequest, response: ResourceResourceInsertResponse): Promise<MessageResultType>;
        onResourceResourceUpdateRequestAsync(context: MessageRouterContext, request: ResourceResourceUpdateRequest, response: ResourceResourceUpdateResponse): Promise<MessageResultType>;
        onResourceResourceDeleteRequestAsync(context: MessageRouterContext, request: ResourceResourceDeleteRequest, response: ResourceResourceDeleteResponse): Promise<MessageResultType>;
        onResourceResourceUpdateModelRequestAsync(context: MessageRouterContext, request: ResourceResourceUpdateModelRequest, response: ResourceResourceUpdateModelResponse): Promise<MessageResultType>;
        createConvertEventAsync(context: MessageRouterContext, resourceId: string, libraryId: string, param?: any): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/perspective/router/PerspectiveConfigDecorateItemRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { ConfigDecorateItemGetDefaultRequest } from 'sk/data/logic/perspective/message/ConfigDecorateItemGetDefaultRequest';
    import { ConfigDecorateItemGetDefaultResponse } from 'sk/data/logic/perspective/message/ConfigDecorateItemGetDefaultResponse';
    import { ConfigDecorateItemPageRequest } from 'sk/data/logic/perspective/message/ConfigDecorateItemPageRequest';
    import { ConfigDecorateItemPageResponse } from 'sk/data/logic/perspective/message/ConfigDecorateItemPageResponse';
    import { ConfigDecorateItemSyncRequest } from 'sk/data/logic/perspective/message/ConfigDecorateItemSyncRequest';
    import { ConfigDecorateItemSyncResponse } from 'sk/data/logic/perspective/message/ConfigDecorateItemSyncResponse';
    import { ProductShowPerspectiveController } from 'sk/service/data/logic/digitization/controller/ProductShowPerspectiveController';
    import { DesignInterfaceCacheService } from 'sk/service/data/logic/digitization/service/DesignInterfaceCacheService';
    import { ConfigDecorateItemController } from 'sk/service/data/logic/module/controller/ConfigDecorateItemController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { PatternController } from 'sk/service/data/logic/module/controller/PatternController';
    import { ProductController } from 'sk/service/data/logic/module/controller/ProductController';
    import { DecorateSynchronizationService } from 'sk/service/data/logic/module/service/DecorateSynchronizationService';
    import { ModuleConfigDecorateItemController } from 'sk/service/data/logic/perspective/controller/ModuleConfigDecorateItemController';
    export class PerspectiveConfigDecorateItemRouter extends MessageRouter {
        processCode: string;
        protected _familyController: FamilyController;
        protected _patternController: PatternController;
        private _configDecorateController;
        protected _configDecorateItemController: ConfigDecorateItemController;
        protected _moduleConfigDecorateItemController: ModuleConfigDecorateItemController;
        protected _productShowPerspectiveController: ProductShowPerspectiveController;
        protected _productController: ProductController;
        protected _familyDocumentService: FamilyDocumentService;
        protected _patternDocumentService: PatternDocumentService;
        protected _decorateSyncService: DecorateSynchronizationService;
        protected _interfaceCacheService: DesignInterfaceCacheService;
        private syncDecorateItemsAsync;
        private syncFamilyDocumentDecorateItemsAsync;
        private syncPatternDocumentDecorateItemsAsync;
        private syncDocumentDecorateItemsAsync;
        private syncSystemDecorateItemsAsync;
        private makeDecorateItemPageResponseData;
        onConfigDecorateItemPageRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemPageRequest, response: ConfigDecorateItemPageResponse): Promise<MessageResultType>;
        onConfigDecorateItemGetDefaultRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemGetDefaultRequest, response: ConfigDecorateItemGetDefaultResponse): Promise<MessageResultType>;
        onConfigDecorateItemSyncRequestAsync(context: MessageRouterContext, request: ConfigDecorateItemSyncRequest, response: ConfigDecorateItemSyncResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/perspective/router/PerspectiveProductShowProductRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ProductShowProductSyncRequest } from 'sk/data/logic/perspective/message/ProductShowProductSyncRequest';
    import { ProductShowProductSyncResponse } from 'sk/data/logic/perspective/message/ProductShowProductSyncResponse';
    import { ProductShowCategoryItemController } from 'sk/service/data/logic/module/controller/ProductShowCategoryItemController';
    import { ModuleProductShowProductController } from 'sk/service/data/logic/perspective/controller/ModuleProductShowProductController';
    export class PerspectiveProductShowProductRouter extends MessageRouter {
        processCode: string;
        protected _moduleProductShowProductController: ModuleProductShowProductController;
        protected _productShowCategoryItemController: ProductShowCategoryItemController;
        onProductShowProductSyncRequestAsync(context: MessageRouterContext, request: ProductShowProductSyncRequest, response: ProductShowProductSyncResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/produce/router/ProduceFactoryParameterRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { FactoryParameterListRequest } from 'sk/data/logic/produce/message/FactoryParameterListRequest';
    import { FactoryParameterListResponse, FactoryParameterListResponseItemsVo } from 'sk/data/logic/produce/message/FactoryParameterListResponse';
    import { FactoryLibraryController } from 'sk/service/data/logic/produce/controller/FactoryLibraryController';
    import { FactoryParameterController } from 'sk/service/data/logic/produce/controller/FactoryParameterController';
    export class ProduceFactoryParameterRouter extends MessageRouter {
        processCode: string;
        protected _factoryLibraryController: FactoryLibraryController;
        protected _factoryParameterController: FactoryParameterController;
        onFactoryParameterListRequestAsync(context: MessageRouterContext, request: FactoryParameterListRequest, response: FactoryParameterListResponse): Promise<MessageResultType>;
        makeDefaultParameter(factoryId?: string): StructureTypes<FactoryParameterListResponseItemsVo>;
        makeOneDefaultParameter(items: StructureTypes<FactoryParameterListResponseItemsVo>): StructureTypes<FactoryParameterListResponseItemsVo>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/router/LibraryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { LibraryPageRequest } from 'sk/data/logic/resource/message/LibraryPageRequest';
    import { LibraryPageResponse } from 'sk/data/logic/resource/message/LibraryPageResponse';
    export class LibraryRouter extends MessageRouter {
        processCode: string;
        onLibraryPageRequestAsync(context: MessageRouterContext, request: LibraryPageRequest, response: LibraryPageResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/router/ResourceCategoryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { CategoryDeleteRequest } from 'sk/data/logic/resource/message/CategoryDeleteRequest';
    import { CategoryDeleteResponse } from 'sk/data/logic/resource/message/CategoryDeleteResponse';
    import { CategoryGetRequest } from 'sk/data/logic/resource/message/CategoryGetRequest';
    import { CategoryGetResponse } from 'sk/data/logic/resource/message/CategoryGetResponse';
    import { CategoryInsertRequest } from 'sk/data/logic/resource/message/CategoryInsertRequest';
    import { CategoryInsertResponse } from 'sk/data/logic/resource/message/CategoryInsertResponse';
    import { CategorySearchRequest } from 'sk/data/logic/resource/message/CategorySearchRequest';
    import { CategorySearchResponse } from 'sk/data/logic/resource/message/CategorySearchResponse';
    import { CategorySortRequest } from 'sk/data/logic/resource/message/CategorySortRequest';
    import { CategorySortResponse } from 'sk/data/logic/resource/message/CategorySortResponse';
    import { CategoryTreeRequest } from 'sk/data/logic/resource/message/CategoryTreeRequest';
    import { CategoryTreeResponse } from 'sk/data/logic/resource/message/CategoryTreeResponse';
    import { CategoryUpdateRequest } from 'sk/data/logic/resource/message/CategoryUpdateRequest';
    import { CategoryUpdateResponse } from 'sk/data/logic/resource/message/CategoryUpdateResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ResourceCategoryController } from 'sk/service/data/logic/resource/controller/ResourceCategoryController';
    import { ResourceController } from 'sk/service/data/logic/resource/controller/ResourceController';
    export class ResourceCategoryRouter extends MessageRouter {
        processCode: string;
        private _categoryId;
        protected _resourceCategoryController: ResourceCategoryController;
        protected _resourceController: ResourceController;
        protected _logicHistoryService: LogicHistoryService;
        private setTreeCategoryItemVo;
        private recurseSetTreeCategoryItemVo;
        private setTreeCategoryItemNode;
        private makeCategoryTreeResponseData;
        private loopMakeCategoryTreeResponseItemsVo;
        private buildCategoryTreeResponseItemsVo;
        onCategoryTreeRequestAsync(context: MessageRouterContext, request: CategoryTreeRequest, response: CategoryTreeResponse): Promise<MessageResultType>;
        onCategoryGetRequestAsync(context: MessageRouterContext, request: CategoryGetRequest, response: CategoryGetResponse): Promise<MessageResultType>;
        onCategorySearchRequestAsync(context: MessageRouterContext, request: CategorySearchRequest, response: CategorySearchResponse): Promise<MessageResultType>;
        onCategorySortRequestAsync(context: MessageRouterContext, request: CategorySortRequest, response: CategorySortResponse): Promise<MessageResultType>;
        onCategoryInsertRequestAsync(context: MessageRouterContext, request: CategoryInsertRequest, response: CategoryInsertResponse): Promise<MessageResultType>;
        onCategoryUpdateRequestAsync(context: MessageRouterContext, request: CategoryUpdateRequest, response: CategoryUpdateResponse): Promise<MessageResultType>;
        onCategoryDeleteRequestAsync(context: MessageRouterContext, request: CategoryDeleteRequest, response: CategoryDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/router/ResourceGraphRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceGraphUpdateContentRequest } from 'sk/data/logic/resource/message/ResourceGraphUpdateContentRequest';
    import { ResourceGraphUpdateContentResponse } from 'sk/data/logic/resource/message/ResourceGraphUpdateContentResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ResourceController } from 'sk/service/data/logic/resource/controller/ResourceController';
    import { ResourceStorageService } from 'sk/service/data/logic/resource/storage/ResourceStorageService';
    export class ResourceGraphRouter extends MessageRouter {
        processCode: string;
        protected _storageService: ResourceStorageService;
        protected _graphController: ResourceController;
        protected _logicHistoryService: LogicHistoryService;
        onResourceGraphUpdateContentRequestAsync(context: MessageRouterContext, request: ResourceGraphUpdateContentRequest, response: ResourceGraphUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/router/ResourceMaterialRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceMaterialDeleteRequest } from 'sk/data/logic/resource/message/ResourceMaterialDeleteRequest';
    import { ResourceMaterialDeleteResponse } from 'sk/data/logic/resource/message/ResourceMaterialDeleteResponse';
    import { ResourceMaterialGetEffectIdRequest } from 'sk/data/logic/resource/message/ResourceMaterialGetEffectIdRequest';
    import { ResourceMaterialGetEffectIdResponse } from 'sk/data/logic/resource/message/ResourceMaterialGetEffectIdResponse';
    import { ResourceMaterialGetRequest } from 'sk/data/logic/resource/message/ResourceMaterialGetRequest';
    import { ResourceMaterialGetResponse } from 'sk/data/logic/resource/message/ResourceMaterialGetResponse';
    import { ResourceMaterialInsertRequest } from 'sk/data/logic/resource/message/ResourceMaterialInsertRequest';
    import { ResourceMaterialInsertResponse } from 'sk/data/logic/resource/message/ResourceMaterialInsertResponse';
    import { ResourceMaterialPageRequest } from 'sk/data/logic/resource/message/ResourceMaterialPageRequest';
    import { ResourceMaterialPageResponse } from 'sk/data/logic/resource/message/ResourceMaterialPageResponse';
    import { ResourceMaterialUpdateRequest } from 'sk/data/logic/resource/message/ResourceMaterialUpdateRequest';
    import { ResourceMaterialUpdateResponse } from 'sk/data/logic/resource/message/ResourceMaterialUpdateResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { ResourceMaterialController } from 'sk/service/data/logic/resource/controller/ResourceMaterialController';
    export class ResourceMaterialRouter extends MessageRouter {
        processCode: string;
        protected _resourceMaterialController: ResourceMaterialController;
        protected _logicHistoryService: LogicHistoryService;
        onResourceMaterialPageRequestAsync(context: MessageRouterContext, request: ResourceMaterialPageRequest, response: ResourceMaterialPageResponse): Promise<MessageResultType>;
        onResourceMaterialGetEffectIdRequestAsync(context: MessageRouterContext, request: ResourceMaterialGetEffectIdRequest, response: ResourceMaterialGetEffectIdResponse): Promise<MessageResultType>;
        onResourceMaterialGetRequestAsync(context: MessageRouterContext, request: ResourceMaterialGetRequest, response: ResourceMaterialGetResponse): Promise<MessageResultType>;
        onResourceMaterialInsertRequestAsync(context: MessageRouterContext, request: ResourceMaterialInsertRequest, response: ResourceMaterialInsertResponse): Promise<MessageResultType>;
        onResourceMaterialDeleteRequestAsync(context: MessageRouterContext, request: ResourceMaterialDeleteRequest, response: ResourceMaterialDeleteResponse): Promise<MessageResultType>;
        onResourceMaterialUpdateRequestAsync(context: MessageRouterContext, request: ResourceMaterialUpdateRequest, response: ResourceMaterialUpdateResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/router/ResourcePictureRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourcePictureDeleteRequest } from 'sk/data/logic/resource/message/ResourcePictureDeleteRequest';
    import { ResourcePictureDeleteResponse } from 'sk/data/logic/resource/message/ResourcePictureDeleteResponse';
    import { ResourcePictureGetRequest } from 'sk/data/logic/resource/message/ResourcePictureGetRequest';
    import { ResourcePictureGetResponse } from 'sk/data/logic/resource/message/ResourcePictureGetResponse';
    import { ResourcePictureInsertRequest } from 'sk/data/logic/resource/message/ResourcePictureInsertRequest';
    import { ResourcePictureInsertResponse } from 'sk/data/logic/resource/message/ResourcePictureInsertResponse';
    import { ResourcePicturePageRequest } from 'sk/data/logic/resource/message/ResourcePicturePageRequest';
    import { ResourcePicturePageResponse } from 'sk/data/logic/resource/message/ResourcePicturePageResponse';
    import { ResourcePictureUpdateRequest } from 'sk/data/logic/resource/message/ResourcePictureUpdateRequest';
    import { ResourcePictureUpdateResponse } from 'sk/data/logic/resource/message/ResourcePictureUpdateResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    export class ResourcePictureRouter extends MessageRouter {
        processCode: string;
        protected _logicHistoryService: LogicHistoryService;
        onResourcePicturePageRequestAsync(context: MessageRouterContext, request: ResourcePicturePageRequest, response: ResourcePicturePageResponse): Promise<MessageResultType>;
        onResourcePictureGetRequestAsync(context: MessageRouterContext, request: ResourcePictureGetRequest, response: ResourcePictureGetResponse): Promise<MessageResultType>;
        onResourcePictureInsertRequestAsync(context: MessageRouterContext, request: ResourcePictureInsertRequest, response: ResourcePictureInsertResponse): Promise<MessageResultType>;
        onResourcePictureDeleteRequestAsync(context: MessageRouterContext, request: ResourcePictureDeleteRequest, response: ResourcePictureDeleteResponse): Promise<MessageResultType>;
        onResourcePictureUpdateRequestAsync(context: MessageRouterContext, request: ResourcePictureUpdateRequest, response: ResourcePictureUpdateResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/router/ResourceRouter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { HttpDeviceService } from 'cross/core/device/http/HttpDeviceService';
    import { MessageRequest } from 'cross/data/module/message/MessageRequest';
    import { MessageResponse } from 'cross/data/module/message/MessageResponse';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageResultEnum } from 'cross/data/module/message/MessageResultEnum';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { MessageRouterService } from 'foundation/service/common/router/message/MessageRouterService';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { ResourceChangeRequest } from 'sk/data/logic/resource/message/ResourceChangeRequest';
    import { ResourceChangeResponse } from 'sk/data/logic/resource/message/ResourceChangeResponse';
    import { ResourceDeleteRequest } from 'sk/data/logic/resource/message/ResourceDeleteRequest';
    import { ResourceDeleteResponse } from 'sk/data/logic/resource/message/ResourceDeleteResponse';
    import { ResourceDownloadRequest } from 'sk/data/logic/resource/message/ResourceDownloadRequest';
    import { ResourceDownloadResponse } from 'sk/data/logic/resource/message/ResourceDownloadResponse';
    import { ResourceGetInfoRequest } from 'sk/data/logic/resource/message/ResourceGetInfoRequest';
    import { ResourceGetInfoResponse } from 'sk/data/logic/resource/message/ResourceGetInfoResponse';
    import { ResourceGetRequest } from 'sk/data/logic/resource/message/ResourceGetRequest';
    import { ResourceGetResponse } from 'sk/data/logic/resource/message/ResourceGetResponse';
    import { ResourceInsertFileRequest } from 'sk/data/logic/resource/message/ResourceInsertFileRequest';
    import { ResourceInsertFileResponse } from 'sk/data/logic/resource/message/ResourceInsertFileResponse';
    import { ResourceInsertRequest } from 'sk/data/logic/resource/message/ResourceInsertRequest';
    import { ResourceInsertResponse } from 'sk/data/logic/resource/message/ResourceInsertResponse';
    import { ResourcePageRequest } from 'sk/data/logic/resource/message/ResourcePageRequest';
    import { ResourcePageResponse } from 'sk/data/logic/resource/message/ResourcePageResponse';
    import { ResourceSearchRequest } from 'sk/data/logic/resource/message/ResourceSearchRequest';
    import { ResourceSearchResponse } from 'sk/data/logic/resource/message/ResourceSearchResponse';
    import { ResourceUpdateCurveRequest } from 'sk/data/logic/resource/message/ResourceUpdateCurveRequest';
    import { ResourceUpdateCurveResponse } from 'sk/data/logic/resource/message/ResourceUpdateCurveResponse';
    import { ResourceUpdateDrawingGraphRequest } from 'sk/data/logic/resource/message/ResourceUpdateDrawingGraphRequest';
    import { ResourceUpdateDrawingGraphResponse } from 'sk/data/logic/resource/message/ResourceUpdateDrawingGraphResponse';
    import { ResourceUpdateDrawingTemplateRequest } from 'sk/data/logic/resource/message/ResourceUpdateDrawingTemplateRequest';
    import { ResourceUpdateDrawingTemplateResponse } from 'sk/data/logic/resource/message/ResourceUpdateDrawingTemplateResponse';
    import { ResourceUpdateEffectRequest } from 'sk/data/logic/resource/message/ResourceUpdateEffectRequest';
    import { ResourceUpdateEffectResponse } from 'sk/data/logic/resource/message/ResourceUpdateEffectResponse';
    import { ResourceUpdateFbxmodelRequest } from 'sk/data/logic/resource/message/ResourceUpdateFbxmodelRequest';
    import { ResourceUpdateFbxmodelResponse } from 'sk/data/logic/resource/message/ResourceUpdateFbxmodelResponse';
    import { ResourceUpdateIesRequest } from 'sk/data/logic/resource/message/ResourceUpdateIesRequest';
    import { ResourceUpdateIesResponse } from 'sk/data/logic/resource/message/ResourceUpdateIesResponse';
    import { ResourceUpdateMaterialRequest } from 'sk/data/logic/resource/message/ResourceUpdateMaterialRequest';
    import { ResourceUpdateMaterialResponse } from 'sk/data/logic/resource/message/ResourceUpdateMaterialResponse';
    import { ResourceUpdateModelRequest } from 'sk/data/logic/resource/message/ResourceUpdateModelRequest';
    import { ResourceUpdateModelResponse } from 'sk/data/logic/resource/message/ResourceUpdateModelResponse';
    import { ResourceUpdatePictureRequest } from 'sk/data/logic/resource/message/ResourceUpdatePictureRequest';
    import { ResourceUpdatePictureResponse } from 'sk/data/logic/resource/message/ResourceUpdatePictureResponse';
    import { ResourceUpdateRequest } from 'sk/data/logic/resource/message/ResourceUpdateRequest';
    import { ResourceUpdateResponse } from 'sk/data/logic/resource/message/ResourceUpdateResponse';
    import { ResourceUpgradeRequest } from 'sk/data/logic/resource/message/ResourceUpgradeRequest';
    import { ResourceUpgradeResponse } from 'sk/data/logic/resource/message/ResourceUpgradeResponse';
    import { LogicHistoryService } from 'sk/service/data/logic/module/service/LogicHistoryService';
    import { LogicRelationService } from 'sk/service/data/logic/module/service/LogicRelationService';
    import { ResourceCategoryController } from 'sk/service/data/logic/resource/controller/ResourceCategoryController';
    import { ResourceController } from 'sk/service/data/logic/resource/controller/ResourceController';
    import { ResourceTypeController } from 'sk/service/data/logic/resource/controller/ResourceTypeController';
    import { ResourceMaterialUnit } from 'sk/service/data/logic/resource/logic/ResourceMaterialUnit';
    import { ResourceStorageService } from 'sk/service/data/logic/resource/storage/ResourceStorageService';
    export class ResourceRouter extends MessageRouter {
        processCode: string;
        protected _httpService: HttpDeviceService;
        protected _ossService: OssConnectionService;
        protected _environmentService: EnvironmentService;
        protected _messageRouterService: MessageRouterService;
        protected _storageService: ResourceStorageService;
        protected _resourceTypeController: ResourceTypeController;
        protected _resourceCategoryController: ResourceCategoryController;
        protected _resourceController: ResourceController;
        protected _logicHistoryService: LogicHistoryService;
        protected _logicRelationService: LogicRelationService;
        maxVersionAsync(context: IContext, typeCd: string, id: string): Promise<string>;
        cleanResourceAsync(typeCd: string, id: string, context: MessageRouterContext, request: MessageRequest, response: MessageResponse): Promise<MessageResultEnum>;
        private buildCategoryNamesAsync;
        onResourcePageRequestAsync(context: MessageRouterContext, request: ResourcePageRequest, response: ResourcePageResponse): Promise<MessageResultType>;
        onResourceGetRequestAsync(context: MessageRouterContext, request: ResourceGetRequest, response: ResourceGetResponse): Promise<MessageResultType>;
        onResourceGetInfoRequestAsync(context: MessageRouterContext, request: ResourceGetInfoRequest, response: ResourceGetInfoResponse): Promise<MessageResultType>;
        onResourceSearchRequestAsync(context: MessageRouterContext, request: ResourceSearchRequest, response: ResourceSearchResponse): Promise<MessageResultType>;
        onResourceInsertFileRequestAsync(context: MessageRouterContext, request: ResourceInsertFileRequest, response: ResourceInsertFileResponse): Promise<MessageResultType>;
        onResourceInsertRequestAsync(context: MessageRouterContext, request: ResourceInsertRequest, response: ResourceInsertResponse): Promise<MessageResultType>;
        onResourceDownloadRequestAsync(context: MessageRouterContext, request: ResourceDownloadRequest, response: ResourceDownloadResponse): Promise<MessageResultType>;
        onResourceUpdateRequestAsync(context: MessageRouterContext, request: ResourceUpdateRequest, response: ResourceUpdateResponse): Promise<MessageResultType>;
        onResourceUpdateCurveRequestAsync(context: MessageRouterContext, request: ResourceUpdateCurveRequest, response: ResourceUpdateCurveResponse): Promise<MessageResultType>;
        onResourceUpdatePictureRequestAsync(context: MessageRouterContext, request: ResourceUpdatePictureRequest, response: ResourceUpdatePictureResponse): Promise<MessageResultType>;
        onResourceUpdateEffectRequestAsync(context: MessageRouterContext, request: ResourceUpdateEffectRequest, response: ResourceUpdateEffectResponse): Promise<MessageResultType>;
        onResourceUpdateMaterialRequestAsync(context: MessageRouterContext, request: ResourceUpdateMaterialRequest, response: ResourceUpdateMaterialResponse): Promise<MessageResultType>;
        uploadStorageAsync(context: MessageRouterContext, fileName: string, sourcePath: string, targetPath: string): Promise<ResultObject>;
        onResourceUpdateDrawingGraphRequestAsync(context: MessageRouterContext, request: ResourceUpdateDrawingGraphRequest, response: ResourceUpdateDrawingGraphResponse): Promise<MessageResultType>;
        onResourceUpdateDrawingTemplateRequestAsync(context: MessageRouterContext, request: ResourceUpdateDrawingTemplateRequest, response: ResourceUpdateDrawingTemplateResponse): Promise<MessageResultType>;
        onResourceUpdateIesRequestAsync(context: MessageRouterContext, request: ResourceUpdateIesRequest, response: ResourceUpdateIesResponse): Promise<MessageResultType>;
        onResourceUpdateFbxmodelRequestAsync(context: MessageRouterContext, request: ResourceUpdateFbxmodelRequest, response: ResourceUpdateFbxmodelResponse): Promise<MessageResultType>;
        onResourceUpdateModelRequestAsync(context: MessageRouterContext, request: ResourceUpdateModelRequest, response: ResourceUpdateModelResponse): Promise<MessageResultType>;
        onResourceDeleteRequestAsync(context: MessageRouterContext, request: ResourceDeleteRequest, response: ResourceDeleteResponse): Promise<MessageResultType>;
        onResourceUpgradeRequestAsync(context: MessageRouterContext, request: ResourceUpgradeRequest, response: ResourceUpgradeResponse): Promise<MessageResultType>;
        onResourceChangeRequestAsync(context: MessageRouterContext, request: ResourceChangeRequest, response: ResourceChangeResponse): Promise<MessageResultType>;
        getResourceMaterialUnitAsync(context: MessageRouterContext, resourceId: string): Promise<ResourceMaterialUnit>;
        setEffectResourceIdByResourceIdAsync(context: MessageRouterContext, resourceId: string, effectResourceId: string): Promise<ResultObject>;
        createConvertEventAsync(context: MessageRouterContext, resourceId: string, libraryId: string, param?: any): Promise<ResultObject>;
        protected updateDataAsync(sourceFileName: string, id: string, context: MessageRouterContext): Promise<ResultObject>;
        protected checkMaterialChangedByResourceInfoAsync(context: IContext, materialObject: any, texturePath: string, localPath: string, newName: string, quality?: string): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/resource/router/ResourceTypeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceTypeGetRequest } from 'sk/data/logic/resource/message/ResourceTypeGetRequest';
    import { ResourceTypeGetResponse } from 'sk/data/logic/resource/message/ResourceTypeGetResponse';
    import { ResourceTypeSearchRequest } from 'sk/data/logic/resource/message/ResourceTypeSearchRequest';
    import { ResourceTypeSearchResponse } from 'sk/data/logic/resource/message/ResourceTypeSearchResponse';
    import { ResourceTypeController } from 'sk/service/data/logic/resource/controller/ResourceTypeController';
    export class ResourceTypeRouter extends MessageRouter {
        processCode: string;
        protected _resourceTypeController: ResourceTypeController;
        onResourceTypeGetRequestAsync(context: MessageRouterContext, request: ResourceTypeGetRequest, response: ResourceTypeGetResponse): Promise<MessageResultType>;
        onResourceTypeSearchRequestAsync(context: MessageRouterContext, request: ResourceTypeSearchRequest, response: ResourceTypeSearchResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/service/DynamicLoadDataConnectionPoolIntervalService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { DataConnectionService } from 'foundation/service/common/database/DataConnectionService';
    import { DatabaseListResponseItemsVo } from 'sk/data/logic/warehouse/message/DatabaseListResponse';
    export class DynamicLoadDataConnectionPoolIntervalService extends Service {
        protected _threadService: ThreadService;
        protected _dataConnectionService: DataConnectionService;
        private _intervalTime;
        constructor();
        initializeConfig(jconfig: any): void;
        initAsync(context?: IContext): Promise<void>;
        onActive(): void;
        private loadConnectionPoolsAsync;
        private fetchDatabaseListAsync;
        appendDynamicPools(items: StructureTypes<DatabaseListResponseItemsVo>): void;
        private validateResponseItem;
        private appendDynamicPoolsByDatabase;
        getDataConnectionInfo(): {
            allocCount: number;
            freeCount: number;
        };
    }
}
declare module "sk/service/logic/service/FamilyIconRenderService" {
    import { Service } from 'cross/runtime/module/Service';
    import { HttpDeviceService } from 'cross/core/device/http/HttpDeviceService';
    import { BatchCreateResponse } from 'sk/data/logic/digitization/message/BatchCreateResponse';
    export class FamilyIconRenderService extends Service {
        protected _scene: any;
        protected _config: any;
        protected _httpService: HttpDeviceService;
        iconRenderByFamilyInforIdsAsync(familyInfoIds: Array<string>): Promise<BatchCreateResponse>;
    }
}
declare module "sk/service/logic/service/MaterialFamilyIconGeneralService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    export class MaterialFamilyIconGeneralService extends Service {
        protected _ossConnectionService: OssConnectionService;
        generalFamilyIconAsync(context: IContext, familyObject: Array<FamilyObject>): Promise<ResultObject>;
    }
    export type FamilyObject = {
        familyId: string;
        familyInfoIds: string[];
        features: string;
    };
}
declare module "sk/service/logic/system/router/SystemCodeRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { CodeListItemsRequest } from 'sk/data/logic/system/message/CodeListItemsRequest';
    import { CodeListItemsResponse } from 'sk/data/logic/system/message/CodeListItemsResponse';
    import { CodeController } from 'sk/service/data/logic/system/controller/CodeController';
    import { CodeItemController } from 'sk/service/data/logic/system/controller/CodeItemController';
    export class SystemCodeRouter extends MessageRouter {
        processCode: string;
        protected _codeItemController: CodeItemController;
        protected _codeController: CodeController;
        onCodeListItemsRequestAsync(context: MessageRouterContext, request: CodeListItemsRequest, response: CodeListItemsResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/system/router/SystemPluginRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { PluginApplicationPluginPublishRequest } from 'sk/data/logic/system/message/PluginApplicationPluginPublishRequest';
    import { PluginApplicationPluginPublishResponse } from 'sk/data/logic/system/message/PluginApplicationPluginPublishResponse';
    import { PluginListRequest } from 'sk/data/logic/system/message/PluginListRequest';
    import { PluginListResponse } from 'sk/data/logic/system/message/PluginListResponse';
    import { PluginListVersionRequest } from 'sk/data/logic/system/message/PluginListVersionRequest';
    import { PluginListVersionResponse } from 'sk/data/logic/system/message/PluginListVersionResponse';
    import { PluginLoadRequest } from 'sk/data/logic/system/message/PluginLoadRequest';
    import { PluginLoadResponse } from 'sk/data/logic/system/message/PluginLoadResponse';
    import { PluginController } from 'sk/service/data/logic/plugin/controller/PluginController';
    import { PluginVersionController } from 'sk/service/data/logic/plugin/controller/PluginVersionController';
    import { PluginVersionUnit } from 'sk/service/data/logic/plugin/logic/PluginVersionUnit';
    import { PluginStorageService } from 'sk/service/data/logic/plugin/storage/PluginStorageService';
    import { ApplicationController } from 'sk/service/data/logic/system/controller/ApplicationController';
    import { ApplicationPluginController } from 'sk/service/data/logic/system/controller/ApplicationPluginController';
    export class SystemPluginRouter extends MessageRouter {
        processCode: string;
        protected _pluginStorageService: PluginStorageService;
        protected _pluginController: PluginController;
        protected _pluginVersionController: PluginVersionController;
        protected _applicationController: ApplicationController;
        protected _applicationPluginController: ApplicationPluginController;
        onPluginApplicationPluginPublishRequestAsync(context: MessageRouterContext, request: PluginApplicationPluginPublishRequest, response: PluginApplicationPluginPublishResponse): Promise<MessageResultType>;
        onPluginListRequestAsync(context: MessageRouterContext, request: PluginListRequest, response: PluginListResponse): Promise<MessageResultType>;
        onPluginListVersionRequestAsync(context: MessageRouterContext, request: PluginListVersionRequest, response: PluginListVersionResponse): Promise<MessageResultType>;
        onPluginLoadRequestAsync(context: MessageRouterContext, request: PluginLoadRequest, response: PluginLoadResponse): Promise<MessageResultType>;
        sortVersionIndexFun(pv1: PluginVersionUnit, pv2: PluginVersionUnit): number;
        getRouter(): any;
    }
}
declare module "sk/service/logic/test/router/TestCaseRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { CaseGetRequest } from 'sk/data/logic/test/message/CaseGetRequest';
    import { CaseGetResponse } from 'sk/data/logic/test/message/CaseGetResponse';
    import { CaseUpdateCaseRequest } from 'sk/data/logic/test/message/CaseUpdateCaseRequest';
    import { CaseUpdateCaseResponse } from 'sk/data/logic/test/message/CaseUpdateCaseResponse';
    export class TestCaseRouter extends MessageRouter {
        processCode: string;
        onCaseGetRequestAsync(context: MessageRouterContext, request: CaseGetRequest, response: CaseGetResponse): Promise<MessageResultType>;
        onCaseUpdateCaseRequestAsync(context: MessageRouterContext, request: CaseUpdateCaseRequest, response: CaseUpdateCaseResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/test/router/TestRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { TestResultEnum } from 'sk/data/logic/test/enumeration/TestResultEnum';
    import { CleanHistoryRequest } from 'sk/data/logic/test/message/CleanHistoryRequest';
    import { CleanHistoryResponse } from 'sk/data/logic/test/message/CleanHistoryResponse';
    import { InsertHistoryRequest } from 'sk/data/logic/test/message/InsertHistoryRequest';
    import { InsertHistoryResponse } from 'sk/data/logic/test/message/InsertHistoryResponse';
    import { SwitchHistoryRequest } from 'sk/data/logic/test/message/SwitchHistoryRequest';
    import { SwitchHistoryResponse } from 'sk/data/logic/test/message/SwitchHistoryResponse';
    import { UpdateHistoryRequest } from 'sk/data/logic/test/message/UpdateHistoryRequest';
    import { UpdateHistoryResponse } from 'sk/data/logic/test/message/UpdateHistoryResponse';
    import { TestHistoryController } from 'sk/service/data/logic/test/controller/TestHistoryController';
    import { TestStatisticUnit } from 'sk/service/data/logic/test/logic/TestStatisticUnit';
    export class TestRouter extends MessageRouter {
        processCode: string;
        protected _testHistoryController: TestHistoryController;
        onInsertHistoryRequestAsync(context: MessageRouterContext, request: InsertHistoryRequest, response: InsertHistoryResponse): Promise<MessageResultType>;
        onCleanHistoryRequestAsync(context: MessageRouterContext, request: CleanHistoryRequest, response: CleanHistoryResponse): Promise<MessageResultType>;
        onSwitchHistoryRequestAsync(context: MessageRouterContext, request: SwitchHistoryRequest, response: SwitchHistoryResponse): Promise<MessageResultType>;
        onUpdateHistoryRequestAsync(context: MessageRouterContext, request: UpdateHistoryRequest, response: UpdateHistoryResponse): Promise<MessageResultType>;
        createStatisticAsync(context: MessageRouterContext, testCaseId: string, testCaseCode: string, testResult: TestResultEnum): Promise<ResultObject<TestStatisticUnit>>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/test/router/TestStaticRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { StatisticCleanRequest } from 'sk/data/logic/test/message/StatisticCleanRequest';
    import { StatisticCleanResponse } from 'sk/data/logic/test/message/StatisticCleanResponse';
    import { TestStatisticController } from 'sk/service/data/logic/test/controller/TestStatisticController';
    export class TestStaticRouter extends MessageRouter {
        processCode: string;
        protected _testStatisticController: TestStatisticController;
        onStatisticCleanRequestAsync(context: MessageRouterContext, request: StatisticCleanRequest, response: StatisticCleanResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/check/util/DataCheckUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { StorageModuleTypeEnum } from 'foundation/data/common/enumeration/StorageModuleTypeEnum';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { ConfigureElement } from 'sk/data/family/element/config/configure/ConfigureElement';
    import { ConfigureOptionElement } from 'sk/data/family/element/config/configure/ConfigureOptionElement';
    import { DecorateElement } from 'sk/data/family/element/config/decorate/DecorateElement';
    import { DecorateItemElement } from 'sk/data/family/element/config/decorate/DecorateItemElement';
    import { VariableElement } from 'sk/data/family/element/config/variable/VariableElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { DataCheckResultMessageInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { ProductShowCategoryItemUnit } from 'sk/service/data/logic/digitization/logic/ProductShowCategoryItemUnit';
    import { ConfigDecorateItemUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateItemUnit';
    import { ModuleConfigDecorateItemUnit } from 'sk/service/data/logic/perspective/logic/ModuleConfigDecorateItemUnit';
    import { WarehouseDatabaseUnit } from 'sk/service/data/logic/warehouse/logic/WarehouseDatabaseUnit';
    export class DataCheckUtil {
        protected static _ossService: OssConnectionService;
        static appendMessage(messages: Types<DataCheckResultMessageInfo>, content: string, type?: string): void;
        static getDatabaseAsync(context: DataContext, libraryId: string): Promise<ResultObject<WarehouseDatabaseUnit>>;
        static existsFileAsync(context: IContext, storageCd: StorageModuleTypeEnum, type: string, id: string, version: number): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkDecoratePerspectiveDataAsync(context: DataContext, elementId: string, decorateId: string): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkDecorateLinkDataAsync(context: DataContext, elementId: string, decoratePerspectiveUnits: DatasetResult<ModuleConfigDecorateItemUnit>): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkDecorateItemsDataAsync(context: DataContext, bindingCd: number, item: DecorateItemElement | ConfigDecorateItemUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkDecorateItemLinkDataAsync(context: DataContext, item: DecorateItemElement | ConfigDecorateItemUnit, unitDataName: string, categoryDataName: string, typeName: string): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkControllerAsync(context: DataContext, document: FamilyDocument, optionDecoratePerspective?: boolean): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkVariableControllerAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkDecorateControllerAsync(context: DataContext, document: FamilyDocument, optionDecoratePerspective?: boolean): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkConfigureControllerAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static checkSymbolControllerAsync(context: DataContext, document: FamilyDocument): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        static findDecorateFromDocument(document: FamilyDocument, decorateId: string): DecorateElement;
        static findConfigureFromDocument(document: FamilyDocument, configId: string): ConfigureElement;
        static findConfigureOptionFromDocument(document: FamilyDocument, optionId: string): ConfigureOptionElement;
        static findVariableByCodeFromDocument(document: FamilyDocument, code: string): VariableElement;
        static isFamilyTypeAsync(context: DataContext, typeId: string, targetTypeCode: string): Promise<boolean>;
        static checkFamilyRootElement(document: FamilyDocument, targetClass: any): Types<DataCheckResultMessageInfo>;
        static checkElementsByType(document: FamilyDocument, targetClass: any): Types<DataCheckResultMessageInfo>;
        private static checkDigitizationProductAsync;
        static processDigitizationProductAsync(context: DataContext, digitizationProductId: string, digitizationProductUnit?: ProductShowCategoryItemUnit, optionCategory?: boolean): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private static checkProductByLibraryAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/DatasetChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetLogic } from 'foundation/service/common/database/DatasetLogic';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { DatasetCheckParameter } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetCheckerResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { DatasetUnitCheckerDeclareInfo } from 'sk/service/data/logic/warehouse/check/info/DatasetUnitCheckerDeclareInfo';
    import { IDatasetChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetChecker';
    import { DatasetCheckerRegisterService } from 'sk/service/data/logic/warehouse/check/service/DatasetCheckerRegisterService';
    export class DatasetChecker extends InstanceObject implements IDatasetChecker {
        protected _datasetLogicService: DatasetLogicService;
        protected _datasetCheckRegisterService: DatasetCheckerRegisterService;
        processAsync(context: DataContext, parameter: DatasetCheckParameter): Promise<ResultObject<Types<DatasetCheckerResultInfo>>>;
        processDatasetUnitAsync(context: DataContext, logic: DatasetLogic, unit: DatasetUnit, declareInfos: Array<DatasetUnitCheckerDeclareInfo>, libraryId: string, content?: any): Promise<ResultObject<Types<DatasetCheckerResultInfo>>>;
        private checkDatasetUnitAsync;
        private checkForeignKeyReferenceAsync;
        protected checkUnit(logic: DatasetLogic, unit: DatasetUnit, currentLibraryId: string): boolean;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/element/BrepElementChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { VariableService } from 'sk/data/family/element/config/variable/VariableService';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { DataCheckResultMessageInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IElementChecker } from 'sk/service/data/logic/warehouse/check/interface/IElementChecker';
    export class BrepElementChecker extends InstanceObject implements IElementChecker {
        protected _variableService: VariableService;
        processAsync(context: DataContext, unit: DatasetUnit, element: BrepElement): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private checkBindingPropertyAsync;
        private checkParameterAsync;
        private checkVariableAsync;
        private checkDecorateAsync;
        private checkConfigureAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/element/ComponentElementChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { RuleTypeItemElement } from 'sk/data/family/rule/element/instance/RuleTypeItemElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleTypeDocumentService } from 'sk/data/family/rule/RuleTypeDocumentService';
    import { DataCheckResultMessageInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IElementChecker } from 'sk/service/data/logic/warehouse/check/interface/IElementChecker';
    import { RuleTypeUnit } from 'sk/service/data/logic/module/logic/RuleTypeUnit';
    export type RuleTypeMsgOptions = {
        element: ComponentElement;
        typeElement: RuleTypeItemElement;
        typeUnit: RuleTypeUnit;
    };
    export class ComponentElementChecker extends InstanceObject implements IElementChecker {
        protected _ruleTypeDocumentService: RuleTypeDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        processAsync(context: DataContext, unit: DatasetUnit, element: ComponentElement): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        checkRuleAsync(context: DataContext, element: ComponentElement): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private checkRuleInstanceAsync;
        private checkRuleParameterAsync;
        private checkRuleTypeAsync;
        private checkRuleTypeParameterAsync;
        private checkRuleTypeParametersWithDeclare;
        private checkDeclareParametersWithUsing;
        private checkReferenceFamilyAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/element/ComponentInstanceElementChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { DataCheckResultMessageInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IElementChecker } from 'sk/service/data/logic/warehouse/check/interface/IElementChecker';
    export class ComponentInstanceElementChecker extends InstanceObject implements IElementChecker {
        processAsync(context: DataContext, unit: DatasetUnit, element: ComponentInstanceElement): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private checkReferenceFamilyTypeAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/element/ComponentPatternElementChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { ComponentPatternElement } from 'sk/data/family/element/pattern/ComponentPatternElement';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { DataCheckResultMessageInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IElementChecker } from 'sk/service/data/logic/warehouse/check/interface/IElementChecker';
    import { ElementCheckerRegisterService } from 'sk/service/data/logic/warehouse/check/service/ElementCheckerRegisterService';
    export class ComponentPatternElementChecker extends InstanceObject implements IElementChecker {
        protected _elementCheckRegisterService: ElementCheckerRegisterService;
        private _maxLoopCount;
        processAsync(context: DataContext, unit: DatasetUnit, element: ComponentPatternElement, document: PatternDocument): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private checkElementAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/element/LinkerPatternElementChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { DataCheckResultMessageInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IElementChecker } from 'sk/service/data/logic/warehouse/check/interface/IElementChecker';
    export class LinkPatternElementChecker extends InstanceObject implements IElementChecker {
        processAsync(context: DataContext, unit: DatasetUnit, element: LinkerPatternElement, document: PatternDocument): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private checkLinkedDataAsync;
        private checkDigitizationProductAsync;
        private checkProductAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/element/TechnologyHoleComponentElementChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { TechnologyHoleComponentElement } from 'sk/data/family/database/technology/element/TechnologyHoleComponentElement';
    import { DataCheckResultMessageInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IElementChecker } from 'sk/service/data/logic/warehouse/check/interface/IElementChecker';
    export class TechnologyHoleComponentElementChecker extends InstanceObject implements IElementChecker {
        protected _ossService: OssConnectionService;
        processAsync(context: DataContext, unit: DatasetUnit, element: TechnologyHoleComponentElement): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private checkStructureProfileAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/ModuleDatasetChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetLogic } from 'foundation/service/common/database/DatasetLogic';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { DatasetCheckerResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { DatasetUnitCheckerDeclareInfo } from 'sk/service/data/logic/warehouse/check/info/DatasetUnitCheckerDeclareInfo';
    import { DatasetChecker } from "sk/service/logic/warehouse/check/checker/DatasetChecker";
    export class ModuleDatasetChecker extends DatasetChecker {
        processDatasetUnitAsync(context: DataContext, logic: DatasetLogic, unit: DatasetUnit, declareInfos: Array<DatasetUnitCheckerDeclareInfo>, libraryId: string, content?: any): Promise<ResultObject<Types<DatasetCheckerResultInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ConfigConfigureChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ConfigConfigureUnit } from 'sk/service/data/logic/module/logic/ConfigConfigureUnit';
    export class ConfigConfigureChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ConfigConfigureUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ConfigConfigureUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ConfigDecorateChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ConfigDecorateUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateUnit';
    export class ConfigDecorateChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ConfigDecorateUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ConfigDecorateUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ConfigParameterChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ConfigParameterUnit } from 'sk/service/data/logic/module/logic/ConfigParameterUnit';
    export class ConfigParameterChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ConfigParameterUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ConfigParameterUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ConfigVariableChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { VariableService } from 'sk/data/family/element/config/variable/VariableService';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ConfigVariableUnit } from 'sk/service/data/logic/module/logic/ConfigVariableUnit';
    export class ConfigVariableChecker extends InstanceObject implements IDatasetUnitChecker {
        protected _variableService: VariableService;
        processAsync(context: DataContext, unit: ConfigVariableUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ConfigVariableUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/DecoratePerspectiveChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ModuleConfigDecorateItemUnit } from 'sk/service/data/logic/perspective/logic/ModuleConfigDecorateItemUnit';
    export class DecoratePerspectiveChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ModuleConfigDecorateItemUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ModuleConfigDecorateItemUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/FamilyChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ElementCheckerRegisterService } from 'sk/service/data/logic/warehouse/check/service/ElementCheckerRegisterService';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    export class FamilyChecker extends InstanceObject implements IDatasetUnitChecker {
        protected _elementCheckRegisterService: ElementCheckerRegisterService;
        protected _familyDocumentService: FamilyDocumentService;
        processAsync(context: DataContext, family: FamilyUnit, content?: any): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkElementsAsync;
        private checkFamilyUnitAsync;
        private checkSymbolsAsync;
        checkFeaturesByTypeAsync(context: DataContext, family: FamilyUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
        private checkMaterialFeatures;
        private checkProfileFeaturesAsync;
        private checkDocumentRootElementAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/FamilyInfoChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { PublishFamilyInfoUnit } from 'sk/service/data/logic/module/logic/PublishFamilyInfoUnit';
    export class FamilyInfoChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: PublishFamilyInfoUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: PublishFamilyInfoUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/FamilyRuleChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyRuleUnit } from 'sk/service/data/logic/module/logic/FamilyRuleUnit';
    export class FamilyRuleChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyRuleUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/FamilySymbolChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilySymbolUnit } from 'sk/service/data/logic/module/logic/FamilySymbolUnit';
    export class FamilySymbolChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilySymbolUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: FamilySymbolUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/FamilyTypeRuleChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyTypeRuleUnit } from 'sk/service/data/logic/module/logic/FamilyTypeRuleUnit';
    export class FamilyTypeRuleChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyTypeRuleUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/FamilyValuationConfigChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyValuationConfigUnit } from 'sk/service/data/logic/module/logic/FamilyValuationConfigUnit';
    export class FamilyValuationConfigChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyValuationConfigUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/FamilyValuationSystemChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyValuationSystemUnit } from 'sk/service/data/logic/module/logic/FamilyValuationSystemUnit';
    export class FamilyValuationSystemChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyValuationSystemUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/MaterialChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { MaterialUnit } from 'sk/service/data/logic/module/logic/MaterialUnit';
    export class MaterialChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: MaterialUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkFamilyUnitAsync;
        private checkFeaturesAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/MaterialFamilyChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { MaterialFamilyUnit } from 'sk/service/data/logic/module/logic/MaterialFamilyUnit';
    export class MaterialFamilyChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: MaterialFamilyUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: MaterialFamilyUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/MaterialPatternChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { MaterialPatternUnit } from 'sk/service/data/logic/module/logic/MaterialPatternUnit';
    export class MaterialPatternChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: MaterialPatternUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: MaterialPatternUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/MaterialRelationChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { MaterialRelationUnit } from 'sk/service/data/logic/module/logic/MaterialRelationUnit';
    export class MaterialRelationChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: MaterialRelationUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: MaterialRelationUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/MaterialRuleChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { MaterialRuleUnit } from 'sk/service/data/logic/module/logic/MaterialRuleUnit';
    export class MaterialRuleChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: MaterialRuleUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: MaterialRuleUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/MaterialTypeRuleChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { MaterialTypeRuleUnit } from 'sk/service/data/logic/module/logic/MaterialTypeRuleUnit';
    export class MaterialTypeRuleChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: MaterialTypeRuleUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: MaterialTypeRuleUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/PatternChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ElementCheckerRegisterService } from 'sk/service/data/logic/warehouse/check/service/ElementCheckerRegisterService';
    import { PatternUnit } from 'sk/service/data/logic/module/logic/PatternUnit';
    export class PatternChecker extends InstanceObject implements IDatasetUnitChecker {
        protected _elementCheckRegisterService: ElementCheckerRegisterService;
        protected _patternDocumentService: PatternDocumentService;
        processAsync(context: DataContext, unit: PatternUnit, content?: any): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkElementsAsync;
        private checkPatternUnitAsync;
        private checkSymbolsAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/PatternInfoChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { PublishPatternInfoUnit } from 'sk/service/data/logic/module/logic/PublishPatternInfoUnit';
    export class PatternInfoChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: PublishPatternInfoUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: PublishPatternInfoUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/PatternSymbolChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { PatternSymbolUnit } from 'sk/service/data/logic/module/logic/PatternSymbolUnit';
    export class PatternSymbolChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: PatternSymbolUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: PatternSymbolUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/PatternTypeRuleChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { PatternTypeRuleUnit } from 'sk/service/data/logic/module/logic/PatternTypeRuleUnit';
    export class PatternTypeRuleChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: PatternTypeRuleUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ProductChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ProductUnit } from 'sk/service/data/logic/module/logic/ProductUnit';
    export class ProductChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ProductUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ProductUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ProductPerspectiveChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ModuleProductShowProductUnit } from 'sk/service/data/logic/perspective/logic/ModuleProductShowProductUnit';
    export class ProductPerspectiveChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ModuleProductShowProductUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ModuleProductShowProductUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ProductShowCategoryItemChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ProductShowCategoryItemUnit } from 'sk/service/data/logic/module/logic/ProductShowCategoryItemUnit';
    export class ProductShowCategoryItemChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ProductShowCategoryItemUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ProductShowCategoryItemUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ProductSymbolChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ProductSymbolUnit } from 'sk/service/data/logic/module/logic/ProductSymbolUnit';
    export class ProductSymbolChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ProductSymbolUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        checkUnitAsync(context: DataContext, unit: ProductSymbolUnit): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/RuleChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { RuleUnit } from 'sk/service/data/logic/module/logic/RuleUnit';
    import { DatasetCheckLogicService } from "sk/service/logic/warehouse/check/service/DatasetCheckLogicService";
    export class RuleChecker extends InstanceObject implements IDatasetUnitChecker {
        protected _checkService: DatasetCheckLogicService;
        protected _ruleDocumentService: RuleDocumentService;
        processAsync(context: DataContext, unit: RuleUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkRuleUnitAsync;
        private checkElementsAsync;
        private checkElementByTypeAsync;
        private checkFamilyTypeFilterElementAsync;
        private checkFamilyCategoryFilterElementAsync;
        private checkPatternTypeFilterElementAsync;
        private checkRuleParameterElementAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ValuationConfigChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ValuationConfigUnit } from 'sk/service/data/logic/module/logic/ValuationConfigUnit';
    export class ValuationConfigChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ValuationConfigUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ValuationRuleChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ValuationRuleUnit } from 'sk/service/data/logic/module/logic/ValuationRuleUnit';
    export class ValuationRuleChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ValuationRuleUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/module/unit/ValuationSystemChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ValuationSystemUnit } from 'sk/service/data/logic/module/logic/ValuationSystemUnit';
    export class ValuationSystemChecker extends InstanceObject implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: ValuationSystemUnit): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        private checkUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/check/checker/resource/ResourceDatasetChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetLogic } from 'foundation/service/common/database/DatasetLogic';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { DatasetCheckerResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { DatasetUnitCheckerDeclareInfo } from 'sk/service/data/logic/warehouse/check/info/DatasetUnitCheckerDeclareInfo';
    import { DatasetChecker } from "sk/service/logic/warehouse/check/checker/DatasetChecker";
    export class ResourceDatasetChecker extends DatasetChecker {
        processDatasetUnitAsync(context: DataContext, logic: DatasetLogic, unit: DatasetUnit, declareInfos: Array<DatasetUnitCheckerDeclareInfo>, libraryId: string, content?: any): Promise<ResultObject<Types<DatasetCheckerResultInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/check/checker/resource/unit/ResourceChecker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { DataCheckResultMessageInfo, DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { ResourceUnit } from 'sk/service/data/logic/resource/logic/ResourceUnit';
    import { DatasetCheckLogicService } from "sk/service/logic/warehouse/check/service/DatasetCheckLogicService";
    enum CheckType {
        FILE = 0,
        DIR = 1
    }
    type CheckObject = {
        name: string;
        type: CheckType;
    };
    export class ResourceChecker extends InstanceObject implements IDatasetUnitChecker {
        protected _checkService: DatasetCheckLogicService;
        protected _checkResultInfo: DatasetUnitCheckResultInfo;
        protected _ossService: OssConnectionService;
        private checkMap;
        processAsync(context: DataContext, unit: ResourceUnit, content?: any): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
        existsObjectsAsync(context: IContext, storageCd: string, id: string, version: number, checkObjects: Array<CheckObject>): Promise<ResultObject<Types<DataCheckResultMessageInfo>>>;
    }
}
declare module "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { FieldMeta } from 'foundation/service/common/database/FieldMeta';
    export type DatabaseOperatorParameter = {
        databaseName?: string;
        tableName?: string;
        fields?: Array<{
            name: string;
            value: any;
        }>;
        fieldsMeta?: Array<FieldMeta>;
        batchUnits?: Types<DatasetUnit>;
        primaryField?: FieldMeta;
    };
}
declare module "sk/service/logic/warehouse/database/operator/DatabaseBaseOperator" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataSql } from 'foundation/service/common/database/util/DataSql';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatabaseOperatorParameter } from "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter";
    export abstract class DatabaseBaseOperator extends InstanceObject {
        protected abstract makeSql(parameter: DatabaseOperatorParameter): DataSql;
        protected makeParameters(parameter: DatabaseOperatorParameter): Array<any>;
        build(parameter: DatabaseOperatorParameter): {
            sql: DataSql;
            sqlParameters: any;
        };
        processAsync(context: DataContext, parameter: DatabaseOperatorParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/database/declare/DatabaseOperatorDeclareInfo" {
    import { DatabaseBaseOperator } from "sk/service/logic/warehouse/database/operator/DatabaseBaseOperator";
    export class DatabaseOperatorDeclareInfo {
        type: any;
        operator: DatabaseBaseOperator;
    }
}
declare module "sk/service/logic/warehouse/database/service/DatabaseOperatorService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatabaseOperatorParameter } from "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter";
    import { DatabaseOperatorDeclareInfo } from "sk/service/logic/warehouse/database/declare/DatabaseOperatorDeclareInfo";
    export class DatabaseOperatorService extends Service {
        protected _declareInfos: TypeMap<any, DatabaseOperatorDeclareInfo>;
        registerOperatorDeclare(info: DatabaseOperatorDeclareInfo): void;
        processAsync(context: DataContext, clazz: Function, parameter: DatabaseOperatorParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/database/declare/DatabaseOperatorDeclare" {
    export function DatabaseOperatorDeclare(): (target: any) => void;
}
declare module "sk/service/logic/warehouse/database/operator/DatabaseBatchDeleteOperator" {
    import { DataSql } from 'foundation/service/common/database/util/DataSql';
    import { DatabaseOperatorParameter } from "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter";
    import { DatabaseBaseOperator } from "sk/service/logic/warehouse/database/operator/DatabaseBaseOperator";
    export class DatabaseBatchDeleteOperator extends DatabaseBaseOperator {
        protected makeSql(parameter: DatabaseOperatorParameter): DataSql;
        protected makeParameters(parameter: DatabaseOperatorParameter): Array<any>;
    }
}
declare module "sk/service/logic/warehouse/database/operator/DatabaseBatchModifyOperator" {
    import { DataSql } from 'foundation/service/common/database/util/DataSql';
    import { DatabaseOperatorParameter } from "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter";
    import { DatabaseBaseOperator } from "sk/service/logic/warehouse/database/operator/DatabaseBaseOperator";
    export class DatabaseBatchModifyOperator extends DatabaseBaseOperator {
        makeSql(parameter: DatabaseOperatorParameter): DataSql;
        protected makeParameters(parameter: DatabaseOperatorParameter): Array<any>;
    }
}
declare module "sk/service/logic/warehouse/database/operator/DatabaseCreateOperator" {
    import { DataSql } from 'foundation/service/common/database/util/DataSql';
    import { DatabaseOperatorParameter } from "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter";
    import { DatabaseBaseOperator } from "sk/service/logic/warehouse/database/operator/DatabaseBaseOperator";
    export class DatabaseCreateOperator extends DatabaseBaseOperator {
        makeSql(parameter: DatabaseOperatorParameter): DataSql;
    }
}
declare module "sk/service/logic/warehouse/database/operator/DatabaseDeleteOperator" {
    import { DataSql } from 'foundation/service/common/database/util/DataSql';
    import { DatabaseOperatorParameter } from "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter";
    import { DatabaseBaseOperator } from "sk/service/logic/warehouse/database/operator/DatabaseBaseOperator";
    export class DatabaseDeleteOperator extends DatabaseBaseOperator {
        makeSql(parameter: DatabaseOperatorParameter): DataSql;
    }
}
declare module "sk/service/logic/warehouse/database/operator/DatabaseShowTablesOperator" {
    import { DataSql } from 'foundation/service/common/database/util/DataSql';
    import { DatabaseOperatorParameter } from "sk/service/logic/warehouse/database/common/DatabaseOperatorParameter";
    import { DatabaseBaseOperator } from "sk/service/logic/warehouse/database/operator/DatabaseBaseOperator";
    export class DatabaseShowTablesOperator extends DatabaseBaseOperator {
        makeSql(parameter: DatabaseOperatorParameter): DataSql;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/dataconfig/datastorage/LibraryInitDataStorage" {
    export class LibraryInitDataStorage {
        static dataStorage: any;
        static initData(): void;
        static getData(): any;
        static getDataItem(key: String): any;
        static addDataItem(key: String, value: any): void;
        static resetData(): void;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/dataconfig/datastorage/CategoryDataStorage" {
    export class CategoryDataStorage {
        static dataStorage: any;
        static initData(): void;
        static getData(): any;
        static getDataItem(key: String): any;
        static addDataItem(key: String, value: any): void;
        static resetData(): void;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/dataconfig/datastorage/GlobalUserInfoStorage" {
    export class GlobalUserInfoStorage {
        static dataStorage: any;
        static initData(): any;
        static getData(): any;
        static getDataItem(key: String): any;
        static addDataItem(key: String, value: any): void;
        static resetData(): void;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/datacheckcategory/DataCategoryInitUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DatasetMeta } from 'foundation/service/common/database/DatasetMeta';
    import { FieldMeta } from 'foundation/service/common/database/FieldMeta';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export type CategoryConfigTreeNode = {
        id: string;
        code: string;
        name: string;
        parentCode: string;
        typeCode: string;
        exist: boolean;
        children: Array<CategoryConfigTreeNode>;
    };
    export class DataCategoryInitUtil {
        protected static _datasetLogicService: DatasetLogicService;
        static FIELD_CODE: FieldMeta;
        static processAsync(context: LogicContext, categoryData: any, meta: DatasetMeta): Promise<ResultObject>;
        private static initCategoriesAsync;
        private static makeTreeNodes;
        private static makeTreeNode;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/datacheckcategory/DataResourceCategory" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export class DataResourceCategory {
        static startDataCheckAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/dataconfig/dataload/LibraryInitDataLoad" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class LibraryInitDataLoad {
        static startDataLoadAsync(): Promise<ResultObject>;
        static clearData(): void;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationeffect/DataCreationPreEffect" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    export class DataCreationPreEffect {
        protected static _categoryCode: string;
        protected static _targetFileNames: string[];
        protected static _effectRootPath: string;
        protected static _initVersion: number;
        protected static _datasetLogicService: DatasetLogicService;
        protected static _ossConnectionService: OssConnectionService;
        protected static _effects: {
            name: string;
            code: string;
        }[];
        static startDataCreationAsync(context: LogicContext): Promise<ResultObject>;
        private static initEffectAsync;
        private static getEffectUnitAsync;
        private static buildResourceUnitAsync;
        private static buildDataPathAsync;
        private static uploadEffectAsync;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/datacheckcategory/DataCheckCategory" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export class DataCheckCategory {
        static startDataCheckAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/datacheckfamily/DataCheckPreFamily" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    export class DataCheckPreFamily {
        protected static _familyController: FamilyController;
        static startDataCheckAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/datacheckrule/DataCheckRule" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    export class DataCheckRule {
        protected static _ruleController: RuleController;
        static startDataCheckAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/DataCheckAll" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export class DataCheckAll {
        static startDataCheckAllAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationcategorymeasure/DataCreationCategoryMeasures" {
    import { AttributeUnit } from 'sk/service/data/logic/module/logic/AttributeUnit';
    export class DataCreationCategoryMeasures {
        static makeFeature(attributeUnit: AttributeUnit): any;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationcategorysymbols/DataCreationCategorySymbols" {
    import { AttributeUnit } from 'sk/service/data/logic/module/logic/AttributeUnit';
    export class DataCreationCategorySymbols {
        static makeFeature(attributeUnit: AttributeUnit, optionExpand?: boolean): any;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationcategoryfeatures/DataCreationCategoryFeaturesUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { FamilyCategoryUnit } from 'sk/service/data/logic/module/logic/FamilyCategoryUnit';
    import { FeatureUnit } from 'sk/service/data/logic/module/logic/FeatureUnit';
    import { DatabaseOperatorService } from "sk/service/logic/warehouse/database/service/DatabaseOperatorService";
    export class DataCreationCategoryFeaturesUtil {
        protected static _datasetLogicService: DatasetLogicService;
        protected static _databaseOperatorService: DatabaseOperatorService;
        protected static _referenceCd: string;
        static updateCategoryFeaturesAsync(context: LogicContext, categoryUnit: FamilyCategoryUnit, featureCode: string, features: Array<any>): Promise<ResultObject>;
        static processFeatureUnitAsync(context: LogicContext, featureUnits: DatasetResult<FeatureUnit>, featureGroupId: string, attributeId: string, referenceId: string): Promise<ResultObject>;
        private static removeInvalidFeatureUnitsAsync;
        private static findFeatureUnitWithNullReferenceCd;
        private static findFeatureUnit;
        private static insertFeatureUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationcategoryfeatures/DataCreationCategoryFeatures" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { AttributeUnit } from 'sk/service/data/logic/module/logic/AttributeUnit';
    import { FamilyCategoryUnit } from 'sk/service/data/logic/module/logic/FamilyCategoryUnit';
    import { FeatureUnit } from 'sk/service/data/logic/module/logic/FeatureUnit';
    export type DataCreationCategoryFeaturesParameter = {
        storageKey: string;
        featureGroupCode: string;
        featureCode: string;
        categoryUnits: DatasetResult<FamilyCategoryUnit>;
        attributeUnits: DatasetResult<AttributeUnit>;
        featureUnits: DatasetResult<FeatureUnit>;
    };
    export class DataCreationCategoryFeatures {
        protected static _datasetLogicService: DatasetLogicService;
        static startDataCreationAsync(context: LogicContext): Promise<ResultObject>;
        private static initCategoryFeaturesAsync;
        private static makeFeature;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationcategoryvariable/DataCreationCategoryVariable" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export class DataCreationCategoryVariable {
        protected static _datasetLogicService: DatasetLogicService;
        static startDataCreationAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationfamily/DataCreationPreFamily" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { TechnologyHoleComponentElement } from 'sk/data/family/database/technology/element/TechnologyHoleComponentElement';
    import { AnchorElement } from 'sk/data/family/element/assistant/AnchorElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { SpatialStructureElement } from 'sk/data/family/element/brep/SpatialStructureElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class DataCreationPreFamily {
        protected static _documentService: FamilyDocumentService;
        protected static _moduleStorageService: ModuleStorageService;
        protected static _datasetLogicService: DatasetLogicService;
        static threeOneSymbol: {
            lengthX: number;
            lengthY: number;
            lengthZ: number;
            lengthMaxX: number;
            lengthMinX: number;
            lengthMaxY: number;
            lengthMinY: number;
            lengthMaxZ: number;
            lengthMinZ: number;
        };
        static handleSymbol: {
            lengthX: number;
            lengthY: number;
            lengthZ: number;
            lengthMaxX: number;
            lengthMinX: number;
            lengthMaxY: number;
            lengthMinY: number;
            lengthMaxZ: number;
            lengthMinZ: number;
        };
        static rulePanelSymbol: {
            lengthX: number;
            lengthY: number;
            lengthZ: number;
            lengthMaxX: number;
            lengthMinX: number;
            lengthMaxY: number;
            lengthMinY: number;
            lengthMaxZ: number;
            lengthMinZ: number;
        };
        static threeOneVariable: {
            name: string;
            code: string;
            value: number;
        }[];
        static threeOneHole: {
            name: string;
            structureCode: string;
            radius: string;
            depth: string;
            angle: string;
            x: string;
            y: string;
            z: string;
        }[];
        static handleHole: {
            name: string;
            structureCode: string;
            radius: string;
            depth: string;
            angle: string;
            x: string;
            y: string;
            z: string;
        }[];
        static threeOneAnchor: {
            x: string;
            y: string;
            z: string;
        }[];
        static startDataCreationAsync(context: LogicContext): Promise<ResultObject>;
        static createThreeOneAsync(context: LogicContext, tenantId: string, libraryId: string, item: any): Promise<ResultObject>;
        static createHandleAsync(context: LogicContext, tenantId: string, libraryId: string, item: any): Promise<ResultObject>;
        static createRulePanelAsync(context: LogicContext, tenantId: string, libraryId: string, item: any): Promise<ResultObject>;
        static useDataToSpatialElement(element: SpatialStructureElement, value: any): void;
        static useValueToAnchor: (element: AnchorElement, value: any) => AnchorElement;
        static useHoleDataAsync(element: TechnologyHoleComponentElement, value: any): Promise<false | TechnologyHoleComponentElement>;
        static addVariable(familyDocuemnt: any, variables: any): void;
        static addSymbol(document: any, symbol: any): void;
        static loadDocumentAsync(id: string): Promise<false | DataDocumentResult<FamilyDocument>>;
        static saveDocumentAsync(context: LogicContext, familyDto: FamilyDto, document: FamilyDocument): Promise<any>;
        static addElement(selectedElement: any, clazz: any): any;
        static getCategoryIdAsync(context: LogicContext, categoryCode: string): Promise<any>;
        static getTypeIdAsync(context: LogicContext, code: string): Promise<string>;
        protected static initElementPropertyDefaultValue(element: Element): Promise<void>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationrule/DataCreationPreRule" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { RuleCategoryController } from 'sk/service/data/logic/module/controller/RuleCategoryController';
    import { RuleController } from 'sk/service/data/logic/module/controller/RuleController';
    import { RuleTypeController } from 'sk/service/data/logic/module/controller/RuleTypeController';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    export class DataCreationPreRule {
        protected static _ruleController: RuleController;
        protected static _ruleCategoryController: RuleCategoryController;
        protected static _ruleTypeController: RuleTypeController;
        protected static _storageService: ModuleStorageService;
        protected static _ossService: OssConnectionService;
        static getRuleTypeIdAsync(context: LogicContext, code: string): Promise<string>;
        static getRuleCategoryIdAsync(context: LogicContext, categoryCode: string): Promise<any>;
        static createMaterialRuleAsync(context: LogicContext, tenantId: string, libraryId: string, item: any): Promise<ResultObject>;
        static startDataCreationAsync(context: LogicContext): Promise<ResultObject>;
        private static fixRuleDocumentAsync;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/DataCreationAll" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export class DataCreationAll {
        static startDataCreationAllAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/LibraryDataInitService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    export type LibraryDataInitParameter = {
        user: {
            id: string;
            name: string;
            tenantId: string;
        };
        module: {
            libraryId: string;
            databaseId: string;
        };
        resource: {
            libraryId: string;
            databaseId: string;
        };
    };
    export class LibraryDataInitService extends Service {
        protected _configPath: string;
        protected _environmentService: EnvironmentService;
        get configPath(): string;
        initializeConfig(jconfig: any): void;
        check(): boolean;
        initAsync(parameter: LibraryDataInitParameter): Promise<ResultObject>;
        prepareAsync(): Promise<ResultObject>;
        private initResourceLibraryAsync;
        private initModuleLibraryAsync;
        private onInitLibraryAsync;
        resourceInitAsync(context: LogicContext, libraryId: string, tenantId: string): Promise<ResultObject>;
        moduleInitAsync(context: LogicContext, libraryId: string, tenantId: string): Promise<ResultObject>;
        reset(): void;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/datacheckattributes/DataCheckAttributes" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { AttributeController } from 'sk/service/data/logic/module/controller/AttributeController';
    export class DataCheckAttributes {
        protected static _attributeController: AttributeController;
        static startDataCheckAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacheck/datacheckstructure/DataCheckPreStructure" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { StructureController } from 'sk/service/data/logic/module/controller/StructureController';
    export class DataCheckPreStructure {
        protected static _structureController: StructureController;
        static startDataCheckAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/init/libraryinit/datacreation/datacreationcategory/DataCreationCategory" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ConfigCategoryController } from 'sk/service/data/logic/module/controller/ConfigCategoryController';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { MaterialCategoryController } from 'sk/service/data/logic/module/controller/MaterialCategoryController';
    import { PatternCategoryController } from 'sk/service/data/logic/module/controller/PatternCategoryController';
    import { ProductCategoryController } from 'sk/service/data/logic/module/controller/ProductCategoryController';
    import { RuleCategoryController } from 'sk/service/data/logic/module/controller/RuleCategoryController';
    import { StructureCategoryController } from 'sk/service/data/logic/module/controller/StructureCategoryController';
    import { ResourceCategoryController } from 'sk/service/data/logic/resource/controller/ResourceCategoryController';
    export class DataCreationCategory {
        protected static _configCategoryController: ConfigCategoryController;
        protected static _familyCategoryController: FamilyCategoryController;
        protected static _patternCategoryController: PatternCategoryController;
        protected static _materialCategoryController: MaterialCategoryController;
        protected static _resourceCategoryController: ResourceCategoryController;
        protected static _ruleCategoryController: RuleCategoryController;
        protected static _productCategoryController: ProductCategoryController;
        protected static _structureCategoryController: StructureCategoryController;
        static startDataCreationAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/family/data/FamilyPublishParameters" {
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    export class FamilyPublishParameters {
        unit: FamilyUnit;
        library: FamilyPublishLibraryParameter;
        user: FamilyPublishUserParameter;
        database: FamilyPublishDatabaseParameter;
        publishVersion: number;
        static create(jconfig: any): FamilyPublishParameters;
        private static getPublishVersion;
    }
    export class FamilyPublishLibraryParameter {
        id: string;
        code: string;
        name: string;
        typeCode: string;
        version: string;
        static create(jconfig: any): FamilyPublishLibraryParameter;
    }
    export class FamilyPublishUserParameter {
        id: string;
        name: string;
        static create(jconfig: any): FamilyPublishUserParameter;
    }
    export class FamilyPublishDatabaseParameter {
        moduleDbId: string;
        resourceDbId: string;
        static create(jconfig: any): FamilyPublishDatabaseParameter;
    }
    export type FamilyPublishUploadParameter = {
        remoteName: string;
        skjContent: string;
    };
}
declare module "sk/service/logic/warehouse/publish/family/logic/collect/collector/FamilyPublishCollector" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    export abstract class FamilyPublishCollector {
        abstract processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/collect/declare/FamilyPublishCollectorDeclareInfo" {
    export class FamilyPublishCollectorDeclareInfo {
        collectorType: string;
        clazz: Function;
        static create(configType: string, clazz: Function): FamilyPublishCollectorDeclareInfo;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/collect/FamilyPublishCollectService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { FamilyPublishCollectorDeclareInfo } from "sk/service/logic/warehouse/publish/family/logic/collect/declare/FamilyPublishCollectorDeclareInfo";
    export class FamilyPublishCollectService extends Service {
        protected _collectorInfos: Dictionary<FamilyPublishCollectorDeclareInfo>;
        registerDeclare(info: FamilyPublishCollectorDeclareInfo): void;
        processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject<FamilyDocument>>;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/collect/declare/FamilyPublishCollectorDeclare" {
    export function FamilyPublishCollectorDeclare(collectorType: string): (target: any) => void;
}
declare module "sk/service/logic/warehouse/publish/family/logic/collect/collector/FamilyPublishDecorateCollector" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { FamilyPublishCollector } from "sk/service/logic/warehouse/publish/family/logic/collect/collector/FamilyPublishCollector";
    export class FamilyPublishDecorateCollector extends FamilyPublishCollector {
        processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/collect/collector/FamilyPublishVariableCollector" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { FamilyPublishCollector } from "sk/service/logic/warehouse/publish/family/logic/collect/collector/FamilyPublishCollector";
    export class FamilyPublishVariableCollector extends FamilyPublishCollector {
        processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject>;
        private collectVariableAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/fix/declare/FamilyPublishFixerDeclareInfo" {
    export class FamilyPublishFixerDeclareInfo {
        fixerType: string;
        clazz: Function;
        static create(configType: string, clazz: Function): FamilyPublishFixerDeclareInfo;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/fix/fixer/FamilyPublishFixer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    export abstract class FamilyPublishFixer {
        abstract processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/fix/FamilyPublishFixService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { FamilyPublishFixerDeclareInfo } from "sk/service/logic/warehouse/publish/family/logic/fix/declare/FamilyPublishFixerDeclareInfo";
    export class FamilyPublishFixService extends Service {
        protected _fixerInfos: Dictionary<FamilyPublishFixerDeclareInfo>;
        registerDeclare(info: FamilyPublishFixerDeclareInfo): void;
        processByCodeAsync(context: DataContext, code: string, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject<FamilyDocument>>;
        processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject<FamilyDocument>>;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/fix/declare/FamilyPublishFixerDeclare" {
    export function FamilyPublishFixerDeclare(fixerType: string): (target: any) => void;
}
declare module "sk/service/logic/warehouse/publish/family/logic/fix/fixer/FamilyPublishDecorateFixer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { FamilyPublishFixer } from "sk/service/logic/warehouse/publish/family/logic/fix/fixer/FamilyPublishFixer";
    export class FamilyPublishVariableFixer extends FamilyPublishFixer {
        processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/family/logic/fix/fixer/FamilyPublishVariableFixer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { FamilyPublishFixer } from "sk/service/logic/warehouse/publish/family/logic/fix/fixer/FamilyPublishFixer";
    export class FamilyPublishVariableFixer extends FamilyPublishFixer {
        processAsync(context: DataContext, unit: FamilyUnit, document: FamilyDocument): Promise<ResultObject>;
        private fixVariableAsync;
    }
}
declare module "sk/service/logic/warehouse/service/WarehouseDatabaseService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DatasetLogic } from 'foundation/service/common/database/DatasetLogic';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { DatasetUnit } from 'sk/service/data/declare/database/data/dataset/unit/DatasetUnit';
    import { DatasetService } from 'sk/service/data/declare/content/DatasetService';
    import { DatabaseOperatorService } from "sk/service/logic/warehouse/database/service/DatabaseOperatorService";
    export enum DatabaseOptionType {
        INSERT = 0,
        UPDATE = 1
    }
    export class WarehouseDatabaseService extends Service {
        protected _datasetService: DatasetService;
        protected _datasetLogicService: DatasetLogicService;
        protected _databaseOperatorService: DatabaseOperatorService;
        private readonly _blackNames;
        initializeConfig(jconfig: any): void;
        createTablesBySpaceAsync(context: LogicContext, spaceName: string, suffix?: string, prefix?: string): Promise<ResultObject>;
        createTableStructureAsync(context: LogicContext, datasetUnit: DatasetUnit, suffix?: string, prefix?: string): Promise<ResultObject>;
        private createTableIndexAsync;
        private getTableNames;
        private getTableName;
        importTableDataBySpaceAsync(sourceContext: LogicContext, targetContext: LogicContext, spaceName: string, optionCd: DatabaseOptionType, filterFields?: Array<any>): Promise<ResultObject>;
        importTableDataAsync(sourceContext: LogicContext, targetContext: LogicContext, datasetUnit: DatasetUnit, optionCd: DatabaseOptionType, filterFields?: Array<any>): Promise<ResultObject>;
        private updateUnitAsync;
        checkReferenceBySpaceAsync(sourceContext: LogicContext, targetContext: LogicContext, spaceName: string): Promise<ResultObject>;
        private checkInvalid;
        deleteBySpaceAndLibraryAsync(sourceContext: LogicContext, targetContext: LogicContext, spaceName: string, libraryId: string): Promise<ResultObject>;
        private deleteByLibraryIdAsync;
        private prepareTableProcessAsync;
        private checkSourceUnit;
        private buildDatasetQuery;
        private findFieldMeta;
        checkForeignKeyReferenceAsync(context: LogicContext, logic: DatasetLogic, sourceUnit: any): Promise<ResultObject>;
        selectDatabaseAsync(context: LogicContext, databaseName?: string): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { LibraryVersionUnit } from 'sk/service/data/logic/module/logic/LibraryVersionUnit';
    import { ModuleLibraryUnit } from 'sk/service/data/logic/warehouse/logic/ModuleLibraryUnit';
    import { FamilyIconRenderService } from "sk/service/logic/service/FamilyIconRenderService";
    import { MaterialFamilyIconGeneralService } from "sk/service/logic/service/MaterialFamilyIconGeneralService";
    export class ModulePublishDataService extends Service {
        protected _environmentService: EnvironmentService;
        protected _datasetLogicService: DatasetLogicService;
        protected _ossService: OssConnectionService;
        protected _materialFamilyIconService: MaterialFamilyIconGeneralService;
        protected _familyIconRenderService: FamilyIconRenderService;
        readonly publishConnectionName: string;
        private _optionDebug;
        private readonly _imageTypeCodes;
        private readonly _allowTypeCodes;
        get schemeDatabaseName(): string;
        getSourceConnectionName(databaseId: string): string;
        get optionVersion(): boolean;
        get optionCache(): boolean;
        get libraryRoot(): string;
        generateFamilyInfoImageAsync(context: LogicContext): Promise<ResultObject>;
        uploadMaterialFamilyPreviewImageAsync(context: LogicContext): Promise<ResultObject>;
        getLibraryVersionAsync(context: LogicContext, libraryUnit: ModuleLibraryUnit): Promise<ResultObject<LibraryVersionUnit>>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/util/ModulePublishDataUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { SpecificationFamilyCategory } from 'sk/data/specification/familycategory/structure/SpecificationFamilyCategory';
    import { SpecificationFamilySymbolFeature } from 'sk/data/specification/familysymbol/structure/SpecificationFamilySymbolFeature';
    import { SpecificationFamilyType } from 'sk/data/specification/familytype/structure/SpecificationFamilyType';
    import { SpecificationPatternCategory } from 'sk/data/specification/patterncategory/structure/SpecificationPatternCategory';
    import { SpecificationPatternSymbolFeature } from 'sk/data/specification/patternsymbol/structure/SpecificationPatternSymbolFeature';
    import { SpecificationPatternType } from 'sk/data/specification/patterntype/structure/SpecificationPatternType';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PatternUnit } from 'sk/service/data/logic/module/logic/PatternUnit';
    export class ModulePublishDataUtil {
        static buildTypeListAsync<T extends SpecificationFamilyType | SpecificationPatternType>(typeId: string, typeDataset: DatasetResult<any>, typeClass: any): Promise<Types<T>>;
        static buildCategoriesAsync<T extends SpecificationFamilyCategory | SpecificationPatternCategory>(categoryId: string, categoryDataset: DatasetResult<any>, categoryClass: any): Promise<Types<T>>;
        static createSymbolFeatures<T extends SpecificationFamilySymbolFeature | SpecificationPatternSymbolFeature>(symbolFeatures: string, structureClass: any): Types<T>;
        static getFeaturesValueAsync(unit: FamilyUnit | PatternUnit, options: any): Promise<string>;
        private static getValidFeatures;
        private static getFeatureUnitsByReferenceAsync;
        private static getReferenceFeatureAttributesAsync;
        private static mergeInheritFeatures;
        private static mergeInheritArrayFeaturesByCode;
        static getOtherLibraryRuleInfos(ruleInfoContent: any, libraryId: string): Array<any>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/util/ModulePublishInfoUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { SpecificationFamilyInfo } from 'sk/data/specification/familyinfo/structure/SpecificationFamilyInfo';
    import { SpecificationFamilySymbolLink } from 'sk/data/specification/familysymbol/structure/SpecificationFamilySymbolLink';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PublishFamilyInfoUnit } from 'sk/service/data/logic/module/logic/PublishFamilyInfoUnit';
    export class ModulePublishInfoUtil {
        static createFamilyInfoAsync(context: LogicContext, unit: FamilyUnit, infoUnit: PublishFamilyInfoUnit, library?: any, infoUnits?: Array<PublishFamilyInfoUnit>): Promise<SpecificationFamilyInfo>;
        static createFamilySymbolLinks(strFeatures: string, familyInfos: Array<PublishFamilyInfoUnit>): Types<SpecificationFamilySymbolLink>;
        private static createColorSymbolStructures;
        private static createSymbolLinks;
        private static createSymbolLink;
        private static findFamilyLinkInfoUnit;
        private static findMasterInfoUnit;
        private static matchMasterInfoUnit;
        private static matchMasterInfoUnitByFeatures;
        private static createColorSymbolStructure;
    }
}
declare module "sk/service/logic/warehouse/publish/family/service/FamilyPublishProcessService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyCategoryUnit } from 'sk/service/data/logic/module/logic/FamilyCategoryUnit';
    import { FamilyTypeUnit } from 'sk/service/data/logic/module/logic/FamilyTypeUnit';
    import { FamilyPublishCollectService } from "sk/service/logic/warehouse/publish/family/logic/collect/FamilyPublishCollectService";
    import { FamilyPublishFixService } from "sk/service/logic/warehouse/publish/family/logic/fix/FamilyPublishFixService";
    import { FamilyPublishParameters } from "sk/service/logic/warehouse/publish/family/data/FamilyPublishParameters";
    export class FamilyPublishProcessService extends Service {
        protected _datasetLogicService: DatasetLogicService;
        protected _documentService: FamilyDocumentService;
        protected _publishFixService: FamilyPublishFixService;
        protected _publishCollectService: FamilyPublishCollectService;
        protected _ossService: OssConnectionService;
        protected _optionDebug: boolean;
        protected get publishRoot(): string;
        processAsync(context: LogicContext, parameters: FamilyPublishParameters): Promise<ResultObject>;
        private processDocumentAsync;
        private processReferenceFamiliesAsync;
        private processReferenceFamilyAsync;
        private addExternalFamilyElement;
        private setupDocumentAsync;
        setupFamilyTypes(document: FamilyDocument, typeId: string, typeDataset: DatasetResult<FamilyTypeUnit>): void;
        setupFamilyCategories(document: FamilyDocument, categoryId: string, categoryDataset: DatasetResult<FamilyCategoryUnit>): void;
        private uploadOssAsync;
        private createUploadParametersAsync;
        private createInfoUploadParametersAsync;
        private createUploadParameter;
    }
}
declare module "sk/service/logic/warehouse/publish/family/service/FamilyPublishLogicService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DatabaseOperatorService } from "sk/service/logic/warehouse/database/service/DatabaseOperatorService";
    import { WarehouseDatabaseService } from "sk/service/logic/warehouse/service/WarehouseDatabaseService";
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    import { FamilyPublishProcessService } from "sk/service/logic/warehouse/publish/family/service/FamilyPublishProcessService";
    export class FamilyPublishLogicService extends Service {
        protected _publishDataService: ModulePublishDataService;
        protected _datasetLogicService: DatasetLogicService;
        protected _databaseService: WarehouseDatabaseService;
        protected _databaseOperatorService: DatabaseOperatorService;
        protected _publishProcessService: FamilyPublishProcessService;
        publishAsync(jconfig: any): Promise<ResultObject>;
        private onPublishAsync;
        private setupContext;
        private onUpdatePublishInfoAsync;
        private export2SchemeAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/base/attribute/IModulePublishAttribute" {
    import { AttributeUnit } from 'sk/service/data/logic/module/logic/AttributeUnit';
    export interface IModulePublishAttribute {
        id: string;
        typeId: string;
        categoryId: string;
        parentId: string;
        code: string;
        name: string;
        featureGroupId: string;
        dataUseCd: number;
        dataTypeCd: number;
        dataStatisticsCd: number;
        dataStructureId: string;
        dataDefault: string;
        parameters: string;
        configure: string;
        remark: string;
        saveJson(): any;
        loadData(unit: AttributeUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/base/attribute/ModulePublishAttribute" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { AttributeUnit } from 'sk/service/data/logic/module/logic/AttributeUnit';
    import { IModulePublishAttribute } from "sk/service/logic/warehouse/publish/module/data/base/attribute/IModulePublishAttribute";
    export class ModulePublishAttribute extends InstanceObject implements IModulePublishAttribute {
        id: string;
        typeId: string;
        categoryId: string;
        parentId: string;
        code: string;
        name: string;
        featureGroupId: string;
        dataUseCd: number;
        dataTypeCd: number;
        dataStatisticsCd: number;
        dataStructureId: string;
        dataDefault: string;
        parameters: string;
        configure: string;
        remark: string;
        saveJson(): any;
        loadData(unit: AttributeUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/base/businesstype/IModulePublishBusinessType" {
    import { BusinessTypeUnit } from 'sk/service/data/logic/module/logic/BusinessTypeUnit';
    export interface IModulePublishBusinessType {
        id: string;
        tenantId: string;
        libraryId: string;
        code: string;
        name: string;
        remark: string;
        saveJson(): any;
        loadData(unit: BusinessTypeUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/base/businesstype/ModulePublishBusinessType" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { BusinessTypeUnit } from 'sk/service/data/logic/module/logic/BusinessTypeUnit';
    import { IModulePublishBusinessType } from "sk/service/logic/warehouse/publish/module/data/base/businesstype/IModulePublishBusinessType";
    export class ModulePublishBusinessType extends InstanceObject implements IModulePublishBusinessType {
        id: string;
        tenantId: string;
        libraryId: string;
        code: string;
        name: string;
        remark: string;
        saveJson(): any;
        loadData(unit: BusinessTypeUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/base/warehouse/IWarehousePublishTenant" {
    import { WarehouseUnit } from 'sk/service/data/logic/warehouse/logic/WarehouseUnit';
    export interface IWarehousePublishTenant {
        id: string;
        warehouseId: string;
        code: string;
        name: string;
        tenantOrgType: number;
        remark: string;
        saveJson(): any;
        loadData(unit: WarehouseUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/base/warehouse/WarehousePublishTenant" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { WarehouseUnit } from 'sk/service/data/logic/warehouse/logic/WarehouseUnit';
    import { IWarehousePublishTenant } from "sk/service/logic/warehouse/publish/module/data/base/warehouse/IWarehousePublishTenant";
    export class WarehousePublishTenant extends InstanceObject implements IWarehousePublishTenant {
        id: string;
        warehouseId: string;
        code: string;
        name: string;
        tenantOrgType: number;
        remark: string;
        saveJson(): any;
        loadData(unit: WarehouseUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/common/rule/IModulePublishRule" {
    export interface IModulePublishRule {
        id: string;
        libraryId: string;
        typeId: string;
        categoryId: string;
        processId: string;
        code: string;
        name: string;
        version: number;
        levelCd: number;
        statusCd: number;
        functionType: number;
        dataOrder: number;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/common/rule/ModulePublishRule" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { RuleTypeUnit } from 'sk/service/data/logic/module/logic/RuleTypeUnit';
    import { RuleUnit } from 'sk/service/data/logic/module/logic/RuleUnit';
    import { IModulePublishRule } from "sk/service/logic/warehouse/publish/module/data/common/rule/IModulePublishRule";
    export class ModulePublishRule extends InstanceObject implements IModulePublishRule {
        id: string;
        libraryId: string;
        typeId: string;
        categoryId: string;
        processId: string;
        code: string;
        name: string;
        version: number;
        levelCd: number;
        statusCd: number;
        functionType: number;
        dataOrder: number;
        saveJson(): any;
        loadData(rule: RuleUnit, type: RuleTypeUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/common/ruletype/IModulePublishRuleType" {
    export interface IModulePublishRuleType {
        id: string;
        libraryId: string;
        typeCategoryId: string;
        code: string;
        name: string;
        functionType: number;
        version: number;
        levelCd: number;
        processId: string;
        dataOrder: number;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/common/ruletype/ModulePublishRuleType" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { RuleTypeUnit } from 'sk/service/data/logic/module/logic/RuleTypeUnit';
    import { IModulePublishRuleType } from "sk/service/logic/warehouse/publish/module/data/common/ruletype/IModulePublishRuleType";
    export class ModulePublishRuleType extends InstanceObject implements IModulePublishRuleType {
        id: string;
        libraryId: string;
        typeCategoryId: string;
        code: string;
        name: string;
        functionType: number;
        version: number;
        levelCd: number;
        processId: string;
        dataOrder: number;
        saveJson(): any;
        loadData(unit: RuleTypeUnit): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants" {
    export class ModulePublishConstants {
        static readonly TenantFileName: string;
        static readonly BusinessTypeFileName: string;
        static readonly RuleFileName: string;
        static readonly RuleTypeFileName: string;
        static readonly ConfigFileName: string;
        static readonly CompressionConfigFileName: string;
        static readonly PublishFileName = "publish.json";
        static readonly Configure: string;
        static readonly Decorate: string;
        static readonly Variable: string;
        static readonly Parameter: string;
        static readonly Document: string;
        static readonly Symbol: string;
    }
    export enum FeatureReferenceTypeEnum {
        FAMILY_TYPE = "module.family.type",
        FAMILY_CATEGORY = "module.family.category",
        PATTERN_TYPE = "module.pattern.type",
        PATTERN_CATEGORY = "module.pattern.category"
    }
    export enum ConfigureTypeEnum {
        GLOBAL = "global",
        FAMILY = "family",
        PATTERN = "pattern"
    }
    export enum LibraryPublishDataType {
        BASE = 0,
        COMMON = 1,
        MODULE = 2
    }
    export enum LibraryPublishPriorityType {
        HIGH = 0,
        MIDDLE = 1,
        LOW = 2
    }
    export enum LibraryPublishDatasetUpdaterType {
        FAMILY_INFO = "family.info",
        PATTERN_INFO = "pattern.info",
        SYMBOL_INFO = "symbol.info",
        PRODUCT_INFO = "product.info",
        DIGITIZATION_PRODUCT_INFO = "digitization.product.info"
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/configure/IModulePublishConfigConfigureOption" {
    export interface IModulePublishConfigConfigureOption {
        id: string;
        dataValue: any;
        isDefault: number;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/configure/IModulePublishConfigConfigure" {
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    import { IModulePublishConfigConfigureOption } from "sk/service/logic/warehouse/publish/module/data/module/config/configure/IModulePublishConfigConfigureOption";
    export interface IModulePublishConfigConfigure {
        id: string;
        libraryId: string;
        libraryVersion: string;
        type: ConfigureTypeEnum;
        masterId: string;
        configId: string;
        code: string;
        name: string;
        options: IModulePublishConfigConfigureOption[];
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/IModulePublishConfigure" {
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export interface IModulePublishConfigure {
        saveJson(): any;
        loadFromDataUnit(config: DatasetUnit, libraryVersion: string, children?: IModulePublishConfigure[]): void;
        loadFromElement(element: Element, type?: ConfigureTypeEnum, masterId?: string, libraryId?: string, libraryVersion?: string, children?: IModulePublishConfigure[]): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/configure/ModulePublishConfigConfigureOption" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ConfigureOptionElement } from 'sk/data/family/element/config/configure/ConfigureOptionElement';
    import { ConfigConfigureOptionUnit } from 'sk/service/data/logic/module/logic/ConfigConfigureOptionUnit';
    import { IModulePublishConfigure } from "sk/service/logic/warehouse/publish/module/data/module/config/IModulePublishConfigure";
    import { IModulePublishConfigConfigureOption } from "sk/service/logic/warehouse/publish/module/data/module/config/configure/IModulePublishConfigConfigureOption";
    export class ModulePublishConfigConfigureOption extends InstanceObject implements IModulePublishConfigConfigureOption, IModulePublishConfigure {
        id: string;
        dataValue: any;
        isDefault: number;
        saveJson(): any;
        loadFromDataUnit(option: ConfigConfigureOptionUnit): void;
        loadFromElement(option: ConfigureOptionElement): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/configure/ModulePublishConfigConfigure" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ConfigureElement } from 'sk/data/family/element/config/configure/ConfigureElement';
    import { ConfigConfigureUnit } from 'sk/service/data/logic/module/logic/ConfigConfigureUnit';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    import { IModulePublishConfigure } from "sk/service/logic/warehouse/publish/module/data/module/config/IModulePublishConfigure";
    import { IModulePublishConfigConfigure } from "sk/service/logic/warehouse/publish/module/data/module/config/configure/IModulePublishConfigConfigure";
    import { ModulePublishConfigConfigureOption } from "sk/service/logic/warehouse/publish/module/data/module/config/configure/ModulePublishConfigConfigureOption";
    export class ModulePublishConfigConfigure extends InstanceObject implements IModulePublishConfigConfigure, IModulePublishConfigure {
        id: string;
        libraryId: string;
        libraryVersion: string;
        configId: string;
        type: ConfigureTypeEnum;
        masterId: string;
        code: string;
        name: string;
        options: ModulePublishConfigConfigureOption[];
        saveJson(): any;
        loadFromDataUnit(config: ConfigConfigureUnit, libraryVersion: string, children?: ModulePublishConfigConfigureOption[]): void;
        loadFromElement(config: ConfigureElement, type: ConfigureTypeEnum, masterId: string, libraryId: string, libraryVersion: string, children?: ModulePublishConfigConfigureOption[]): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/decorate/IModulePublishConfigDecorate" {
    import { ISpecificationDeclareDecorateItem } from 'sk/data/specification/base/ISpecificationDeclareDecorateItem';
    import { DecorateItemElement } from 'sk/data/family/element/config/decorate/DecorateItemElement';
    import { DecorateBindTypeEnum } from 'sk/data/family/enumeration/DecorateBindTypeEnum';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export class IModulePublishConfigDecorate {
        id: string;
        libraryId: string;
        libraryVersion: string;
        type: ConfigureTypeEnum;
        masterId: string;
        code: string;
        name: string;
        bindingCd: DecorateBindTypeEnum;
        items: ISpecificationDeclareDecorateItem[] | DecorateItemElement[];
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/decorate/ModulePublishConfigDecorateItem" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ISpecificationDeclareDecorateItem } from 'sk/data/specification/base/ISpecificationDeclareDecorateItem';
    import { DecorateItemElement } from 'sk/data/family/element/config/decorate/DecorateItemElement';
    import { DecorateItemBindTypeEnum } from 'sk/data/family/enumeration/DecorateItemBindTypeEnum';
    import { ConfigDecorateItemUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateItemUnit';
    import { IModulePublishConfigure } from "sk/service/logic/warehouse/publish/module/data/module/config/IModulePublishConfigure";
    export class ModulePublishConfigDecorateItem extends InstanceObject implements ISpecificationDeclareDecorateItem, IModulePublishConfigure {
        id: string;
        dataValue: any;
        bindingCd: DecorateItemBindTypeEnum;
        isDefault: number;
        saveJson(): any;
        loadFromDataUnit(item: ConfigDecorateItemUnit): void;
        loadFromElement(item: DecorateItemElement): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/decorate/ModulePublishConfigDecorate" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DecorateElement } from 'sk/data/family/element/config/decorate/DecorateElement';
    import { DecorateBindTypeEnum } from 'sk/data/family/enumeration/DecorateBindTypeEnum';
    import { ConfigDecorateUnit } from 'sk/service/data/logic/module/logic/ConfigDecorateUnit';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    import { IModulePublishConfigure } from "sk/service/logic/warehouse/publish/module/data/module/config/IModulePublishConfigure";
    import { IModulePublishConfigDecorate } from "sk/service/logic/warehouse/publish/module/data/module/config/decorate/IModulePublishConfigDecorate";
    import { ModulePublishConfigDecorateItem } from "sk/service/logic/warehouse/publish/module/data/module/config/decorate/ModulePublishConfigDecorateItem";
    export class ModulePublishConfigDecorate extends InstanceObject implements IModulePublishConfigDecorate, IModulePublishConfigure {
        id: string;
        libraryId: string;
        libraryVersion: string;
        type: ConfigureTypeEnum;
        masterId: string;
        code: string;
        name: string;
        bindingCd: DecorateBindTypeEnum;
        items: ModulePublishConfigDecorateItem[];
        saveJson(): any;
        loadFromDataUnit(decorate: ConfigDecorateUnit, libraryVersion: string, children?: ModulePublishConfigDecorateItem[]): void;
        loadFromElement(decorate: DecorateElement, type: ConfigureTypeEnum, masterId: string, libraryId: string, libraryVersion: string, children?: ModulePublishConfigDecorateItem[]): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/parameter/IModulePublishConfigParameter" {
    import { ParameterTypeEnum } from 'foundation/data/common/enumeration/module/ParameterTypeEnum';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export interface IModulePublishConfigParameter {
        id: string;
        libraryId: string;
        libraryVersion: string;
        type: ConfigureTypeEnum;
        masterId: string;
        code: string;
        name: string;
        dataCd: ParameterTypeEnum;
        dataValue: string;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/parameter/ModulePublishConfigParameter" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ParameterTypeEnum } from 'foundation/data/common/enumeration/module/ParameterTypeEnum';
    import { ParameterElement } from 'sk/data/family/element/config/parameter/ParameterElement';
    import { ConfigParameterUnit } from 'sk/service/data/logic/module/logic/ConfigParameterUnit';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    import { IModulePublishConfigure } from "sk/service/logic/warehouse/publish/module/data/module/config/IModulePublishConfigure";
    import { IModulePublishConfigParameter } from "sk/service/logic/warehouse/publish/module/data/module/config/parameter/IModulePublishConfigParameter";
    export class ModulePublishConfigParameter extends InstanceObject implements IModulePublishConfigParameter, IModulePublishConfigure {
        id: string;
        libraryId: string;
        libraryVersion: string;
        type: ConfigureTypeEnum;
        masterId: string;
        code: string;
        name: string;
        dataCd: ParameterTypeEnum;
        dataValue: string;
        saveJson(): any;
        loadFromDataUnit(parameter: ConfigParameterUnit, libraryVersion: string): void;
        loadFromElement(parameter: ParameterElement, type: ConfigureTypeEnum, masterId: string, libraryId: string, libraryVersion: string): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/variable/IModulePublishConfigVariable" {
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export interface IModulePublishConfigVariable {
        id: string;
        libraryId: string;
        libraryVersion: string;
        type: ConfigureTypeEnum;
        masterId: string;
        code: string;
        name: string;
        dataValue: string;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/module/config/variable/ModulePublishConfigVariable" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { VariableElement } from 'sk/data/family/element/config/variable/VariableElement';
    import { ConfigVariableUnit } from 'sk/service/data/logic/module/logic/ConfigVariableUnit';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    import { IModulePublishConfigure } from "sk/service/logic/warehouse/publish/module/data/module/config/IModulePublishConfigure";
    import { IModulePublishConfigVariable } from "sk/service/logic/warehouse/publish/module/data/module/config/variable/IModulePublishConfigVariable";
    export class ModulePublishConfigVariable extends InstanceObject implements IModulePublishConfigVariable, IModulePublishConfigure {
        id: string;
        libraryId: string;
        libraryVersion: string;
        type: ConfigureTypeEnum;
        masterId: string;
        code: string;
        name: string;
        dataValue: string;
        saveJson(): any;
        loadFromDataUnit(variable: ConfigVariableUnit, libraryVersion: string): void;
        loadFromElement(variable: VariableElement, type: ConfigureTypeEnum, masterId: string, libraryId: string, libraryVersion: string): void;
    }
}
declare module "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { StatisticsOperator } from 'foundation/core/module/statistics/StatisticsOperator';
    import { LibraryHistoryUnit } from 'sk/service/data/logic/module/logic/LibraryHistoryUnit';
    import { ModuleLibraryUnit } from 'sk/service/data/logic/warehouse/logic/ModuleLibraryUnit';
    export class ModulePublishParameter extends InstanceObject {
        private _user;
        private _database;
        private _library;
        private _libraryHistory;
        private _options;
        _resourceLibraryId: string;
        private _currentVersion;
        private _nextVersion;
        private _publishVersion;
        private _statistics;
        constructor();
        static load(jconfig: any): ModulePublishParameter;
        loadLibrary(jconfig: any): void;
        private loadLibraryHistory;
        get user(): LibraryPublishUser;
        get database(): LibraryPublishDatabase;
        get sourceConnectionName(): string;
        get library(): ModuleLibraryUnit;
        get libraryHistory(): LibraryHistoryUnit;
        set statistics(statistics: StatisticsOperator);
        get statistics(): StatisticsOperator;
        get optionBase(): boolean;
        get optionCheck(): boolean;
        get optionRenderIcon(): boolean;
        get optionUploadMaterial(): boolean;
        get optionIncrement(): boolean;
        get resourceLibraryId(): string;
        set currentVersion(version: string);
        get currentVersion(): string;
        set nextVersion(version: string);
        get nextVersion(): string;
        set publishVersion(version: string);
        get publishVersion(): string;
    }
    export class LibraryPublishUser extends InstanceObject {
        private _id;
        private _name;
        static load(jconfig: any): LibraryPublishUser;
        get id(): string;
        get name(): string;
    }
    export class LibraryPublishDatabase extends InstanceObject {
        private _id;
        private _name;
        private _resourceDbId;
        static load(jconfig: any): LibraryPublishDatabase;
        get id(): string;
        get name(): string;
        get resourceDbId(): string;
    }
    export class LibraryPublishOptions extends InstanceObject {
        protected _optionBase: boolean;
        protected _optionRenderIcon: boolean;
        protected _optionCheck: boolean;
        protected _optionUploadMaterial: boolean;
        protected _optionIncrement: boolean;
        constructor();
        static load(jconfig: any): LibraryPublishOptions;
        get optionBase(): boolean;
        get optionCheck(): boolean;
        get optionRenderIcon(): boolean;
        get optionUploadMaterial(): boolean;
        get optionIncrement(): boolean;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishConfigPublisherDeclareInfo" {
    export class ModulePublishConfigPublisherDeclareInfo {
        configType: string;
        clazz: Function;
        static create(configType: string, clazz: Function): ModulePublishConfigPublisherDeclareInfo;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MultiPromiseProcessor } from 'foundation/core/module/process/MultiPromiseProcessor';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { MongoStorageTransferService } from 'foundation/service/common/storage/mongodb/MongoStorageTransferService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { OssResult } from 'foundation/service/common/oss/OssResult';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    export abstract class ModulePublishStoragePublisher extends InstanceObject {
        protected _storageTransferService: MongoStorageTransferService;
        protected _datasetLogicService: DatasetLogicService;
        protected _publishDataService: ModulePublishDataService;
        protected _ossService: OssConnectionService;
        abstract processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        protected createMultiProcessor(multiCount?: number): MultiPromiseProcessor;
        protected createVariableUploadParameter(libraryId: string, libraryVersion: string, id: string, content: any): MongoStorageUploadParameters;
        protected downloadJsonObjectAsync(context: IContext, path: string): Promise<OssResult>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishConfigPublishService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { OssResult } from 'foundation/service/common/oss/OssResult';
    import { WarehouseDatabaseUnit } from 'sk/service/data/logic/warehouse/logic/WarehouseDatabaseUnit';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    import { ModulePublishConfigPublisherDeclareInfo } from "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishConfigPublisherDeclareInfo";
    export class ModulePublishConfigPublishService extends Service {
        protected _publisherInfos: Dictionary<ModulePublishConfigPublisherDeclareInfo>;
        protected _publishDataService: ModulePublishDataService;
        protected _ossService: OssConnectionService;
        registerDeclare(info: ModulePublishConfigPublisherDeclareInfo): void;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        buildConfigContentAsync(context: LogicContext, parameter: ModulePublishParameter, globalContent: any): Promise<ResultObject>;
        private uploadLibraryConfigAsync;
        private mergeGlobalConfigByLibraryId;
        downloadJsonObjectAsync(context: IContext, path: string): Promise<OssResult>;
        rebuildGlobalConfigAsync(context: IContext, databases: Types<WarehouseDatabaseUnit>): Promise<ResultObject>;
        onRebuildGlobalConfigAsync(context: LogicContext, libraryId: string, globalContent: any): Promise<ResultObject>;
        uploadConfigureAsync(context: IContext, content: any, libraryRoot: string, ...parameters: Array<string>): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishConfigPublisherDeclare" {
    export function ModulePublishConfigPublisherDeclare(configType: string): (target: any) => void;
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishDatasetPublisherDeclareInfo" {
    import { DatasetMeta } from 'foundation/service/common/database/DatasetMeta';
    import { LibraryPublishDataType } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export class ModulePublishDatasetPublisherDeclareInfo {
        type: Function;
        meta: DatasetMeta;
        dataType: LibraryPublishDataType;
        static create(clazz: Function, logicClazz: Function, dataType: LibraryPublishDataType): ModulePublishDatasetPublisherDeclareInfo;
    }
}
declare module "sk/service/logic/warehouse/publish/module/util/ModulePublishDatasetUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogic } from 'foundation/service/common/database/DatasetLogic';
    import { DatasetUnit } from 'foundation/service/common/database/DatasetUnit';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { DatabaseOperatorService } from "sk/service/logic/warehouse/database/service/DatabaseOperatorService";
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    export type ModuleLibraryPublishDatasetUnitUpdateParameter = {
        targetContext: LogicContext;
        targetLogic: DatasetLogic;
        batchUnits: Types<DatasetUnit>;
        sourceUnit: DatasetUnit;
        index: number;
        totalCount: number;
        maxCountPerOneTime: number;
    };
    export class ModulePublishDatasetUtil {
        protected static _databaseOperatorService: DatabaseOperatorService;
        static updateUnitsAsync(targetContext: LogicContext, targetLogic: DatasetLogic, updateUnits: Types<DatasetUnit>, parameter: ModulePublishParameter, maxCountPerOneTime?: number): Promise<ResultObject>;
        protected static onUpdateAsync(parameter: ModuleLibraryPublishDatasetUnitUpdateParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/dataset/ModulePublishDatasetPublisher" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { DatasetLogic } from 'foundation/service/common/database/DatasetLogic';
    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 { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { DatasetService } from 'sk/service/data/declare/content/DatasetService';
    import { DatabaseOperatorService } from "sk/service/logic/warehouse/database/service/DatabaseOperatorService";
    import { WarehouseDatabaseService } from "sk/service/logic/warehouse/service/WarehouseDatabaseService";
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    export class ModulePublishDatasetPublisher extends InstanceObject {
        protected _databaseService: WarehouseDatabaseService;
        protected _databaseOperatorService: DatabaseOperatorService;
        protected _datasetLogicService: DatasetLogicService;
        protected _datasetService: DatasetService;
        private readonly _maxCountPerOneTime;
        private prepareAsync;
        processAsync(sourceContext: LogicContext, targetContext: LogicContext, parameter: ModulePublishParameter, datasetMeta: DatasetMeta): Promise<ResultObject>;
        protected getUpdateUnits(sourceDataset: DatasetResult<DatasetUnit>, targetDatasetMap: Dictionary<DatasetUnit>, library: any): {
            sourceDatasetMap: Dictionary<DatasetUnit>;
            updateUnits: Types<DatasetUnit>;
        };
        protected removeUnitsAsync(targetContext: LogicContext, targetLogic: DatasetLogic, sourceDatasetMap: Dictionary<DatasetUnit>, targetDatasetMap: Dictionary<DatasetUnit>, libraryId: string): Promise<ResultObject>;
        protected datasetResult2Map(dataset: DatasetResult<DatasetUnit>): Dictionary<DatasetUnit>;
        protected getUpdateOption(sourceUnit: DatasetUnit, targetUnit: DatasetUnit): boolean;
        protected getRemoveUnits(sourceDatasetMap: Dictionary<DatasetUnit>, targetDatasetMap: Dictionary<DatasetUnit>, libraryId: string): Types<DatasetUnit>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishDatasetPublishService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDatasetPublisherDeclareInfo } from "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishDatasetPublisherDeclareInfo";
    export class ModulePublishDatasetPublishService extends Service {
        protected _publisherInfos: Types<ModulePublishDatasetPublisherDeclareInfo>;
        registerDeclare(info: ModulePublishDatasetPublisherDeclareInfo): void;
        processAsync(sourceContext: LogicContext, targetContext: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private findDeclare;
        private sortByDataType;
        private findDeclareInfos;
        private check;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishDatasetPublisherDeclare" {
    import { LibraryPublishDataType } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export function ModulePublishDatasetPublisherDeclare(logicClazz: any, dataType?: LibraryPublishDataType): (target: any) => void;
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishStoragePublisherDeclareInfo" {
    import { LibraryPublishDataType } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export class ModulePublishStoragePublisherDeclareInfo {
        moduleCd: string;
        clazz: Function;
        dataType: LibraryPublishDataType;
        static create(clazz: Function, moduleCd: string, dataType: LibraryPublishDataType): ModulePublishStoragePublisherDeclareInfo;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishStoragePublishService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisherDeclareInfo } from "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishStoragePublisherDeclareInfo";
    export class ModulePublishStoragePublishService extends Service {
        private readonly _publisherInfos;
        registerDeclare(info: ModulePublishStoragePublisherDeclareInfo): void;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private findDeclare;
        private sortByDataType;
        private findDeclareInfos;
        private check;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/publisher/ModulePublishStoragePublisherDeclare" {
    import { LibraryPublishDataType } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export function ModulePublishStoragePublisherDeclare(moduleCd: string, dataType: LibraryPublishDataType): (target: any) => void;
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/updater/ModulePublishDatasetUpdaterDeclareInfo" {
    import { LibraryPublishDataType } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export class ModulePublishDatasetUpdaterDeclareInfo {
        type: string;
        clazz: Function;
        dataType: LibraryPublishDataType;
        order: number;
        static create(clazz: Function, type: string, dataType: LibraryPublishDataType, order: number): ModulePublishDatasetUpdaterDeclareInfo;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishDatasetUpdater" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    export abstract class ModulePublishDatasetUpdater extends InstanceObject {
        protected _datasetLogicService: DatasetLogicService;
        abstract processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishDatasetUpdateService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDatasetUpdaterDeclareInfo } from "sk/service/logic/warehouse/publish/module/logic/declare/updater/ModulePublishDatasetUpdaterDeclareInfo";
    export class ModulePublishDatasetUpdateService extends Service {
        protected _updaterDeclareInfos: Types<ModulePublishDatasetUpdaterDeclareInfo>;
        registerDeclare(info: ModulePublishDatasetUpdaterDeclareInfo): void;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/declare/updater/ModulePublishDatasetUpdaterDeclare" {
    import { LibraryPublishDataType } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    export function ModulePublishDatasetUpdaterDeclare(type: string, dataType: LibraryPublishDataType, order: number): (target: any) => void;
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/config/ModulePublishConfigurePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishConfigurePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private buildPublishConfigure;
        private buildPublishConfigureOptions;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/config/ModulePublishDecoratePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishDecoratePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private buildPublishDecorate;
        private buildPublishDecorateItems;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/config/ModulePublishParameterPublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishParameterPublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/config/ModulePublishVariablePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishVariablePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private buildPublishVariable;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/dataset/ModulePublishDatasetBasePublisher" {
    import { ModulePublishDatasetPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/dataset/ModulePublishDatasetPublisher";
    export class ModulePublishDatasetBasePublisher extends ModulePublishDatasetPublisher {
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/dataset/ModulePublishDatasetModulePublisher" {
    import { ModulePublishDatasetPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/dataset/ModulePublishDatasetPublisher";
    export class ModulePublishDatasetModulePublisher extends ModulePublishDatasetPublisher {
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishDocumentPublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { StorageModuleTypeEnum } from 'foundation/data/common/enumeration/StorageModuleTypeEnum';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export type ModulePublishDocumentParameter = {
        documentService: DataDocumentService<DataDocument>;
        moduleCd: StorageModuleTypeEnum;
        id: string;
        version: number;
        fileName: string;
        optionCopy?: boolean;
        libraryId?: string;
        libraryVersion?: string;
    };
    export class ModulePublishDocumentPublisher extends ModulePublishStoragePublisher {
        protected _familyConfigService: FamilyConfigService;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        convertDocumentVariableAsync(context: LogicContext, library: {
            id: string;
            version: string;
        }, moduleCd: string, document: FamilyDocument): Promise<ResultObject>;
        createVariableUploadParameters(document: FamilyDocument, type: ConfigureTypeEnum, libraryId: string, libraryVersion: string): Array<MongoStorageUploadParameters>;
        protected processDocumentAsync(context: LogicContext, parameter: ModulePublishDocumentParameter): Promise<ResultObject>;
        createDocumentUploadParameter(moduleCd: StorageModuleTypeEnum, libraryId: string, libraryVersion: string, id: string, content: any, optionCopy?: boolean): MongoStorageUploadParameters;
        createEncryptionDocumentUploadParameter(moduleCd: StorageModuleTypeEnum, libraryId: string, libraryVersion: string, id: string, jsonContent: any, optionCopy?: boolean): MongoStorageUploadParameters;
        createStorageUploadParameter(fileName: string, moduleCd: StorageModuleTypeEnum, content: any): MongoStorageUploadParameters;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishFamilyPublisher" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { DatasetResult } from 'foundation/service/common/database/DatasetResult';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ServiceProcessService } from 'foundation/service/common/process/ServiceProcessService';
    import { SpecificationFamily } from 'sk/data/specification/family/structure/SpecificationFamily';
    import { SpecificationFamilyInfo } from 'sk/data/specification/familyinfo/structure/SpecificationFamilyInfo';
    import { SpecificationFamilySymbol } from 'sk/data/specification/familysymbol/structure/SpecificationFamilySymbol';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilySymbolUnit } from 'sk/service/data/logic/module/logic/FamilySymbolUnit';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PublishFamilyInfoUnit } from 'sk/service/data/logic/module/logic/PublishFamilyInfoUnit';
    import { ModuleLibraryUnit } from 'sk/service/data/logic/warehouse/logic/ModuleLibraryUnit';
    import { ConfigureTypeEnum } from "sk/service/logic/warehouse/publish/module/data/ModulePublishConstants";
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDocumentPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishDocumentPublisher";
    export type ModulePublishFamilyPublishChildProcessSection = {
        index: number;
        processCount: number;
        start: number;
        end: number;
    };
    export type ModulePublishFamilyPublishChildProcessSectionParameter = {
        id: string;
        content: any;
        variables: Array<any>;
        infos: Array<any>;
    };
    export type ModulePublishFamilyPublishStorageInfoCacheParameter = {
        infoUnits: Types<PublishFamilyInfoUnit>;
        infoSymbolMap: Dictionary<PublishFamilyInfoUnit>;
    };
    export type ModulePublishFamilyPublishCacheParameter = {
        infoMap: Dictionary<ModulePublishFamilyPublishStorageInfoCacheParameter>;
        symbolMap: Dictionary<Types<FamilySymbolUnit>>;
    };
    export class ModulePublishFamilyPublisher extends ModulePublishDocumentPublisher {
        protected _documentService: FamilyDocumentService;
        protected _processService: ServiceProcessService;
        protected _optionChildProcess: boolean;
        protected _processDirPaths: Array<string>;
        protected prepareAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject<ModulePublishFamilyPublishCacheParameter>>;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        protected onProcessByMultiProcessorAsync(context: LogicContext, parameter: ModulePublishParameter, cache: ModulePublishFamilyPublishCacheParameter, familyDataset: DatasetResult<FamilyUnit>): Promise<ResultObject>;
        onProcessStorageLogicAsync(context: LogicContext, unit: FamilyUnit, publishParameter: ModulePublishParameter, cache: ModulePublishFamilyPublishCacheParameter): Promise<ResultObject>;
        protected buildPublishInfoParametersAsync(context: LogicContext, specDocument: SpecificationFamily, libraryUnit: ModuleLibraryUnit, unit: FamilyUnit, cache: ModulePublishFamilyPublishCacheParameter): Promise<ResultObject<Array<MongoStorageUploadParameters>>>;
        protected onProcessByChildProcessAsync(context: LogicContext, parameter: ModulePublishParameter, cache: ModulePublishFamilyPublishCacheParameter, familyDataset: DatasetResult<FamilyUnit>, sections: Types<ModulePublishFamilyPublishChildProcessSection>): Promise<ResultObject>;
        protected computeChildProcessSections(familyDataset: DatasetResult<FamilyUnit>): Types<ModulePublishFamilyPublishChildProcessSection>;
        onBuildChildProcessParameterAsync(context: LogicContext, unit: FamilyUnit, parameter: ModulePublishParameter, cache: ModulePublishFamilyPublishCacheParameter): Promise<ResultObject<ModulePublishFamilyPublishChildProcessSectionParameter>>;
        protected buildVariables(document: FamilyDocument, type: ConfigureTypeEnum, libraryId: string, libraryVersion: string): Array<any>;
        protected buildPublishInfosAsync(context: LogicContext, specDocument: SpecificationFamily, libraryUnit: ModuleLibraryUnit, unit: FamilyUnit, cache: ModulePublishFamilyPublishCacheParameter): Promise<ResultObject<Array<any>>>;
        protected buildPublishInfoAsync(context: LogicContext, specDocument: SpecificationFamily, libraryUnit: ModuleLibraryUnit, infoCache: ModulePublishFamilyPublishStorageInfoCacheParameter, unit: FamilyUnit, symbolUnit: FamilySymbolUnit): Promise<ResultObject<SpecificationFamilyInfo>>;
        private runByChildProcessAsync;
        protected createStorageUploadParameters(libraryId: string, libraryVersion: string, sectionParameter: ModulePublishFamilyPublishChildProcessSectionParameter): Array<MongoStorageUploadParameters>;
        setupDocument(document: FamilyDocument, library: {
            id: string;
            version: string;
        }, unit: FamilyUnit, documentVersion: string): void;
        protected createSpecificationDocumentAsync(context: LogicContext, unit: FamilyUnit, content: any, library: {
            id: string;
            version: string;
        }): Promise<SpecificationFamily>;
        getFeaturesOptionsAsync(context: LogicContext): Promise<any>;
        createSpecificationSymbol(infoUnit: PublishFamilyInfoUnit, symbolUnit: FamilySymbolUnit): SpecificationFamilySymbol;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishPatternPublisher" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MongoStorageUploadParameters } from 'foundation/data/common/storage/mongo/MongoStorageUploadParameters';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { SpecificationPattern } from 'sk/data/specification/pattern/structure/SpecificationPattern';
    import { SpecificationPatternInfo } from 'sk/data/specification/patterninfo/structure/SpecificationPatternInfo';
    import { SpecificationPatternSymbol } from 'sk/data/specification/patternsymbol/structure/SpecificationPatternSymbol';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { PatternSymbolUnit } from 'sk/service/data/logic/module/logic/PatternSymbolUnit';
    import { PatternUnit } from 'sk/service/data/logic/module/logic/PatternUnit';
    import { PublishPatternInfoUnit } from 'sk/service/data/logic/module/logic/PublishPatternInfoUnit';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDocumentPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishDocumentPublisher";
    export type ModulePublishPatternPublishCacheParameter = {
        infoSymbolMap: Dictionary<PublishPatternInfoUnit>;
        symbolMap: Dictionary<Types<PatternSymbolUnit>>;
    };
    export class ModulePublishPatternPublisher extends ModulePublishDocumentPublisher {
        protected _documentService: PatternDocumentService;
        protected prepareAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject<ModulePublishPatternPublishCacheParameter>>;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        onProcessAsync(context: LogicContext, unit: PatternUnit, parameter: ModulePublishParameter, cache: ModulePublishPatternPublishCacheParameter): Promise<ResultObject>;
        protected processStorageInfosAsync(context: LogicContext, specDocument: SpecificationPattern, unit: PatternUnit, cache: ModulePublishPatternPublishCacheParameter): Promise<ResultObject<Array<MongoStorageUploadParameters>>>;
        protected processStorageInfoAsync(context: LogicContext, specDocument: SpecificationPattern, infoSymbolMap: Dictionary<PublishPatternInfoUnit>, unit: PatternUnit, symbolUnit: PatternSymbolUnit): Promise<ResultObject<MongoStorageUploadParameters>>;
        setupDocument(document: PatternDocument, library: {
            id: string;
            version: string;
        }, unit: PatternUnit, documentVersion: string): void;
        protected createPublishInfoAsync(context: LogicContext, unit: PatternUnit, infoUnit: PublishPatternInfoUnit): Promise<SpecificationPatternInfo>;
        protected getFeaturesOptionsAsync(context: LogicContext): Promise<any>;
        protected createSpecificationDocumentAsync(context: LogicContext, unit: PatternUnit, content: any, library: {
            id: string;
            version: string;
        }): Promise<SpecificationPattern>;
        protected createSpecificationSymbol(infoUnit: PublishPatternInfoUnit, symbolUnit: PatternSymbolUnit): SpecificationPatternSymbol;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishRuleProcessPublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { RuleProcessDocumentService } from 'sk/data/family/rule/RuleProcessDocumentService';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDocumentPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishDocumentPublisher";
    export class ModulePublishRuleProcessPublisher extends ModulePublishDocumentPublisher {
        protected _documentService: RuleProcessDocumentService;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishRulePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDocumentPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishDocumentPublisher";
    export class ModulePublishRulePublisher extends ModulePublishDocumentPublisher {
        protected _documentService: RuleDocumentService;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishStructurePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { LayoutDocumentService } from 'sk/data/family/structure/layout/LayoutDocumentService';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { SectionDocumentService } from 'sk/data/family/structure/section/SectionDocumentService';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDocumentPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishDocumentPublisher";
    export type ModulePublishStructureParameter = {
        documentService: DataDocumentService<DataDocument>;
        moduleCd: string;
    };
    export class ModulePublishStructurePublisher extends ModulePublishDocumentPublisher {
        protected _profileDocumentService: ProfileDocumentService;
        protected _layoutDocumentService: LayoutDocumentService;
        protected _sectionDocumentService: SectionDocumentService;
        private _publishParameters;
        constructor();
        private setupPublishParameters;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishWorkflowPublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { WorkflowDocumentService } from 'sk/data/family/workflow/WorkflowDocumentService';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDocumentPublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/document/ModulePublishDocumentPublisher";
    export class ModulePublishWorkflowDocumentExporter extends ModulePublishDocumentPublisher {
        protected _documentService: WorkflowDocumentService;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/info/ModulePublishAttributePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishAttributePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private createStorageUploadParameter;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/info/ModulePublishBusinessTypePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishBusinessTypePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private buildAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/info/ModulePublishDecoratePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishDecoratePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private uploadAsync;
        private buildPublishSpecificationDecorateItem;
        private createStorageUploadParameter;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/info/ModulePublishRuleInfoRulePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishRuleInfoRulePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private buildRulesAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/info/ModulePublishRuleInfoRuleTypePublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishRuleInfoRuleTypePublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private buildRuleTypesAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/publisher/info/ModulePublishTenantPublisher" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishStoragePublisher } from "sk/service/logic/warehouse/publish/module/logic/publisher/ModulePublishStoragePublisher";
    export class ModulePublishTenantPublisher extends ModulePublishStoragePublisher {
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        onProcessAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishDigitizationProductUpdater" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    import { ModulePublishDatasetUpdater } from "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishDatasetUpdater";
    export class ModulePublishDigitizationProductUpdater extends ModulePublishDatasetUpdater {
        protected _datasetLogicService: DatasetLogicService;
        protected _publishDataService: ModulePublishDataService;
        private readonly _maxCountPerOneTime;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessAsync;
        private getUpdateUnits;
        private setupContext;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishFamilyInfoUpdater" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDatasetUpdater } from "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishDatasetUpdater";
    export class ModulePublishFamilyInfoUpdater extends ModulePublishDatasetUpdater {
        protected _familyInfoController: PublishFamilyInfoController;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishPatternInfoUpdater" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { PublishPatternInfoController } from 'sk/service/data/logic/module/controller/PublishPatternInfoController';
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDatasetUpdater } from "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishDatasetUpdater";
    export class ModulePublishPatternInfoUpdater extends ModulePublishDatasetUpdater {
        protected _patternInfoController: PublishPatternInfoController;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishProductUpdater" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { TypeSet } from 'cross/runtime/lang/collection/TypeSet';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { ProductCategoryUnit } from 'sk/service/data/logic/module/logic/ProductCategoryUnit';
    import { ProductShowCategoryUnit } from 'sk/service/data/logic/module/logic/ProductShowCategoryUnit';
    import { ProductUnit } from 'sk/service/data/logic/module/logic/ProductUnit';
    import { DatabaseOperatorService } from "sk/service/logic/warehouse/database/service/DatabaseOperatorService";
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDatasetUpdater } from "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishDatasetUpdater";
    export class PublishCategoryTreeNode<T extends ProductCategoryUnit | ProductShowCategoryUnit> extends InstanceObject {
        unit: T;
        parent: T;
        children: Types<PublishCategoryTreeNode<T>>;
        constructor();
    }
    export class ModulePublishProductUpdater extends ModulePublishDatasetUpdater {
        protected _databaseOperatorService: DatabaseOperatorService;
        protected _categoryCodeMap: TypeMap<string, string[]>;
        protected _categoryCodeSet: TypeSet<string>;
        protected _categoryRelation: TypeMap<string, {
            parent: ProductCategoryUnit;
            showParent: ProductShowCategoryUnit;
        }>;
        protected _categoryCodes: {
            firstLevel: string;
            secondLevel: string[];
        }[];
        constructor();
        private initData;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessAsync;
        private updateShowCategoriesAsync;
        private clearShowCategoriesAsync;
        private clearItemUnitByProductAsync;
        private clearShowUnitByProductAsync;
        private updateShowCategoryAsync;
        private buildShowCategoryUnit;
        private updateShowItemByCategoryAsync;
        private buildShowCategoryItemUnit;
        private buildCategoryTreeRootNodes;
        private buildCategoryTreeNodes;
        private buildCategoryTreeNode;
        private buildDataPath;
        updateProductShowAsync(context: LogicContext, showCategoryUnit: ProductShowCategoryUnit, productUnit: ProductUnit, dataOrder: number): Promise<ResultObject>;
        private buildProductShowUnitAsync;
    }
}
declare module "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishSymbolUpdater" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { FamilySymbolUnit } from 'sk/service/data/logic/module/logic/FamilySymbolUnit';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { ProductSymbolUnit } from 'sk/service/data/logic/module/logic/ProductSymbolUnit';
    import { ProductUnit } from 'sk/service/data/logic/module/logic/ProductUnit';
    import { FamilySymbolLogicService } from "sk/service/logic/module/symbol/service/FamilySymbolLogicService";
    import { ProductSymbolLogicService } from "sk/service/logic/module/symbol/service/ProductSymbolLogicService";
    import { FamilySymbolConfigure, SymbolStructure } from "sk/service/logic/module/symbol/structure/SymbolStructure";
    import { SymbolSynchronizationService } from "sk/service/logic/module/service/SymbolSynchronizationService";
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    import { ModulePublishDatasetUpdater } from "sk/service/logic/warehouse/publish/module/logic/updater/ModulePublishDatasetUpdater";
    export type ModulePublishSymbolUpdateCacheParameter = {
        familySymbolMap: Dictionary<Types<FamilySymbolUnit>>;
        productMap: Dictionary<ProductUnit>;
        productSymbolMap: Dictionary<Types<ProductSymbolUnit>>;
    };
    export type ModulePublishSymbolUpdateParameter = {
        familyUnit: FamilyUnit;
        document: FamilyDocument;
        cache: ModulePublishSymbolUpdateCacheParameter;
        configure: FamilySymbolConfigure;
        libraryVersion: string;
    };
    export type ModulePublishSymbolUpdateLogicParameter = {
        symbolStructures: Array<Array<SymbolStructure>>;
        familyUnit: FamilyUnit;
        productUnit: ProductUnit;
        familySymbols: Types<FamilySymbolUnit>;
        productSymbols: Types<ProductSymbolUnit>;
        libraryVersion: string;
    };
    export class ModulePublishSymbolUpdater extends ModulePublishDatasetUpdater {
        protected _familySymbolLogicService: FamilySymbolLogicService;
        protected _productSymbolLogicService: ProductSymbolLogicService;
        protected _publishDataService: ModulePublishDataService;
        protected _documentService: FamilyDocumentService;
        protected _symbolSyncService: SymbolSynchronizationService;
        protected _familyInfoController: PublishFamilyInfoController;
        protected _prepareDataNames: string[];
        private prepareAsync;
        private prepareResourceAsync;
        private fetchResourceAsync;
        processAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessFamilySymbolAsync;
        private processFamilySymbolAsync;
        private processSymbolsByDimensionsAsync;
        insertSymbolsAsync(context: LogicContext, parameter: ModulePublishSymbolUpdateLogicParameter): Promise<ResultObject>;
        private insertSymbolAsync;
        private checkProductSymbolConfig;
        private updateSymbolsAsync;
        private updateFamilySymbolAsync;
        private updateProductSymbolAsync;
        private getUpdateFeatures;
    }
}
declare module "sk/service/logic/warehouse/publish/module/service/ModulePublishCacheService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { WarehouseCacheService } from 'sk/data/warehouse/cache/WarehouseCacheService';
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    export class ModulePublishCacheService extends Service {
        protected _warehouseCacheService: WarehouseCacheService;
        protected _publishDataService: ModulePublishDataService;
        loadAsync(context: LogicContext): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/warehouse/service/WarehouseLibraryHistoryService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { LibraryProcessTypeEnum } from 'sk/data/logic/library/enumeration/LibraryProcessTypeEnum';
    import { EventController } from 'sk/service/data/logic/control/controller/EventController';
    import { EventDto } from 'sk/service/data/logic/control/controller/EventDto';
    import { EventHistoryController } from 'sk/service/data/logic/control/controller/EventHistoryController';
    import { EventHistoryDto } from 'sk/service/data/logic/control/controller/EventHistoryDto';
    import { EventTypeController } from 'sk/service/data/logic/control/controller/EventTypeController';
    import { LibraryHistoryController } from 'sk/service/data/logic/module/controller/LibraryHistoryController';
    import { LibraryHistoryDto } from 'sk/service/data/logic/module/controller/LibraryHistoryDto';
    import { LibraryHistoryUnit } from 'sk/service/data/logic/module/logic/LibraryHistoryUnit';
    import { ModuleLibraryDto } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryDto';
    import { WarehouseDatabaseDto } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDto';
    import { ModuleLibraryUnit } from 'sk/service/data/logic/warehouse/logic/ModuleLibraryUnit';
    export type LibraryHistoryUpdateParameter = {
        sourceConnectionName: string;
        user: {
            id: string;
            name: string;
        };
        optionBase: boolean;
        libraryHistory: any;
    };
    export type LibraryHistoryFindParameter = {
        sourceConnectionName: string;
        historyId: string;
    };
    export class WarehouseLibraryHistoryService extends Service {
        protected _datasetLogicService: DatasetLogicService;
        protected _eventTypeController: EventTypeController;
        protected _eventController: EventController;
        protected _libraryHistoryController: LibraryHistoryController;
        protected _eventHistoryController: EventHistoryController;
        getPublishEventAsync(context: MessageRouterContext, libraryDto: ModuleLibraryDto): Promise<ResultObject<{
            event: EventDto;
            eventHistory: EventHistoryDto;
            history: LibraryHistoryDto;
        }>>;
        updateHistoryAsync(context: MessageRouterContext, historyDto: LibraryHistoryDto, eventDto: EventDto): Promise<ResultObject>;
        getPublishingStatusAsync(context: MessageRouterContext, libraryDto: ModuleLibraryDto): Promise<ResultObject<{
            isPublishing: boolean;
            publishUserName: string;
        }>>;
        insertLibraryHistoryAsync(context: MessageRouterContext, libraryUnit: ModuleLibraryUnit, database: WarehouseDatabaseDto, optionBase: boolean, processType: LibraryProcessTypeEnum): Promise<ResultObject<LibraryHistoryUnit>>;
        private invokeInsertLibraryHistoryAsync;
        findLibraryHistoryAsync(parameter: LibraryHistoryFindParameter): Promise<ResultObject<LibraryHistoryUnit>>;
        private invokeFindLibraryHistoryAsync;
        updateLibraryHistoryAsync(parameter: LibraryHistoryUpdateParameter, result?: ResultObject, statusCd?: number, resultCd?: number): Promise<ResultObject>;
        private invokeUpdateLibraryHistoryAsync;
        private buildLibraryHistoryUnit;
    }
}
declare module "sk/service/logic/warehouse/publish/module/service/ModulePublishLogicService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { CacheConnectionService } from 'cross/service/module/cache/CacheConnectionService';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { DatasetCheckLogicService } from "sk/service/logic/warehouse/check/service/DatasetCheckLogicService";
    import { WarehouseDatabaseService } from "sk/service/logic/warehouse/service/WarehouseDatabaseService";
    import { LibraryHistoryUpdateParameter, WarehouseLibraryHistoryService } from "sk/service/logic/warehouse/service/WarehouseLibraryHistoryService";
    import { ModulePublishConfigPublishService } from "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishConfigPublishService";
    import { ModulePublishDatasetPublishService } from "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishDatasetPublishService";
    import { ModulePublishDatasetUpdateService } from "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishDatasetUpdateService";
    import { ModulePublishStoragePublishService } from "sk/service/logic/warehouse/publish/module/logic/service/ModulePublishStoragePublishService";
    import { ModulePublishParameter } from "sk/service/logic/warehouse/publish/module/data/ModulePublishParameter";
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    export class ModulePublishLogicService extends Service {
        protected _databaseService: WarehouseDatabaseService;
        protected _libraryHistoryService: WarehouseLibraryHistoryService;
        protected _datasetCheckService: DatasetCheckLogicService;
        protected _cacheService: CacheConnectionService;
        protected _datasetLogicService: DatasetLogicService;
        protected _publishDataService: ModulePublishDataService;
        protected _datasetUpdateService: ModulePublishDatasetUpdateService;
        protected _datasetPublishService: ModulePublishDatasetPublishService;
        protected _configPublishService: ModulePublishConfigPublishService;
        protected _storagePublishService: ModulePublishStoragePublishService;
        protected _ossService: OssConnectionService;
        publishAsync(context: IContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private onProcessAsync;
        private onModulePublishAsync;
        private onModulePublishProcessAsync;
        private checkAsync;
        private checkBySpaceAsync;
        publishDatasetAsync(schemeContext: LogicContext, moduleContext: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private processFamilyImageAsync;
        private getNextModuleLibraryVersionAsync;
        onGetModuleLibraryVersionAsync(context: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject<{
            currentVersion: number;
            nextVersion: number;
            publishVersion: number;
        }>>;
        private updateLibraryAsync;
        updateWarehouseModuleLibraryUnitAsync(warehouseContext: LogicContext, parameter: ModulePublishParameter, checkMessages: Array<any>): Promise<ResultObject>;
        private setupLibraryUnit;
        private updateWarehouseLibraryVersionAsync;
        private updateModuleLibraryVersionAsync;
        updateSchemeLibraryVersionAsync(schemeContext: LogicContext, parameter: ModulePublishParameter): Promise<ResultObject>;
        private buildSchemeLibraryVersionUnit;
        private buildLibraryVersionUnit;
        updateLibraryHistoryAsync(parameter: LibraryHistoryUpdateParameter, result?: ResultObject, statusCd?: number, resultCd?: number): Promise<ResultObject>;
        private onUpdateLibraryHistoryAsync;
        private setupContext;
        private processLibraryPublishJsonAsync;
        private getPublishLibraries;
    }
}
declare module "sk/service/logic/warehouse/router/custom/SearchWarehouseRouter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DatasetControllerContext } from 'foundation/service/common/router/database/DatasetControllerContext';
    import { DatasetControllerRouter } from 'foundation/service/common/router/database/DatasetControllerRouter';
    import { ModuleLibraryController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryController';
    import { ResourceLibraryController } from 'sk/service/data/logic/warehouse/controller/ResourceLibraryController';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { WarehouseDatabaseDataspaceController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDataspaceController';
    export class SearchWarehouseRouter extends DatasetControllerRouter {
        protected _warehouseController: WarehouseController;
        protected _modulelibraryController: ModuleLibraryController;
        protected _resourceLibraryController: ResourceLibraryController;
        protected _warehouseDatabaseController: WarehouseDatabaseController;
        protected _warehouseDatabaseDataspaceController: WarehouseDatabaseDataspaceController;
        onGetWarehouseId(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onGetModuleLibrary(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onGetResourceLibrary(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onGetDatabaseId(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        private searchWareHousePageResponseDataAsync;
        private searchWareHousePageResponseDatasAsync;
        private makeWareHousePageResponseDataAsync;
        onDatabaseListRequest(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onResourceLibraryRequest(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        onModuleLibraryRequest(context: DatasetControllerContext, request: any, response: any): Promise<ResultObject>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseDatabaseDataspaceRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DataspaceDeleteRequest } from 'sk/data/logic/warehouse/message/DataspaceDeleteRequest';
    import { DataspaceDeleteResponse } from 'sk/data/logic/warehouse/message/DataspaceDeleteResponse';
    import { DataspaceInsertRequest } from 'sk/data/logic/warehouse/message/DataspaceInsertRequest';
    import { DataspaceInsertResponse } from 'sk/data/logic/warehouse/message/DataspaceInsertResponse';
    import { TenantController } from 'sk/service/data/logic/member/controller/TenantController';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { WarehouseDatabaseDataspaceController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDataspaceController';
    export class WarehouseDatabaseDataspaceRouter extends MessageRouter {
        processCode: string;
        protected _environmentService: EnvironmentService;
        protected _logicInterfaceService: LogicInterfaceService;
        protected _warehouseDatabaseDataspaceController: WarehouseDatabaseDataspaceController;
        protected _warehouseDatabaseController: WarehouseDatabaseController;
        protected _warehouseController: WarehouseController;
        protected _tenantController: TenantController;
        onDataspaceInsertRequestAsync(context: MessageRouterContext, request: DataspaceInsertRequest, response: DataspaceInsertResponse): Promise<MessageResultType>;
        onDataspaceDeleteRequestAsync(context: MessageRouterContext, request: DataspaceDeleteRequest, response: DataspaceDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/service/DatabaseListIntervalService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { StructureTypes } from 'foundation/data/common/structure/StructureTypes';
    import { LogicInvokeAsyncThread } from 'foundation/service/common/router/thread/LogicInvokeAsyncThread';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatabaseListResponseItemsVo } from 'sk/data/logic/warehouse/message/DatabaseListResponse';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { WarehouseDatabaseDataspaceController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDataspaceController';
    export class DatabaseListIntervalService extends Service {
        private _intervalTime;
        private _databases;
        protected _threadService: ThreadService;
        protected thread: LogicInvokeAsyncThread;
        protected _warehouseController: WarehouseController;
        protected _databaseController: WarehouseDatabaseController;
        protected _spaceController: WarehouseDatabaseDataspaceController;
        constructor();
        initializeConfig(jconfig: any): void;
        onActive(): void;
        fetchDatabaseListAsync(context: DataContext): Promise<ResultObject>;
        getDatabaseListAsync(context: DataContext, type: string): Promise<ResultObject<StructureTypes<DatabaseListResponseItemsVo>>>;
        private buildDatabaseListAsync;
        private buildListItemVoAsync;
        private getDataSpacesAsync;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseDatabaseRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { DatabaseCheckDatasetRequest } from 'sk/data/logic/warehouse/message/DatabaseCheckDatasetRequest';
    import { DatabaseCheckDatasetResponse } from 'sk/data/logic/warehouse/message/DatabaseCheckDatasetResponse';
    import { DatabaseFindIdRequest } from 'sk/data/logic/warehouse/message/DatabaseFindIdRequest';
    import { DatabaseFindIdResponse } from 'sk/data/logic/warehouse/message/DatabaseFindIdResponse';
    import { DatabaseListRequest } from 'sk/data/logic/warehouse/message/DatabaseListRequest';
    import { DatabaseListResponse } from 'sk/data/logic/warehouse/message/DatabaseListResponse';
    import { DatasetService } from 'sk/service/data/declare/content/DatasetService';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { WarehouseDatabaseDataspaceController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDataspaceController';
    import { DatabaseListIntervalService } from "sk/service/logic/warehouse/service/DatabaseListIntervalService";
    export class WarehouseDatabaseRouter extends MessageRouter {
        processCode: string;
        protected _databaseListService: DatabaseListIntervalService;
        protected _warehouseDatabaseController: WarehouseDatabaseController;
        protected _warehouseController: WarehouseController;
        protected _warehouseDatabaseDataspaceController: WarehouseDatabaseDataspaceController;
        private readonly _moduleSpaceName;
        private readonly _resourceSpaceName;
        protected _datasetService: DatasetService;
        onDatabaseFindIdRequestAsync(context: MessageRouterContext, request: DatabaseFindIdRequest, response: DatabaseFindIdResponse): Promise<MessageResultType>;
        onDatabaseCheckDatasetRequestAsync(context: MessageRouterContext, request: DatabaseCheckDatasetRequest, response: DatabaseCheckDatasetResponse): Promise<MessageResultType>;
        onDatabaseListRequestAsync(context: MessageRouterContext, request: DatabaseListRequest, response: DatabaseListResponse): Promise<MessageResultType>;
        private buildDatabaseListAsync;
        private buildListItemVoAsync;
        private getDataSpacesAsync;
        makeTableData(type: string): any;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/util/WarehouseLibraryEventUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { EventTypeEnum } from 'sk/data/logic/control/enumeration/event/EventTypeEnum';
    import { LibraryEventStatusResponse } from 'sk/data/logic/warehouse/message/LibraryEventStatusResponse';
    import { ModuleLibraryPublishStatusResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryPublishStatusResponse';
    import { EventDto } from 'sk/service/data/logic/control/controller/EventDto';
    import { EventHistoryDto } from 'sk/service/data/logic/control/controller/EventHistoryDto';
    export class WarehouseLibraryEventUtil extends Service {
        private static _eventTypeController;
        private static _eventController;
        private static _eventHistoryController;
        static getEventAsync(context: MessageRouterContext, libraryId: string, eventType: EventTypeEnum): Promise<ResultObject<{
            event: EventDto;
            eventHistory: EventHistoryDto;
        }>>;
        static getEventStatusAsync(context: MessageRouterContext, libraryId: string, eventType: EventTypeEnum): Promise<ResultObject<{
            isExecuting: boolean;
            userName: string;
        }>>;
        static processEventStatusResponse(context: MessageRouterContext, response: LibraryEventStatusResponse | ModuleLibraryPublishStatusResponse, event: EventDto, eventHistory: EventHistoryDto, requestEventId: string): void;
        static parseEventErrorResult(process: string): string;
        private static processErrorResultInfo;
        private static processErrorMessages;
        private static buildResultInfo;
        private static buildStacks;
        private static parseErrorStack;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseLibraryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { LibraryBackupListRequest } from 'sk/data/logic/warehouse/message/LibraryBackupListRequest';
    import { LibraryBackupListResponse } from 'sk/data/logic/warehouse/message/LibraryBackupListResponse';
    import { LibraryBackupRequest } from 'sk/data/logic/warehouse/message/LibraryBackupRequest';
    import { LibraryBackupResponse } from 'sk/data/logic/warehouse/message/LibraryBackupResponse';
    import { LibraryCreateRequest } from 'sk/data/logic/warehouse/message/LibraryCreateRequest';
    import { LibraryCreateResponse } from 'sk/data/logic/warehouse/message/LibraryCreateResponse';
    import { LibraryEventStatusRequest } from 'sk/data/logic/warehouse/message/LibraryEventStatusRequest';
    import { LibraryEventStatusResponse } from 'sk/data/logic/warehouse/message/LibraryEventStatusResponse';
    import { LibraryInitRequest } from 'sk/data/logic/warehouse/message/LibraryInitRequest';
    import { LibraryInitResponse } from 'sk/data/logic/warehouse/message/LibraryInitResponse';
    import { LibraryRestoreRequest } from 'sk/data/logic/warehouse/message/LibraryRestoreRequest';
    import { LibraryRestoreResponse } from 'sk/data/logic/warehouse/message/LibraryRestoreResponse';
    import { LibraryUpgradeRequest } from 'sk/data/logic/warehouse/message/LibraryUpgradeRequest';
    import { LibraryUpgradeResponse } from 'sk/data/logic/warehouse/message/LibraryUpgradeResponse';
    import { EventController } from 'sk/service/data/logic/control/controller/EventController';
    import { ModuleLibraryController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { WarehouseLibraryInitializeService } from "sk/service/logic/warehouse/service/WarehouseLibraryInitializeService";
    export class WarehouseLibraryRouter extends MessageRouter {
        processCode: string;
        protected _logicInterfaceService: LogicInterfaceService;
        protected _libraryInitializeService: WarehouseLibraryInitializeService;
        protected _ossConnectionService: OssConnectionService;
        protected _eventController: EventController;
        protected _moduleLibraryController: ModuleLibraryController;
        protected _databaseController: WarehouseDatabaseController;
        onLibraryBackupListRequestAsync(context: MessageRouterContext, request: LibraryBackupListRequest, response: LibraryBackupListResponse): Promise<MessageResultType>;
        onLibraryBackupRequestAsync(context: MessageRouterContext, request: LibraryBackupRequest, response: LibraryBackupResponse): Promise<MessageResultType>;
        onLibraryRestoreRequestAsync(context: MessageRouterContext, request: LibraryRestoreRequest, response: LibraryRestoreResponse): Promise<MessageResultType>;
        onLibraryCreateRequestAsync(context: MessageRouterContext, request: LibraryCreateRequest, response: LibraryCreateResponse): Promise<MessageResultType>;
        onLibraryInitRequestAsync(context: MessageRouterContext, request: LibraryInitRequest, response: LibraryInitResponse): Promise<MessageResultType>;
        onLibraryEventStatusRequestAsync(context: MessageRouterContext, request: LibraryEventStatusRequest, response: LibraryEventStatusResponse): Promise<MessageResultType>;
        onLibraryUpgradeRequestAsync(context: MessageRouterContext, request: LibraryUpgradeRequest, response: LibraryUpgradeResponse): Promise<MessageResultType>;
        private processCreateAsync;
        private processUpgradeAsync;
        private getUpgradeLibraries;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseModuleLibraryReferenceRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ModuleLibraryReferenceListRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryReferenceListRequest';
    import { ModuleLibraryReferenceListResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryReferenceListResponse';
    import { ModuleLibraryController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryController';
    import { ModuleLibraryReferenceController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryReferenceController';
    export class WarehouseModuleLibraryReferenceRouter extends MessageRouter {
        processCode: string;
        protected _libraryReferenceController: ModuleLibraryReferenceController;
        protected _libraryController: ModuleLibraryController;
        protected _: any;
        onModuleLibraryReferenceListRequestAsync(context: MessageRouterContext, request: ModuleLibraryReferenceListRequest, response: ModuleLibraryReferenceListResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/service/WarehouseLibraryFixService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { StorageModuleTypeEnum } from 'foundation/data/common/enumeration/StorageModuleTypeEnum';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { LogicContext } from 'foundation/service/common/logic/LogicContext';
    import { OssConnectionService } from 'foundation/service/common/oss/OssConnectionService';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    export class WarehouseLibraryFixService extends Service {
        private readonly _moduleSpaceName;
        protected _datasetLogicService: DatasetLogicService;
        protected _ossService: OssConnectionService;
        protected _familyDocumentService: FamilyDocumentService;
        protected _patternDocumentService: PatternDocumentService;
        processInvokerAsync(databaseId: string): Promise<any>;
        fixAsync(context: LogicContext): Promise<ResultObject>;
        private fixDocumentsAsync;
        fixDocumentAsync(context: LogicContext, documentService: DataDocumentService<DataDocument>, moduleCd: StorageModuleTypeEnum, id: string, version: number): Promise<ResultObject>;
        protected fixDocument(document: FamilyDocument): any;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseModuleLibraryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ModuleLibraryBackupRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryBackupRequest';
    import { ModuleLibraryBackupResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryBackupResponse';
    import { ModuleLibraryCheckRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryCheckRequest';
    import { ModuleLibraryCheckResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryCheckResponse';
    import { ModuleLibraryDeleteRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryDeleteRequest';
    import { ModuleLibraryDeleteResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryDeleteResponse';
    import { ModuleLibraryFixRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryFixRequest';
    import { ModuleLibraryFixResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryFixResponse';
    import { ModuleLibraryImportRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryImportRequest';
    import { ModuleLibraryImportResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryImportResponse';
    import { ModuleLibraryInsertRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryInsertRequest';
    import { ModuleLibraryInsertResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryInsertResponse';
    import { ModuleLibraryListRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryListRequest';
    import { ModuleLibraryListResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryListResponse';
    import { ModuleLibraryPageRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryPageRequest';
    import { ModuleLibraryPageResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryPageResponse';
    import { ModuleLibraryPublishRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryPublishRequest';
    import { ModuleLibraryPublishResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryPublishResponse';
    import { ModuleLibraryPublishStatusRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryPublishStatusRequest';
    import { ModuleLibraryPublishStatusResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryPublishStatusResponse';
    import { ModuleLibraryRebuildGlobalConfigRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryRebuildGlobalConfigRequest';
    import { ModuleLibraryRebuildGlobalConfigResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryRebuildGlobalConfigResponse';
    import { ModuleLibraryUpdateRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryUpdateRequest';
    import { ModuleLibraryUpdateResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryUpdateResponse';
    import { ModuleLibraryUpgradeRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryUpgradeRequest';
    import { ModuleLibraryUpgradeResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryUpgradeResponse';
    import { ModuleLibraryValidateListRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryValidateListRequest';
    import { ModuleLibraryValidateListResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryValidateListResponse';
    import { EventController } from 'sk/service/data/logic/control/controller/EventController';
    import { ModuleLibraryBackupVersionController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryBackupVersionController';
    import { ModuleLibraryController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryController';
    import { ModuleLibraryReferenceController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryReferenceController';
    import { ModuleLibraryVersionController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryVersionController';
    import { ResourceLibraryController } from 'sk/service/data/logic/warehouse/controller/ResourceLibraryController';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { DatasetCheckLogicService } from "sk/service/logic/warehouse/check/service/DatasetCheckLogicService";
    import { WarehouseLibraryFixService } from "sk/service/logic/warehouse/service/WarehouseLibraryFixService";
    import { WarehouseLibraryHistoryService } from "sk/service/logic/warehouse/service/WarehouseLibraryHistoryService";
    import { WarehouseLibraryInitializeService } from "sk/service/logic/warehouse/service/WarehouseLibraryInitializeService";
    export class WarehouseModuleLibraryRouter extends MessageRouter {
        processCode: string;
        protected _logicInterfaceService: LogicInterfaceService;
        protected _libraryInitializeService: WarehouseLibraryInitializeService;
        protected _libraryFixService: WarehouseLibraryFixService;
        protected _libraryHistoryService: WarehouseLibraryHistoryService;
        protected _datasetCheckService: DatasetCheckLogicService;
        protected _datasetLogicService: DatasetLogicService;
        protected _warehouseController: WarehouseController;
        protected _warehouseDatabaseController: WarehouseDatabaseController;
        protected _libraryController: ModuleLibraryController;
        protected _resourceLibraryController: ResourceLibraryController;
        protected _libraryVersionController: ModuleLibraryVersionController;
        protected _referenceController: ModuleLibraryReferenceController;
        protected _moduleLibraryBackupVersionController: ModuleLibraryBackupVersionController;
        protected _eventController: EventController;
        private _libraryHistoryController;
        onModuleLibraryInsertRequestAsync(context: MessageRouterContext, request: ModuleLibraryInsertRequest, response: ModuleLibraryInsertResponse): Promise<MessageResultType>;
        onModuleLibraryPageRequestAsync(context: MessageRouterContext, request: ModuleLibraryPageRequest, response: ModuleLibraryPageResponse): Promise<MessageResultType>;
        onModuleLibraryDeleteRequestAsync(context: MessageRouterContext, request: ModuleLibraryDeleteRequest, response: ModuleLibraryDeleteResponse): Promise<MessageResultType>;
        onModuleLibraryImportRequestAsync(context: MessageRouterContext, request: ModuleLibraryImportRequest, response: ModuleLibraryImportResponse): Promise<MessageResultType>;
        onModuleLibraryPublishRequestAsync(context: MessageRouterContext, request: ModuleLibraryPublishRequest, response: ModuleLibraryPublishResponse): Promise<MessageResultType>;
        onModuleLibraryUpdateRequestAsync(context: MessageRouterContext, request: ModuleLibraryUpdateRequest, response: ModuleLibraryUpdateResponse): Promise<MessageResultType>;
        onModuleLibraryValidateListRequestAsync(context: MessageRouterContext, request: ModuleLibraryValidateListRequest, response: ModuleLibraryValidateListResponse): Promise<MessageResultType>;
        onModuleLibraryCheckRequestAsync(context: MessageRouterContext, request: ModuleLibraryCheckRequest, response: ModuleLibraryCheckResponse): Promise<MessageResultType>;
        onModuleLibraryFixRequestAsync(context: MessageRouterContext, request: ModuleLibraryFixRequest, response: ModuleLibraryFixResponse): Promise<MessageResultType>;
        onModuleLibraryPublishStatusRequestAsync(context: MessageRouterContext, request: ModuleLibraryPublishStatusRequest, response: ModuleLibraryPublishStatusResponse): Promise<MessageResultType>;
        onModuleLibraryUpgradeRequestAsync(context: MessageRouterContext, request: ModuleLibraryUpgradeRequest, response: ModuleLibraryUpgradeResponse): Promise<MessageResultType>;
        onModuleLibraryRebuildGlobalConfigRequestAsync(context: MessageRouterContext, request: ModuleLibraryRebuildGlobalConfigRequest, response: ModuleLibraryRebuildGlobalConfigResponse): Promise<MessageResultType>;
        onModuleLibraryListRequestAsync(context: MessageRouterContext, request: ModuleLibraryListRequest, response: ModuleLibraryListResponse): Promise<MessageResultType>;
        onModuleLibraryBackupRequestAsync(context: MessageRouterContext, request: ModuleLibraryBackupRequest, response: ModuleLibraryBackupResponse): Promise<MessageResultType>;
        private makeLibraryPageResponseDataAsync;
        private processPublishAsync;
        private postPublishRequestAsync;
        private createPublishEventAsync;
        private updateLibraryHistoryAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseModuleLibraryVersionRouter" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ModuleLibraryVersionUpdateContentRequest } from 'sk/data/logic/warehouse/message/ModuleLibraryVersionUpdateContentRequest';
    import { ModuleLibraryVersionUpdateContentResponse } from 'sk/data/logic/warehouse/message/ModuleLibraryVersionUpdateContentResponse';
    import { PublishFamilyInfoController } from 'sk/service/data/logic/module/controller/PublishFamilyInfoController';
    import { PublishPatternInfoController } from 'sk/service/data/logic/module/controller/PublishPatternInfoController';
    import { ModuleLibraryController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryController';
    import { ModuleLibraryVersionController } from 'sk/service/data/logic/warehouse/controller/ModuleLibraryVersionController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    export class WarehouseModuleLibraryVersionRouter extends MessageRouter {
        processCode: string;
        protected _environmentService: EnvironmentService;
        protected _logicInterfaceService: LogicInterfaceService;
        protected _warehouseDatabaseController: WarehouseDatabaseController;
        protected _libraryController: ModuleLibraryController;
        protected _libraryVersionController: ModuleLibraryVersionController;
        protected _familyInfoController: PublishFamilyInfoController;
        protected _patternInfoController: PublishPatternInfoController;
        onModuleLibraryVersionUpdateContentRequestAsync(context: MessageRouterContext, request: ModuleLibraryVersionUpdateContentRequest, response: ModuleLibraryVersionUpdateContentResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseResourceLibraryRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ResourceLibraryCheckRequest } from 'sk/data/logic/warehouse/message/ResourceLibraryCheckRequest';
    import { ResourceLibraryCheckResponse } from 'sk/data/logic/warehouse/message/ResourceLibraryCheckResponse';
    import { ResourceLibraryDeleteRequest } from 'sk/data/logic/warehouse/message/ResourceLibraryDeleteRequest';
    import { ResourceLibraryDeleteResponse } from 'sk/data/logic/warehouse/message/ResourceLibraryDeleteResponse';
    import { ResourceLibraryInsertRequest } from 'sk/data/logic/warehouse/message/ResourceLibraryInsertRequest';
    import { ResourceLibraryInsertResponse } from 'sk/data/logic/warehouse/message/ResourceLibraryInsertResponse';
    import { ResourceLibraryPageRequest } from 'sk/data/logic/warehouse/message/ResourceLibraryPageRequest';
    import { ResourceLibraryPageResponse } from 'sk/data/logic/warehouse/message/ResourceLibraryPageResponse';
    import { ResourceLibraryUpgradeRequest } from 'sk/data/logic/warehouse/message/ResourceLibraryUpgradeRequest';
    import { ResourceLibraryUpgradeResponse } from 'sk/data/logic/warehouse/message/ResourceLibraryUpgradeResponse';
    import { ResourceLibraryController } from 'sk/service/data/logic/warehouse/controller/ResourceLibraryController';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { DatasetCheckLogicService } from "sk/service/logic/warehouse/check/service/DatasetCheckLogicService";
    import { WarehouseLibraryInitializeService } from "sk/service/logic/warehouse/service/WarehouseLibraryInitializeService";
    export class WarehouseResourceLibraryRouter extends MessageRouter {
        processCode: string;
        protected _libraryInitializeService: WarehouseLibraryInitializeService;
        protected _warehouseController: WarehouseController;
        protected _libraryController: ResourceLibraryController;
        protected _warehouseDatabaseController: WarehouseDatabaseController;
        protected _datasetCheckService: DatasetCheckLogicService;
        onResourceLibraryPageRequestAsync(context: MessageRouterContext, request: ResourceLibraryPageRequest, response: ResourceLibraryPageResponse): Promise<MessageResultType>;
        onResourceLibraryInsertRequestAsync(context: MessageRouterContext, request: ResourceLibraryInsertRequest, response: ResourceLibraryInsertResponse): Promise<MessageResultType>;
        onResourceLibraryUpgradeRequestAsync(context: MessageRouterContext, request: ResourceLibraryUpgradeRequest, response: ResourceLibraryUpgradeResponse): Promise<MessageResultType>;
        onResourceLibraryCheckRequestAsync(context: MessageRouterContext, request: ResourceLibraryCheckRequest, response: ResourceLibraryCheckResponse): Promise<MessageResultType>;
        onResourceLibraryDeleteRequestAsync(context: MessageRouterContext, request: ResourceLibraryDeleteRequest, response: ResourceLibraryDeleteResponse): Promise<MessageResultType>;
        private makeLibraryPageResponseDataAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/router/WarehouseWarehouseRouter" {
    import { MessageResultType } from 'cross/data/module/message/MessageResult';
    import { ServerWarehouseService } from 'foundation/service/common/router/database/ServerWarehouseService';
    import { MessageRouter } from 'foundation/service/common/router/message/MessageRouter';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { WarehouseDeleteRequest } from 'sk/data/logic/warehouse/message/WarehouseDeleteRequest';
    import { WarehouseDeleteResponse } from 'sk/data/logic/warehouse/message/WarehouseDeleteResponse';
    import { WarehouseInsertRequest } from 'sk/data/logic/warehouse/message/WarehouseInsertRequest';
    import { WarehouseInsertResponse } from 'sk/data/logic/warehouse/message/WarehouseInsertResponse';
    import { WarehouseListRequest } from 'sk/data/logic/warehouse/message/WarehouseListRequest';
    import { WarehouseListResponse } from 'sk/data/logic/warehouse/message/WarehouseListResponse';
    import { WarehouseSearchRequest } from 'sk/data/logic/warehouse/message/WarehouseSearchRequest';
    import { WarehouseSearchResponse } from 'sk/data/logic/warehouse/message/WarehouseSearchResponse';
    import { WarehouseController } from 'sk/service/data/logic/warehouse/controller/WarehouseController';
    import { WarehouseDatabaseController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseController';
    import { WarehouseDatabaseDataspaceController } from 'sk/service/data/logic/warehouse/controller/WarehouseDatabaseDataspaceController';
    import { WarehouseLibraryInitializeService } from "sk/service/logic/warehouse/service/WarehouseLibraryInitializeService";
    export class WarehouseWarehouseRouter extends MessageRouter {
        processCode: string;
        protected _libraryInitializeService: WarehouseLibraryInitializeService;
        protected _warehouseService: ServerWarehouseService;
        protected _warehouseController: WarehouseController;
        protected _databaseController: WarehouseDatabaseController;
        protected _dataSpaceController: WarehouseDatabaseDataspaceController;
        onWarehouseListRequestAsync(context: MessageRouterContext, request: WarehouseListRequest, response: WarehouseListResponse): Promise<MessageResultType>;
        onWarehouseSearchRequestAsync(context: MessageRouterContext, request: WarehouseSearchRequest, response: WarehouseSearchResponse): Promise<MessageResultType>;
        onWarehouseInsertRequestAsync(context: MessageRouterContext, request: WarehouseInsertRequest, response: WarehouseInsertResponse): Promise<MessageResultType>;
        onWarehouseDeleteRequestAsync(context: MessageRouterContext, request: WarehouseDeleteRequest, response: WarehouseDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/warehouse/service/WarehouseLibraryManageService" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Service } from 'cross/runtime/module/Service';
    import { DatasetLogicService } from 'foundation/service/common/router/database/DatasetLogicService';
    import { ServerWarehouseService } from 'foundation/service/common/router/database/ServerWarehouseService';
    import { WarehouseDatabaseUnit } from 'sk/service/data/logic/warehouse/logic/WarehouseDatabaseUnit';
    import { ModulePublishDataService } from "sk/service/logic/warehouse/publish/module/service/ModulePublishDataService";
    import { DatabaseOperatorService } from "sk/service/logic/warehouse/database/service/DatabaseOperatorService";
    import { LibraryDataInitService } from "sk/service/logic/warehouse/init/LibraryDataInitService";
    import { WarehouseDatabaseService } from "sk/service/logic/warehouse/service/WarehouseDatabaseService";
    import { LibraryCreateParameter, WarehouseLibraryInitializeService } from "sk/service/logic/warehouse/service/WarehouseLibraryInitializeService";
    export type LibraryUpgradeParameter = {
        baseDatabase: WarehouseDatabaseUnit;
        templateDatabase: WarehouseDatabaseUnit;
        database: WarehouseDatabaseUnit;
        dataSpaces: Array<string>;
        tenantId: string;
        logicType: LibraryLogicType;
    };
    export enum LibraryLogicType {
        Base = 0,
        Template = 1,
        Business = 2
    }
    export class WarehouseLibraryManageService extends Service {
        protected _libraryInitializeService: WarehouseLibraryInitializeService;
        protected _datasetLogicService: DatasetLogicService;
        protected _warehouseService: ServerWarehouseService;
        protected _databaseService: WarehouseDatabaseService;
        protected _databaseOperatorService: DatabaseOperatorService;
        protected _publishDataService: ModulePublishDataService;
        protected _environmentService: EnvironmentService;
        protected _libraryInitService: LibraryDataInitService;
        private _templateDatabaseNames;
        constructor();
        private initTemplateDatabaseNames;
        createAsync(data: any): Promise<ResultObject>;
        private createModuleAsync;
        private onCreateModuleAsync;
        private createResourceAsync;
        private onCreateResourceAsync;
        private getWarehouseUnitAsync;
        createPhysicalDatabasesAsync(parameters: Array<LibraryCreateParameter>, optionFull?: boolean): Promise<ResultObject>;
        private createPhysicalDatabaseAsync;
        private importBaseAsync;
        private importTemplateAsync;
        private initLibraryAsync;
        private getTemplateDatabaseUnitAsync;
        private getTemplateDatabaseName;
        private getConnectionName;
        private importDataBySpaceAsync;
        upgradeAsync(data: any): Promise<ResultObject>;
        private onUpgradeAsync;
        private upgradeLibraryAsync;
        private upgradeLibraryByLogicTypeAsync;
        private upgradeBusinessLibraryAsync;
        private buildUpgradeParameterAsync;
        private getLibraryLogicType;
        private buildLibraryParameterAsync;
        private upgradeLibraryBySpacesAsync;
        private upgradeBySpaceLibraryAsync;
        private upgradeFromSourceLibraryAsync;
        initAsync(parameter: any): Promise<ResultObject>;
    }
}