/// <reference path="../library/typings/cross-service.d.ts" />
/// <reference path="../typings/private/foundation-service-common.d.ts" />
/// <reference path="../typings/private/foundation-data-common.d.ts" />
/// <reference path="../typings/private/sk-data-logic.d.ts" />
/// <reference path="../typings/private/sk-data-furniture.d.ts" />
/// <reference path="../typings/private/sk-data-family.d.ts" />
/// <reference path="../typings/private/sk-service-data-logic.d.ts" />
declare module "copyright" {
    export class ServiceFurnitureCopyright {
        static toString(): string;
    }
}
declare module "sk/service/logic/furniture/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/service/logic/furniture/pdms/codefindid/BusinessManageCodeId" {
    export class BusinessManageCodeId {
        static categoryStorage: Object;
        static typeStorage: Object;
        static masterStorage: Object;
        static storageGetValue(storage: any, code: string): string;
        static storageSetValue(storage: any, code: string, value: string): void;
        static typeFindIdByCodeAsync(code: string): Promise<string>;
    }
}
declare module "sk/service/logic/furniture/pdms/codefindid/MaterialManageCodeId" {
    export class MaterialManageCodeId {
        static categoryStorage: Object;
        static typeStorage: Object;
        static masterStorage: Object;
        static storageGetValue(storage: any, code: string): string;
        static storageSetValue(storage: any, code: string, value: string): void;
        static categoryFindIdByCodeAsync(code: string): Promise<string>;
        static typeFindIdByCodeAsync(code: string): Promise<string>;
        static masterFindIdByCodeAsync(code: string): Promise<void>;
    }
}
declare module "sk/service/logic/furniture/pdms/router/PdmsComponentHardwareRouter" {
    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 { HardwareDeleteRequest } from 'sk/data/furniture/pdms/message/HardwareDeleteRequest';
    import { HardwareDeleteResponse } from 'sk/data/furniture/pdms/message/HardwareDeleteResponse';
    import { HardwareGetRequest } from 'sk/data/furniture/pdms/message/HardwareGetRequest';
    import { HardwareGetResponse } from 'sk/data/furniture/pdms/message/HardwareGetResponse';
    import { HardwareInsertRequest } from 'sk/data/furniture/pdms/message/HardwareInsertRequest';
    import { HardwareInsertResponse } from 'sk/data/furniture/pdms/message/HardwareInsertResponse';
    import { HardwarePageRequest } from 'sk/data/furniture/pdms/message/HardwarePageRequest';
    import { HardwarePageResponse } from 'sk/data/furniture/pdms/message/HardwarePageResponse';
    import { HardwareUpdateRequest } from 'sk/data/furniture/pdms/message/HardwareUpdateRequest';
    import { HardwareUpdateResponse } from 'sk/data/furniture/pdms/message/HardwareUpdateResponse';
    export class PdmsComponentHardwareRouter extends MessageRouter {
        processCode: string;
        hardwareTypeToIdEnumAsync: (type: any) => Promise<{
            typeId: string;
            categoryId: string;
        }>;
        onHardwareGetRequestAsync(context: MessageRouterContext, request: HardwareGetRequest, response: HardwareGetResponse): Promise<MessageResultType>;
        onHardwareInsertRequestAsync(context: MessageRouterContext, request: HardwareInsertRequest, response: HardwareInsertResponse): Promise<MessageResultType>;
        onHardwareUpdateRequestAsync(context: MessageRouterContext, request: HardwareUpdateRequest, response: HardwareUpdateResponse): Promise<MessageResultType>;
        onHardwarePageRequestAsync(context: MessageRouterContext, request: HardwarePageRequest, response: HardwarePageResponse): Promise<MessageResultType>;
        onHardwareDeleteRequestAsync(context: MessageRouterContext, request: HardwareDeleteRequest, response: HardwareDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog" {
    export class ExecuteLog {
        success: boolean;
        message: string;
        id: string;
        code: string;
        constructor(success: boolean, message: string, id?: string, code?: string);
    }
}
declare module "sk/service/logic/furniture/pdms/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/furniture/pdms/libraryinit/dataconfig/dataload/LibraryInitDataLoad" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class LibraryInitDataLoad {
        protected static _environmentService: EnvironmentService;
        static startDataLoadAsync(context: MessageRouterContext, config?: any): Promise<ExecuteLog>;
        static clearData(): void;
    }
}
declare module "sk/service/logic/furniture/pdms/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/furniture/pdms/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/furniture/pdms/libraryinit/datacheck/datacheckattributes/DataCheckAttributes" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckAttributes {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckcategory/DataCheckCategory" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckCategory {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckfamily/DataCheckPreFamily" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckPreFamily {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckrule/DataCheckRule" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckRule {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckstructure/DataCheckPreStructure" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckPreStructure {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/DataCheckAll" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckAll {
        static startDataCheckAllAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationcategory/DataCreationCategory" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationCategory {
        static startDataCreationAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationcategoryfeatures/DataCreationCategoryFeatures" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { AttributeController } from 'sk/service/data/logic/module/controller/AttributeController';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FeatureController } from 'sk/service/data/logic/module/controller/FeatureController';
    import { FeatureGroupController } from 'sk/service/data/logic/module/controller/FeatureGroupController';
    export class DataCreationCategoryFeatures {
        protected static _familyCategoryController: FamilyCategoryController;
        protected static _featureController: FeatureController;
        protected static _featureGroupController: FeatureGroupController;
        protected static _attributeController: AttributeController;
        static startDataCreationAsync(context: MessageRouterContext): Promise<any>;
        static makeJson(jsonArr: any, code: string, name: string, attributeId: string): any;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationcategorysymbols/DataCreationCategorySymbols" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { AttributeController } from 'sk/service/data/logic/module/controller/AttributeController';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FeatureController } from 'sk/service/data/logic/module/controller/FeatureController';
    import { FeatureGroupController } from 'sk/service/data/logic/module/controller/FeatureGroupController';
    export class DataCreationCategorySymbols {
        protected static _familyCategoryController: FamilyCategoryController;
        protected static _featureController: FeatureController;
        protected static _featureGroupController: FeatureGroupController;
        protected static _attributeController: AttributeController;
        static startDataCreationAsync(context: MessageRouterContext): Promise<any>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationcategoryvariable/DataCreationCategoryVariable" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ConfigVariableController } from 'sk/service/data/logic/module/controller/ConfigVariableController';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    export class DataCreationCategoryVariable {
        protected static _familyCategoryController: FamilyCategoryController;
        protected static _configVariableController: ConfigVariableController;
        static startDataCreationAsync(context: MessageRouterContext): Promise<any>;
    }
}
declare module "sk/service/logic/furniture/pdms/codefindid/StructureManageCodeId" {
    export class StructureManageCodeId {
        static categoryStorage: Object;
        static typeStorage: Object;
        static masterStorage: Object;
        static storageGetValue(storage: any, code: string): string;
        static storageSetValue(storage: any, code: string, value: string): void;
        static categoryFindIdByCodeAsync(code: string): Promise<string>;
        static typeFindIdByCodeAsync(code: string): Promise<string>;
        static masterFindIdByCodeAsync(code: string): Promise<string>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationfamily/DataCreationPreFamily" {
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    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 { FamilySymbolSyncResponse } from 'sk/data/logic/module/message/FamilySymbolSyncResponse';
    import { ConfigDecorateItemSyncResponse } from 'sk/data/logic/perspective/message/ConfigDecorateItemSyncResponse';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationPreFamily {
        protected static _documentService: FamilyDocumentService;
        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: MessageRouterContext): Promise<ExecuteLog>;
        static createThreeOneAsync(context: MessageRouterContext, tenantId: string, libraryId: string, item: any): Promise<ExecuteLog>;
        static createHandleAsync(context: MessageRouterContext, tenantId: string, libraryId: string, item: any): Promise<ExecuteLog>;
        static createRulePanelAsync(context: MessageRouterContext, tenantId: string, libraryId: string, item: any): Promise<ExecuteLog>;
        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: MessageRouterContext, id: string, document: any): Promise<any>;
        static addElement(selectedElement: any, clazz: any): any;
        static getCategoryIdAsync(context: MessageRouterContext, categoryCode: string): Promise<any>;
        static getTypeIdAsync(context: MessageRouterContext, code: string): Promise<string | false>;
        protected static initElementPropertyDefaultValue(element: Element): Promise<ExecuteLog>;
        static syncSymbolAsync(context: MessageRouterContext, query?: any): Promise<FamilySymbolSyncResponse>;
        static syncDecorateItemAsync(context: MessageRouterContext, obj?: any): Promise<ConfigDecorateItemSyncResponse>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationrule/DataCreationPreRule" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationPreRule {
        static startDataCreationAsync(context: MessageRouterContext): Promise<ExecuteLog>;
        static createPanelExpandRuleAsync(context: MessageRouterContext, tenantId: string, libraryId: string, item: any): Promise<ExecuteLog>;
        static createPanelFindRuleAsync(context: MessageRouterContext, tenantId: string, libraryId: string, item: any): Promise<ExecuteLog>;
        static getRuleCategoryIdAsync(context: MessageRouterContext, categoryCode: string): Promise<any>;
        static getRuleTypeIdAsync(context: MessageRouterContext, code: string): Promise<string | false>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/DataCreationAll" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationAll {
        static startDataCreationAllAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/router/PdmsLibraryInitRouter" {
    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 { InitInitgetRequest } from 'sk/data/furniture/pdms/message/InitInitgetRequest';
    import { InitInitgetResponse } from 'sk/data/furniture/pdms/message/InitInitgetResponse';
    import { InitInitRequest } from 'sk/data/furniture/pdms/message/InitInitRequest';
    import { InitInitResponse } from 'sk/data/furniture/pdms/message/InitInitResponse';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    export class PdmsLibraryInitRouter extends MessageRouter {
        processCode: string;
        protected _familyController: FamilyController;
        protected _familyCategoryController: FamilyCategoryController;
        protected _familyDocumentService: FamilyDocumentService;
        onInitInitRequestAsync(context: MessageRouterContext, request: InitInitRequest, response: InitInitResponse): Promise<MessageResultType>;
        onInitInitgetRequestAsync(context: MessageRouterContext, request: InitInitgetRequest, response: InitInitgetResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/furniture/pdms/router/PdmsMaterielsEdgeRouter" {
    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 { FamilyStructureService } from 'sk/data/family/library/FamilyStructureService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { EdgeDeleteRequest } from 'sk/data/furniture/pdms/message/EdgeDeleteRequest';
    import { EdgeDeleteResponse } from 'sk/data/furniture/pdms/message/EdgeDeleteResponse';
    import { EdgeGetRequest } from 'sk/data/furniture/pdms/message/EdgeGetRequest';
    import { EdgeGetResponse } from 'sk/data/furniture/pdms/message/EdgeGetResponse';
    import { EdgeInsertRequest } from 'sk/data/furniture/pdms/message/EdgeInsertRequest';
    import { EdgeInsertResponse } from 'sk/data/furniture/pdms/message/EdgeInsertResponse';
    import { EdgePageRequest } from 'sk/data/furniture/pdms/message/EdgePageRequest';
    import { EdgePageResponse } from 'sk/data/furniture/pdms/message/EdgePageResponse';
    import { EdgeUpdateRequest } from 'sk/data/furniture/pdms/message/EdgeUpdateRequest';
    import { EdgeUpdateResponse } from 'sk/data/furniture/pdms/message/EdgeUpdateResponse';
    import { ConfigDecorateController } from 'sk/service/data/logic/module/controller/ConfigDecorateController';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    export class PdmsMaterielsEdgeRouter extends MessageRouter {
        processCode: string;
        protected _configDecorateController: ConfigDecorateController;
        protected _familyCategoryController: FamilyCategoryController;
        protected _documentService: FamilyDocumentService;
        protected _familyStructureService: FamilyStructureService;
        documentFindPlane: (documentLoadResult: any) => any;
        onEdgeGetRequestAsync(context: MessageRouterContext, request: EdgeGetRequest, response: EdgeGetResponse): Promise<MessageResultType>;
        onEdgeInsertRequestAsync(context: MessageRouterContext, request: EdgeInsertRequest, response: EdgeInsertResponse): Promise<MessageResultType>;
        onEdgeUpdateRequestAsync(context: MessageRouterContext, request: EdgeUpdateRequest, response: EdgeUpdateResponse): Promise<MessageResultType>;
        onEdgePageRequestAsync(context: MessageRouterContext, request: EdgePageRequest, response: EdgePageResponse): Promise<MessageResultType>;
        onEdgeDeleteRequestAsync(context: MessageRouterContext, request: EdgeDeleteRequest, response: EdgeDeleteResponse): Promise<MessageResultType>;
        private buildCategoryNamesAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/furniture/pdms/router/PdmsMaterielsPdmsmaterialRouter" {
    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 { FamilyStructureService } from 'sk/data/family/library/FamilyStructureService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { PdmsmaterialDeleteRequest } from 'sk/data/furniture/pdms/message/PdmsmaterialDeleteRequest';
    import { PdmsmaterialDeleteResponse } from 'sk/data/furniture/pdms/message/PdmsmaterialDeleteResponse';
    import { PdmsmaterialGetRequest } from 'sk/data/furniture/pdms/message/PdmsmaterialGetRequest';
    import { PdmsmaterialGetResponse } from 'sk/data/furniture/pdms/message/PdmsmaterialGetResponse';
    import { PdmsmaterialInsertRequest } from 'sk/data/furniture/pdms/message/PdmsmaterialInsertRequest';
    import { PdmsmaterialInsertResponse } from 'sk/data/furniture/pdms/message/PdmsmaterialInsertResponse';
    import { PdmsmaterialPageRequest } from 'sk/data/furniture/pdms/message/PdmsmaterialPageRequest';
    import { PdmsmaterialPageResponse } from 'sk/data/furniture/pdms/message/PdmsmaterialPageResponse';
    import { PdmsmaterialUpdateRequest } from 'sk/data/furniture/pdms/message/PdmsmaterialUpdateRequest';
    import { PdmsmaterialUpdateResponse } from 'sk/data/furniture/pdms/message/PdmsmaterialUpdateResponse';
    import { ConfigDecorateController } from 'sk/service/data/logic/module/controller/ConfigDecorateController';
    import { ConfigDecorateItemController } from 'sk/service/data/logic/module/controller/ConfigDecorateItemController';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    export class PdmsMaterielsPdmsmaterialRouter extends MessageRouter {
        processCode: string;
        protected _documentService: FamilyDocumentService;
        protected _configDecorateController: ConfigDecorateController;
        protected _familyStructureService: FamilyStructureService;
        protected _configDecorateItemController: ConfigDecorateItemController;
        protected _familyCategoryController: FamilyCategoryController;
        documentFindPlane: (documentLoadResult: any) => any;
        documentFindSpatial: (documentLoadResult: any) => any;
        onPdmsmaterialGetRequestAsync(context: MessageRouterContext, request: PdmsmaterialGetRequest, response: PdmsmaterialGetResponse): Promise<MessageResultType>;
        onPdmsmaterialInsertRequestAsync(context: MessageRouterContext, request: PdmsmaterialInsertRequest, response: PdmsmaterialInsertResponse): Promise<MessageResultType>;
        onPdmsmaterialUpdateRequestAsync(context: MessageRouterContext, request: PdmsmaterialUpdateRequest, response: PdmsmaterialUpdateResponse): Promise<MessageResultType>;
        onPdmsmaterialPageRequestAsync(context: MessageRouterContext, request: PdmsmaterialPageRequest, response: PdmsmaterialPageResponse): Promise<MessageResultType>;
        onPdmsmaterialDeleteRequestAsync(context: MessageRouterContext, request: PdmsmaterialDeleteRequest, response: PdmsmaterialDeleteResponse): Promise<MessageResultType>;
        private buildCategoryNamesAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/furniture/pdms/router/PdmsMaterielsTextureRouter" {
    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 { Element } from 'sk/data/family/element/base/Element';
    import { FamilyStructureService } from 'sk/data/family/library/FamilyStructureService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { TextureDeleteRequest } from 'sk/data/furniture/pdms/message/TextureDeleteRequest';
    import { TextureDeleteResponse } from 'sk/data/furniture/pdms/message/TextureDeleteResponse';
    import { TextureGetRequest } from 'sk/data/furniture/pdms/message/TextureGetRequest';
    import { TextureGetResponse } from 'sk/data/furniture/pdms/message/TextureGetResponse';
    import { TextureInsertBatchRequest } from 'sk/data/furniture/pdms/message/TextureInsertBatchRequest';
    import { TextureInsertBatchResponse } from 'sk/data/furniture/pdms/message/TextureInsertBatchResponse';
    import { TextureInsertRequest } from 'sk/data/furniture/pdms/message/TextureInsertRequest';
    import { TextureInsertResponse } from 'sk/data/furniture/pdms/message/TextureInsertResponse';
    import { TexturePageRequest } from 'sk/data/furniture/pdms/message/TexturePageRequest';
    import { TexturePageResponse } from 'sk/data/furniture/pdms/message/TexturePageResponse';
    import { TextureUpdateRequest } from 'sk/data/furniture/pdms/message/TextureUpdateRequest';
    import { TextureUpdateResponse } from 'sk/data/furniture/pdms/message/TextureUpdateResponse';
    import { FamilyCategoryController } from 'sk/service/data/logic/module/controller/FamilyCategoryController';
    export class PdmsMaterielsTextureRouter extends MessageRouter {
        processCode: string;
        protected _documentService: FamilyDocumentService;
        protected _familyStructureService: FamilyStructureService;
        protected _familyCategoryController: FamilyCategoryController;
        _loadDocumentAsync(id: string): Promise<void>;
        protected initElementPropertyDefaultValue(element: Element): void;
        selectedElement: any;
        protected onAddElement: (clazz: any) => () => void;
        documentFindPlane: (documentLoadResult: any) => any;
        insertTextureAsync: (response: any, data: any) => Promise<any>;
        onTextureGetRequestAsync(context: MessageRouterContext, request: TextureGetRequest, response: TextureGetResponse): Promise<MessageResultType>;
        onTextureInsertBatchRequestAsync(context: MessageRouterContext, request: TextureInsertBatchRequest, response: TextureInsertBatchResponse): Promise<MessageResultType>;
        onTextureInsertRequestAsync(context: MessageRouterContext, request: TextureInsertRequest, response: TextureInsertResponse): Promise<MessageResultType>;
        onTextureUpdateRequestAsync(context: MessageRouterContext, request: TextureUpdateRequest, response: TextureUpdateResponse): Promise<MessageResultType>;
        onTexturePageRequestAsync(context: MessageRouterContext, request: TexturePageRequest, response: TexturePageResponse): Promise<MessageResultType>;
        onTextureDeleteRequestAsync(context: MessageRouterContext, request: TextureDeleteRequest, response: TextureDeleteResponse): Promise<MessageResultType>;
        private buildCategoryNamesAsync;
        getRouter(): any;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateBase" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    export class LibraryUpdateProcessResult {
        updateCount: number;
        tableCount: number;
        recordCount: number;
        familyCount: number;
        message: string;
    }
    export class LibraryContentUpdateBase {
        processAsync(context: RouterContext): Promise<ResultObject<LibraryUpdateProcessResult>>;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { LibraryContentUpdateBase } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateBase";
    export class LibraryContentUpdateService extends Service {
        protected _processors: Dictionary<any>;
        register(name: string, processor: any): void;
        protected getProcessor(updateCode: string): LibraryContentUpdateBase;
        processAsync(context: RouterContext, updateCode: string): Promise<ResultObject>;
    }
}
declare module "sk/service/logic/furniture/pdms/router/PdmsPublishLibraryRouter" {
    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 { LibraryContentUpdateRequest } from 'sk/data/furniture/pdms/message/LibraryContentUpdateRequest';
    import { LibraryContentUpdateResponse } from 'sk/data/furniture/pdms/message/LibraryContentUpdateResponse';
    import { LibraryContentUpdateService } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateService";
    export class PdmsPublishLibraryRouter extends MessageRouter {
        processCode: string;
        protected _libraryContentUpdateService: LibraryContentUpdateService;
        onLibraryContentUpdateRequestAsync(context: MessageRouterContext, request: LibraryContentUpdateRequest, response: LibraryContentUpdateResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}
declare module "sk/service/logic/furniture/pdms/LogicFurnitureModuleRouterUtil" {
    export class LogicFurnitureModuleRouterUtil {
        static register(app: any): void;
    }
}
declare module "sk/service/logic/furniture/LogicFurnitureRouterUtil" {
    export class LogicFurnitureRouterUtil {
        static register(app: any): void;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/data/PdmsChekcerCode" {
    export class PdmsCheckerCode {
        static PdmsFamilyPlank: string;
        static PdmsFamilyDoorPlank: string;
        static PdmsFamilyHardware: string;
        static PdmsFamilyLinear: string;
        static PdmsFamilySlidingDoor: string;
        static PdmsFamilyAssembly: string;
        static PdmsFamilyChest: string;
        static PdmsFamilyStandard: string;
        static PdmsFamilyDecorateSurface: string;
        static PdmsRuleStructureHardware: string;
        static PdmsRuleHingeHardware: string;
        static PdmsRuleHandle: string;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    export class PdmsFamilyChecker extends InstanceObject {
        checkFilterOptionAsync(context: DataContext, unit: FamilyUnit, filterOption?: DatasetUnitCheckFilterOption): Promise<boolean>;
        private filterCategoryAsync;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyAssemblyChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyAssemblyChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChestChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyChestChecker extends PdmsFamilyChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyDecorateSurfaceChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyDecorateSurfaceChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyDoorPlankChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyDoorPlankChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyHardwareChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyHardwareChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyLinearChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyLinearChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyPlankChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyPlankChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilySlidingDoorChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilySlidingDoorChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyStandardChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { DatasetUnitCheckResultInfo } from 'sk/service/data/logic/warehouse/check/info/DataCheckResultInfo';
    import { IDatasetUnitChecker } from 'sk/service/data/logic/warehouse/check/interface/IDatasetUnitChecker';
    import { FamilyUnit } from 'sk/service/data/logic/module/logic/FamilyUnit';
    import { PdmsFamilyChecker } from "sk/service/logic/furniture/pdms/checker/unit/family/PdmsFamilyChecker";
    export class PdmsFamilyStandardChecker extends PdmsFamilyChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: FamilyUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/rule/PdmsRuleChecker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    import { RuleUnit } from 'sk/service/data/logic/module/logic/RuleUnit';
    export class PdmsRuleChecker extends InstanceObject {
        checkFilterOptionAsync(context: DataContext, unit: RuleUnit, filterOption?: DatasetUnitCheckFilterOption): Promise<boolean>;
        private filterCategoryAsync;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/rule/PdmsRuleHandleChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    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 { PdmsRuleChecker } from "sk/service/logic/furniture/pdms/checker/unit/rule/PdmsRuleChecker";
    export class PdmsRuleHandleChecker extends PdmsRuleChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: RuleUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/rule/PdmsRuleHingeHardwareChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    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 { PdmsRuleChecker } from "sk/service/logic/furniture/pdms/checker/unit/rule/PdmsRuleChecker";
    export class PdmsRuleHingeHardwareChecker extends PdmsRuleChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: RuleUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/checker/unit/rule/PdmsRuleStructureHardwareChecker" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataContext } from 'foundation/service/common/database/DataContext';
    import { DatasetUnitCheckFilterOption } from 'sk/service/data/logic/warehouse/check/constants/DataCheckerConstants';
    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 { PdmsRuleChecker } from "sk/service/logic/furniture/pdms/checker/unit/rule/PdmsRuleChecker";
    export class PdmsRuleStructureHardwareChecker extends PdmsRuleChecker implements IDatasetUnitChecker {
        processAsync(context: DataContext, unit: RuleUnit, content?: any, filterOption?: DatasetUnitCheckFilterOption): Promise<ResultObject<DatasetUnitCheckResultInfo>>;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateFamilyBase" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataQuery } from 'foundation/service/common/database/util/DataQuery';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyController } from 'sk/service/data/logic/module/controller/FamilyController';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { FamilyTypeController } from 'sk/service/data/logic/module/controller/FamilyTypeController';
    import { ModuleStorageService } from 'sk/service/data/logic/module/storage/ModuleStorageService';
    import { LibraryContentUpdateBase, LibraryUpdateProcessResult } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateBase";
    export class FamilyDocumentProcessResult {
        changed: boolean;
    }
    export class LibraryContentUpdateFamilyBase extends LibraryContentUpdateBase {
        protected _familyController: FamilyController;
        protected _familyTypeController: FamilyTypeController;
        protected _familyDocumentService: FamilyDocumentService;
        protected _moduleStorageService: ModuleStorageService;
        getFamilyQueryAsync(context: RouterContext): Promise<DataQuery>;
        processFamilyDocumentAsync(context: RouterContext, dto: FamilyDto, document: FamilyDocument, typeCode: string): Promise<ResultObject<FamilyDocumentProcessResult>>;
        processAsync(context: RouterContext): Promise<ResultObject<LibraryUpdateProcessResult>>;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/LibraryUpdateDeclare" {
    export function LibraryUpdateDeclare(name: string): (target: any) => void;
}
declare module "sk/service/logic/furniture/pdms/library/update/processor/LibraryContentUpdateDatapath" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    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';
    import { LibraryContentUpdateBase, LibraryUpdateProcessResult } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateBase";
    export class LibraryContentUpdateDatabaseBase extends LibraryContentUpdateBase {
        protected _productCategoryController: ProductCategoryController;
        protected _productController: ProductController;
        protected _logicHistoryService: LogicHistoryService;
        processAsync(context: RouterContext): Promise<ResultObject<LibraryUpdateProcessResult>>;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/processor/LibraryContentUpdateDecorateValues" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataQuery } from 'foundation/service/common/database/util/DataQuery';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { LibraryContentUpdateFamilyBase, FamilyDocumentProcessResult } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateFamilyBase";
    export class LibraryContentUpdateDecorateValues extends LibraryContentUpdateFamilyBase {
        getFamilyQueryAsync(context: RouterContext): Promise<DataQuery>;
        processFamilyDocumentAsync(context: RouterContext, dto: FamilyDto, document: FamilyDocument, typeCode: string): Promise<ResultObject<FamilyDocumentProcessResult>>;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/processor/LibraryContentUpdatePlaceCd" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataQuery } from 'foundation/service/common/database/util/DataQuery';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { LibraryContentUpdateFamilyBase, FamilyDocumentProcessResult } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateFamilyBase";
    export class LibraryContentUpdatePlaceCd extends LibraryContentUpdateFamilyBase {
        getFamilyQueryAsync(context: RouterContext): Promise<DataQuery>;
        processFamilyDocumentAsync(context: RouterContext, dto: FamilyDto, document: FamilyDocument, typeCode: string): Promise<ResultObject<FamilyDocumentProcessResult>>;
        private getPlankTypePlaceCd;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/processor/LibraryContentUpdateVariableAtrribute" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { EventController } from 'sk/service/data/logic/control/controller/EventController';
    import { VariableAttributeService } from 'sk/service/data/logic/module/service/VariableAttributeService';
    import { LibraryContentUpdateBase, LibraryUpdateProcessResult } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateBase";
    export class LibraryContentUpdateVariableAtrribute extends LibraryContentUpdateBase {
        protected _variableAttrService: VariableAttributeService;
        protected _eventController: EventController;
        processAsync(context: RouterContext): Promise<ResultObject<LibraryUpdateProcessResult>>;
    }
}
declare module "sk/service/logic/furniture/pdms/library/update/processor/LibraryContentUpdateVariableCode" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataQuery } from 'foundation/service/common/database/util/DataQuery';
    import { RouterContext } from 'foundation/service/common/router/RouterContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDto } from 'sk/service/data/logic/module/controller/FamilyDto';
    import { LibraryContentUpdateFamilyBase, FamilyDocumentProcessResult } from "sk/service/logic/furniture/pdms/library/update/LibraryContentUpdateFamilyBase";
    export class LibraryContentUpdateVariableCode extends LibraryContentUpdateFamilyBase {
        getFamilyQueryAsync(context: RouterContext): Promise<DataQuery>;
        processFamilyDocumentAsync(context: RouterContext, dto: FamilyDto, document: FamilyDocument, typeCode: string): Promise<ResultObject<FamilyDocumentProcessResult>>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckattributesgroup/DataCheckAttributesGroup" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckAttributesGroup {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckcategoryattributes/DataCheckCategoryAttributes" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckCategoryAttributes {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckfamilytyperule/DataCheckFamilyTypeRule" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckFamilyTypeRule {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacheck/datacheckvaluationrule/DataCheckValuationRule" {
    import { MessageRouterContext } from 'foundation/service/common/router/message/MessageRouterContext';
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCheckValuationRule {
        static startDataCheckAsync(context: MessageRouterContext): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationattributes/DataCreationAttributes" {
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationAttributes {
        static startDataCreationAsync(): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationattributesgroup/DataCreationAttributesGroup" {
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationAttributesGroup {
        static startDataCreationAsync(): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationcategoryattributes/DataCreationCategoryAttributes" {
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationCategoryAttributes {
        static startDataCreationAsync(): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationstructure/DataCreationStructure" {
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationStructure {
        static startDataCreationAsync(): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationtyperule/DataCreationFamilyTypeRule" {
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationFamilyTypeRule {
        static startDataCreationAsync(): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/libraryinit/datacreation/datacreationvaluationrule/DataCreationValuationRule" {
    import { ExecuteLog } from "sk/service/logic/furniture/pdms/libraryinit/components/utils/ExecuteLog";
    export class DataCreationValuationRule {
        static startDataCreationAsync(): Promise<ExecuteLog>;
    }
}
declare module "sk/service/logic/furniture/pdms/router/PdmsConfigCategoryInitRouter" {
    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 { CategoryInitDeleteRequest } from 'sk/data/furniture/pdms/message/CategoryInitDeleteRequest';
    import { CategoryInitDeleteResponse } from 'sk/data/furniture/pdms/message/CategoryInitDeleteResponse';
    import { CategoryInitUploadRequest } from 'sk/data/furniture/pdms/message/CategoryInitUploadRequest';
    import { CategoryInitUploadResponse } from 'sk/data/furniture/pdms/message/CategoryInitUploadResponse';
    export class PdmsConfigCategoryInitRouter extends MessageRouter {
        processCode: string;
        protected _environmentService: EnvironmentService;
        protected _ossService: OssConnectionService;
        ossPath: string;
        onCategoryInitUploadRequestAsync(context: MessageRouterContext, request: CategoryInitUploadRequest, response: CategoryInitUploadResponse): Promise<MessageResultType>;
        onCategoryInitDeleteRequestAsync(context: MessageRouterContext, request: CategoryInitDeleteRequest, response: CategoryInitDeleteResponse): Promise<MessageResultType>;
        getRouter(): any;
    }
}