/// <reference path="../library/typings/native.d.ts" />
/// <reference path="../library/typings/cross-runtime.d.ts" />
/// <reference path="../typings/private/foundation-runtime-math.d.ts" />
/// <reference path="../typings/private/foundation-runtime-geometry.d.ts" />
/// <reference path="../typings/private/foundation-runtime-graphics.d.ts" />
/// <reference path="../typings/private/foundation-core-module.d.ts" />
/// <reference path="../typings/private/foundation-data-common.d.ts" />
/// <reference path="../typings/private/sk-data-family.d.ts" />
/// <reference path="../typings/private/sk-data-resource.d.ts" />
declare module "copyright" {
    export class DataSchemeCopyright {
        static toString(): string;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigAttributeInfo" {
    export interface ISchemeConfigAttributeInfo {
        id: string;
        code: string;
        name: string;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigBusinessType" {
    export interface ISchemeConfigBusinessType {
        id: string;
        code: string;
        name: string;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigDecorateInfo" {
    import { DecorateBindTypeEnum } from 'sk/data/family/enumeration/DecorateBindTypeEnum';
    import { DecorateItemStateTypeEnum } from 'sk/data/family/enumeration/DecorateItemStateTypeEnum';
    export interface ISchemeConfigDecorateInfo {
        id: string;
        code: string;
        name: string;
        configId: string;
        configCode: string;
        configName: string;
        decorateItemId: string;
        linkId: string;
        linkCd: DecorateBindTypeEnum;
        linkCode: string;
        linkName: string;
        linkVersion: string;
        familyInfoId: string;
        previewUrl: string;
        optionDefault: DecorateItemStateTypeEnum;
        features: any;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigDigitizationMerchandiseIteInfo" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ISpecificationFamilyCategory } from 'sk/data/specification/base/ISpecificationFamilyCategory';
    import { ISpecificationFamilyType } from 'sk/data/specification/base/ISpecificationFamilyType';
    export interface ISchemeConfigDigitizationMerchandiseIteInfo {
        productId: string;
        productLinkCd: number;
        code: string;
        name: string;
        linkId: string;
        infoId: string;
        categories: Types<ISpecificationFamilyCategory>;
        types: Types<ISpecificationFamilyType>;
        features: any;
        optionDefault: boolean;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigMaterialRuleInfo" {
    import { MaterialRuleFunctionTypeEnum } from 'sk/data/family/enumeration/MaterialRuleFunctionTypeEnum';
    export interface ISchemeConfigMaterialRuleInfo {
        ruleId: string;
        meteringTypeCode: string;
        meteringTypeName: string;
        functionCd: MaterialRuleFunctionTypeEnum;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigMaterialVariableInfo" {
    export interface ISchemeConfigMaterialVariableInfo {
        id: string;
        code: string;
        name: string;
        dataIcon: string;
        dataValue: any;
        unitType: number;
        features: any;
        remark: string;
        tags: string;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigRuleInfo" {
    export interface ISchemeConfigRuleInfo {
        id: string;
        tenantId: string;
        libraryId: string;
        typeId: string;
        processId: string;
        code: string;
        name: string;
        version: number;
        statusCd: string;
        functionType: string;
        dataOrder: number;
    }
}
declare module "sk/data/scheme/config/ISchemeConfigSystemCodeInfo" {
    export interface ISchemeConfigSystemCodeInfo {
        id: string;
        code: string;
        name: string;
        dataValue: string;
    }
}
declare module "sk/data/scheme/config/SchemeConfigAtrributeInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ISchemeConfigAttributeInfo } from "sk/data/scheme/config/ISchemeConfigAttributeInfo";
    export class SchemeConfigAttributeInfo extends InstanceObject implements ISchemeConfigAttributeInfo {
        category_id: string;
        code: string;
        configure: any;
        data_default: any;
        data_statictics_cd: number;
        data_type_cd: number;
        data_use_cd: number;
        feature_group_id: string;
        id: string;
        name: string;
        parameters: string;
        parent_id: string;
        remark: string;
        type_id: string;
        loadJson(data: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigAttributeDocument" {
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { SchemeConfigAttributeInfo } from "sk/data/scheme/config/SchemeConfigAtrributeInfo";
    export class SchemeConfigAttributeDocument extends DataDocument {
        info: SchemeConfigAttributeInfo;
        constructor();
        loadJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigAttributeService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { SchemeConfigAttributeDocument } from "sk/data/scheme/config/SchemeConfigAttributeDocument";
    export class SchemeConfigAttributeService extends DataDocumentService<SchemeConfigAttributeDocument> {
        constructor();
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeConfigAttributeDocument;
        loadConfigAsync(context: ContextObject, id: string): Promise<ResultObject<SchemeConfigAttributeDocument>>;
    }
}
declare module "sk/data/scheme/config/SchemeConfigBusinessType" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ISchemeConfigBusinessType } from "sk/data/scheme/config/ISchemeConfigBusinessType";
    export class SchemeConfigBusinessType extends InstanceObject implements ISchemeConfigBusinessType {
        id: string;
        code: string;
        name: string;
        loadData(data: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigDataInvoker" {
    import { DataCacheInvoker } from 'foundation/data/common/service/DataCacheInvoker';
    export class SchemeConfigDataInvoker extends DataCacheInvoker {
    }
}
declare module "sk/data/scheme/config/SchemeConfigDecorateInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DecorateBindTypeEnum } from 'sk/data/family/enumeration/DecorateBindTypeEnum';
    import { DecorateItemStateTypeEnum } from 'sk/data/family/enumeration/DecorateItemStateTypeEnum';
    import { ISchemeConfigDecorateInfo } from "sk/data/scheme/config/ISchemeConfigDecorateInfo";
    export class SchemeConfigDecorateInfo extends InstanceObject implements ISchemeConfigDecorateInfo {
        id: string;
        code: string;
        name: string;
        configId: string;
        configCode: string;
        configName: string;
        decorateItemId: string;
        linkId: string;
        linkCd: DecorateBindTypeEnum;
        linkCode: string;
        linkName: string;
        linkVersion: string;
        familyInfoId: string;
        previewUrl: string;
        optionDefault: DecorateItemStateTypeEnum;
        features: any;
        loadData(data: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigDigitizationMerchandiseIteInfo" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { SpecificationFamilyCategory } from 'sk/data/specification/familycategory/structure/SpecificationFamilyCategory';
    import { SpecificationFamilyType } from 'sk/data/specification/familytype/structure/SpecificationFamilyType';
    import { ISchemeConfigDigitizationMerchandiseIteInfo } from "sk/data/scheme/config/ISchemeConfigDigitizationMerchandiseIteInfo";
    export class SchemeConfigDigitizationMerchandiseIteInfo extends InstanceObject implements ISchemeConfigDigitizationMerchandiseIteInfo {
        productId: string;
        productLinkCd: number;
        code: string;
        name: string;
        optionDefault: boolean;
        linkId: string;
        infoId: string;
        types: Types<SpecificationFamilyType>;
        categories: Types<SpecificationFamilyCategory>;
        features: any;
        constructor();
        loadConfig(jconfig: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigFamilyDocument" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    export class SchemeConfigFamilyDocument extends FamilyDataDocument {
        static CLASS_NAME: string;
        protected static _factory: PersistentFactory;
        static get Factory(): PersistentFactory;
        protected constructor();
        get factory(): PersistentFactory;
        static createEmptyDocument(json?: any): SchemeConfigFamilyDocument;
        static createDefaultDocument(): SchemeConfigFamilyDocument;
    }
}
declare module "sk/data/scheme/config/SchemeConfigFamilyDocumentService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { SchemeConfigFamilyDocument } from "sk/data/scheme/config/SchemeConfigFamilyDocument";
    export class SchemeConfigFamilyDocumentService extends DataDocumentService<SchemeConfigFamilyDocument> {
        constructor();
        makeCode(parameters: DataDocumentParameters): string;
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeConfigFamilyDocument;
        loadFamilyDocumentAsync(context: IContext, familyId: string, force?: boolean): Promise<DataDocumentResult<SchemeConfigFamilyDocument>>;
        loadFamilyDocumentByIdAsync(context: IContext, id: string, force?: boolean): Promise<DataDocumentResult<SchemeConfigFamilyDocument>>;
        loadFamilyByIdAsync(context: IContext, id: string, force?: boolean): Promise<ResultObject<any>>;
    }
}
declare module "sk/data/scheme/config/SchemeConfigFamilyInfoDocument" {
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    export class SchemeConfigFamilyInfoDocument extends DataDocument {
        info: ISpecificationFamilyInfo;
        constructor();
        loadJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigLibraryUtil" {
    export class SchemeConfigLibraryUtil {
        static makeRuleInfoUrl(): string;
        static makeRuleTypeInfoUrl(): string;
        static makeConfigUrl(): string;
        static makeBusinessTypeUrl(): string;
    }
}
declare module "sk/data/scheme/config/SchemeConfigMaterialInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class SchemeConfigMaterialInfo extends InstanceObject {
        familyId: string;
        familySymbolId: string;
        parentRemark: string;
        id: string;
        tenantId: string;
        libraryId: string;
        categoryId: string;
        typeId: string;
        code: string;
        name: string;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        unit: string;
        expandFields: any;
        features: string;
        remark: string;
        items: Array<SchemeConfigMaterialInfo>;
        constructor();
        loadConfig(jconfig: any): void;
        private loadChildConfig;
        private loadData;
    }
}
declare module "sk/data/scheme/config/SchemeConfigMaterialRuleInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { MaterialRuleFunctionTypeEnum } from 'sk/data/family/enumeration/MaterialRuleFunctionTypeEnum';
    import { ISchemeConfigMaterialRuleInfo } from "sk/data/scheme/config/ISchemeConfigMaterialRuleInfo";
    export class SchemeConfigMaterialRuleInfo extends InstanceObject implements ISchemeConfigMaterialRuleInfo {
        ruleId: string;
        meteringTypeCode: string;
        meteringTypeName: string;
        functionCd: MaterialRuleFunctionTypeEnum;
        loadConfig(jconfig?: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigMaterialVariableInfo" {
    import { ISchemeConfigMaterialVariableInfo } from "sk/data/scheme/config/ISchemeConfigMaterialVariableInfo";
    export class SchemeConfigMaterialVariableInfo implements ISchemeConfigMaterialVariableInfo {
        id: string;
        code: string;
        name: string;
        dataIcon: string;
        dataValue: any;
        unitType: number;
        features: any;
        remark: string;
        tags: string;
        loadData(data: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigOpearteEnum" {
    export class SchemeConfigOpearteEnum {
        static Create: string;
    }
}
declare module "sk/data/scheme/config/SchemeConfigOpearteInfo" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { Element } from 'sk/data/family/element/base/Element';
    export class SchemeConfigOpearteInfo {
        typeCd: string;
        parentElement: Element;
        optionOrigin: boolean;
        info: ISpecificationFamilyInfo;
        position: Vector3;
        parameters: any;
    }
}
declare module "sk/data/scheme/service/SchemeComputeEnum" {
    export class SchemeComputeEnum {
        static DeclareBuild: string;
        static Family: string;
        static Structure: string;
        static Design: string;
        static Technology: string;
        static ModeBuild: string;
        static ModeCompute: string;
        static PatternSimple: string;
        static PatternBuild: string;
        static PatternCompletion: string;
        static PatternAll: string;
    }
}
declare module "sk/data/scheme/config/SchemeConfigOperator" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Element } from 'sk/data/family/element/base/Element';
    import { SchemeConfigOpearteInfo } from "sk/data/scheme/config/SchemeConfigOpearteInfo";
    export abstract class SchemeConfigOperator extends InstanceObject {
        abstract createElement(opearte: SchemeConfigOpearteInfo): Element;
    }
}
declare module "sk/data/scheme/config/SchemeConfigOperateService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Service } from 'cross/runtime/module/Service';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { Element } from 'sk/data/family/element/base/Element';
    import { SchemeConfigOpearteEnum } from "sk/data/scheme/config/SchemeConfigOpearteEnum";
    import { SchemeConfigOpearteInfo } from "sk/data/scheme/config/SchemeConfigOpearteInfo";
    import { SchemeConfigOperator } from "sk/data/scheme/config/SchemeConfigOperator";
    export type SchemeConfigOperateDeclareInfo = {
        opearteCd: SchemeConfigOpearteEnum;
        level: number;
        type: any;
        instance: SchemeConfigOperator;
    };
    export class SchemeConfigOperateService extends Service {
        protected _operateInfos: Types<SchemeConfigOperateDeclareInfo>;
        protected _calculatorService: CalculatorService;
        protected findOperator(declare: SchemeConfigOperateDeclareInfo): SchemeConfigOperator;
        register(declare: SchemeConfigOperateDeclareInfo): void;
        createElementByInfo(context: IContext, opearte: SchemeConfigOpearteInfo): Element;
    }
}
declare module "sk/data/scheme/config/SchemeConfigPatternDocument" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { PatternDataDocument } from 'sk/data/family/pattern/PatternDataDocument';
    export class SchemeConfigPatternDocument extends PatternDataDocument {
        static CLASS_NAME: string;
        protected static _factory: PersistentFactory;
        static get Factory(): PersistentFactory;
        protected constructor();
        get factory(): PersistentFactory;
        static createEmptyDocument(json?: any): SchemeConfigPatternDocument;
        static createDefaultDocument(): SchemeConfigPatternDocument;
    }
}
declare module "sk/data/scheme/config/SchemeConfigPatternDocumentService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { ISpecificationPattern } from 'sk/data/specification/base/ISpecificationPattern';
    import { SchemeConfigPatternDocument } from "sk/data/scheme/config/SchemeConfigPatternDocument";
    export class SchemeConfigPatternDocumentService extends DataDocumentService<SchemeConfigPatternDocument> {
        constructor();
        makeCode(parameters: DataDocumentParameters): string;
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeConfigPatternDocument;
        loadPatternDocumentAsync(context: IContext, patternId: string, force?: boolean): Promise<DataDocumentResult<SchemeConfigPatternDocument>>;
        loadPatternDocumentByIdAsync(context: IContext, id: string, force?: boolean): Promise<DataDocumentResult<SchemeConfigPatternDocument>>;
        loadPatternByIdAsync(context: IContext, id: string, force?: boolean): Promise<ResultObject<ISpecificationPattern>>;
    }
}
declare module "sk/data/scheme/config/SchemeConfigRuleInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ISchemeConfigRuleInfo } from "sk/data/scheme/config/ISchemeConfigRuleInfo";
    export class SchemeConfigRuleInfo extends InstanceObject implements ISchemeConfigRuleInfo {
        id: string;
        tenantId: string;
        libraryId: string;
        typeId: string;
        processId: string;
        code: string;
        name: string;
        version: number;
        statusCd: string;
        functionType: string;
        dataOrder: number;
        loadJson(jconfig?: any): void;
        loadConfig(jconfig?: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigSystemCodeInfo" {
    import { ISchemeConfigSystemCodeInfo } from "sk/data/scheme/config/ISchemeConfigSystemCodeInfo";
    export class SchemeConfigSystemCodeInfo implements ISchemeConfigSystemCodeInfo {
        id: string;
        code: string;
        name: string;
        dataValue: string;
        loadData(data: any): void;
    }
}
declare module "sk/data/scheme/config/SchemeConfigService" {
    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 { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { MessageService } from 'cross/data/module/message/MessageService';
    import { LogicInterfaceService } from 'foundation/data/common/net/LogicInterfaceService';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { DataService } from 'foundation/data/common/service/DataService';
    import { ConfigReferenceStructure } from 'foundation/data/common/structure/ConfigReferenceStructure';
    import { SpecificationStorageLoadOptions } from 'sk/data/specification/common/storage/SpecificationStorageService';
    import { SpecificationFamilyInfo } from 'sk/data/specification/familyinfo/structure/SpecificationFamilyInfo';
    import { ISpecificationFamily } from 'sk/data/specification/base/ISpecificationFamily';
    import { ISpecificationFamilyCategory } from 'sk/data/specification/base/ISpecificationFamilyCategory';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ISpecificationFamilyType } from 'sk/data/specification/base/ISpecificationFamilyType';
    import { ISpecificationPattern } from 'sk/data/specification/base/ISpecificationPattern';
    import { ISpecificationPatternInfo } from 'sk/data/specification/base/ISpecificationPatternInfo';
    import { ISpecificationProduct } from 'sk/data/specification/base/ISpecificationProduct';
    import { SpecificationFamilyService } from 'sk/data/specification/family/SpecificationFamilyService';
    import { SpecificationFamilyInfoService } from 'sk/data/specification/familyinfo/SpecificationFamilyInfoService';
    import { SpecificationPatternService } from 'sk/data/specification/pattern/SpecificationPatternService';
    import { SpecificationPatternInfoService } from 'sk/data/specification/patterninfo/SpecificationPatternInfoService';
    import { SpecificationWarehouse } from 'sk/data/specification/warehouse/SpecificationWarehouse';
    import { SpecificationWarehouseService } from 'sk/data/specification/warehouse/SpecificationWarehouseService';
    import { ConfigureElement } from 'sk/data/family/element/config/configure/ConfigureElement';
    import { DecorateElement } from 'sk/data/family/element/config/decorate/DecorateElement';
    import { ParameterElement } from 'sk/data/family/element/config/parameter/ParameterElement';
    import { VariableElement } from 'sk/data/family/element/config/variable/VariableElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { FamilyRuleFunctionTypeEnum } from 'sk/data/family/enumeration/FamilyRuleFunctionTypeEnum';
    import { MaterialRuleFunctionTypeEnum } from 'sk/data/family/enumeration/MaterialRuleFunctionTypeEnum';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { ISchemeConfigDigitizationMerchandiseIteInfo } from "sk/data/scheme/config/ISchemeConfigDigitizationMerchandiseIteInfo";
    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 { SchemeConfigDataInvoker } from "sk/data/scheme/config/SchemeConfigDataInvoker";
    import { SchemeConfigDecorateInfo } from "sk/data/scheme/config/SchemeConfigDecorateInfo";
    import { SchemeConfigFamilyDocumentService } from "sk/data/scheme/config/SchemeConfigFamilyDocumentService";
    import { SchemeConfigMaterialInfo } from "sk/data/scheme/config/SchemeConfigMaterialInfo";
    import { SchemeConfigMaterialRuleInfo } from "sk/data/scheme/config/SchemeConfigMaterialRuleInfo";
    import { SchemeConfigOperateService } from "sk/data/scheme/config/SchemeConfigOperateService";
    import { SchemeConfigPatternDocumentService } from "sk/data/scheme/config/SchemeConfigPatternDocumentService";
    import { SchemeConfigRuleInfo } from "sk/data/scheme/config/SchemeConfigRuleInfo";
    export class SyncResult<T> {
        content: T;
        constructor(content: T);
    }
    export class SchemeConfigService extends DataService {
        workCd: string;
        senceSkj: boolean;
        protected _jsonService: JsonService;
        protected _interfaceService: LogicInterfaceService;
        protected _specificationFamilyInfoService: SpecificationFamilyInfoService;
        protected _specificationFamilyService: SpecificationFamilyService;
        protected _documentService: SchemeConfigFamilyDocumentService;
        protected _specificationPatternInfoService: SpecificationPatternInfoService;
        protected _specificationPatternService: SpecificationPatternService;
        protected _environmentService: EnvironmentService;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        protected _messageService: MessageService;
        protected _schemeConfigFamilyDocumentService: SchemeConfigFamilyDocumentService;
        protected _schemeConfigPatternDocumentService: SchemeConfigPatternDocumentService;
        protected _ruleTypesStorageMap: Types<SchemeConfigRuleInfo>;
        protected _familyConfigService: FamilyConfigService;
        protected _warehouseService: SpecificationWarehouseService;
        constructor();
        initializeConfig(jconfig: any): void;
        protected createInvoker(name: string): SchemeConfigDataInvoker;
        getWarehouse(context: IContext): SpecificationWarehouse;
        loadWarehouseLibraryAsync(context: IContext, libraryId: string, libraryVersion: any): Promise<ResultObject>;
        loadWarehouseFamilyAsync(context: IContext, document: FamilyDocument): Promise<ResultObject>;
        findParameterById(context: IContext, id: string): ParameterElement;
        findParameterByCode(context: IContext, code: string): ParameterElement;
        findParameterValueByCode(context: IContext, code: string): any;
        findVariableById(context: IContext, id: string): VariableElement;
        findVariableByCode(context: IContext, code: string, familyId?: string, familyVersion?: any, libraryId?: string, libraryVersion?: any): VariableElement;
        findDecorateById(context: IContext, id: string, familyId?: string, familyVersion?: AssetVersionType, libarayId?: string, libarayVersion?: AssetVersionType): DecorateElement;
        findConfigureById(context: IContext, id: string, familyId?: string, familyVersion?: AssetVersionType, libarayId?: string, libarayVersion?: AssetVersionType): ConfigureElement;
        getSpecificationFamilyAsync(context: IContext, familyId: string, options?: SpecificationStorageLoadOptions): Promise<ResultObject<ISpecificationFamily>>;
        getSpecificationFamilyTypesAsync(context: IContext, familyId: string, options?: SpecificationStorageLoadOptions): Promise<ISpecificationFamilyType[]>;
        getSpecificationFamilyCategoriesAsync(context: IContext, familyId: string, options?: SpecificationStorageLoadOptions): Promise<ISpecificationFamilyCategory[]>;
        findFamilyInfoById(context: IContext, familyInfoId: string): ResultObject<ISpecificationFamilyInfo>;
        getSpecificationFamilyInfoAsync(context: IContext, familyInfoId: string, options?: SpecificationStorageLoadOptions): Promise<ResultObject<ISpecificationFamilyInfo>>;
        getSpecificationFamilyInfoByFamilyIdAsync(context: IContext, familyId: string): Promise<ResultObject<ISpecificationFamilyInfo>>;
        getFamilyInfoIdBySymbolIdAsync(context: IContext, familyId: string, familySymbolId: string): Promise<ResultObject<string>>;
        getFamilyInfoListByFamilyIdAsync(context: IContext, familyId: string): Promise<ResultObject<ISpecificationFamily>>;
        getSpecificationPatternAsync(context: IContext, patternId: string, options?: SpecificationStorageLoadOptions): Promise<ResultObject<ISpecificationPattern>>;
        getSpecificationPatternInfoAsync(context: IContext, patternInfoId: string, options?: SpecificationStorageLoadOptions): Promise<ResultObject<ISpecificationPatternInfo>>;
        getSpecificationPatternInfoByCodeAsync(context: IContext, code: string, options?: SpecificationStorageLoadOptions): Promise<ResultObject<ISpecificationPatternInfo>>;
        getPatternInfoByPatternIdAsync(context: IContext, patternId: string): Promise<ResultObject<ISpecificationPatternInfo>>;
        getPatternInfoListByPatternIdAsync(context: IContext, patternId: string): Promise<ResultObject<ISpecificationPattern>>;
        getProductByIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getProductByIdGet(context: IContext, parameters: any, content: any): any;
        getProductByIdAsync(context: IContext, id: string): Promise<ResultObject<ISpecificationProduct>>;
        getDigitalProductByIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getDigitalProductByIdGet(context: IContext, parameters: any, content: any): any;
        getDigitalProductByIdAsync(context: IContext, id: string): Promise<ResultObject<ISpecificationProduct>>;
        getDecorateItemsByConfigIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<SchemeConfigDecorateInfo>>;
        getDecorateItemsByConfigIdGet(context: IContext, parameters: any, content: any): Array<SchemeConfigDecorateInfo>;
        getDecorateItemsByConfigIdAsync(context: IContext, configId: string): Promise<ResultObject<Array<SchemeConfigDecorateInfo>>>;
        getDefaultDecorateAsync(configId: any): Promise<ConfigReferenceStructure>;
        getDefaultDecorateItemAndLinkerLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<SchemeConfigDecorateInfo>>;
        getDefaultDecorateItemAndLinkerGet(context: IContext, parameters: any, content: any): SchemeConfigDecorateInfo;
        getDefaultDecorateItemAndLinkerAsync(context: IContext, id: string): Promise<ResultObject<SchemeConfigDecorateInfo>>;
        protected loadFactoryParamLoadByLibarayIdAsync(context: IContext, service: SchemeConfigService, paramters: any): Promise<ResultObject>;
        protected loadFactoryParamByLibarayIdGet(context: IContext, parameters: any, content: any): any;
        loadFactoryParamByLibarayIdAsync(context: IContext, libraryId: string): Promise<ResultObject<any>>;
        protected loadSystemLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        loadSystemAsync(context: IContext): Promise<ResultObject<any>>;
        protected getRuleTypesListLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        protected getRuleTypesListGet(context: IContext, parameters: any, content: any): any;
        getRuleTypesListAsync(context: IContext): Promise<ResultObject<Types<SchemeConfigRuleInfo>>>;
        getRuleTypesMapAsync(context: IContext): Promise<Dictionary<SchemeConfigRuleInfo>>;
        protected getRuleListLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        protected getRuleListGet(context: IContext, parameters: any, content: any): Types<SchemeConfigRuleInfo>;
        getRuleListAsync(context: IContext): Promise<ResultObject<Types<SchemeConfigRuleInfo>>>;
        getRuleMapAsync(context: IContext): Promise<Dictionary<SchemeConfigRuleInfo>>;
        getRuleInfoByFamilyId(context: IContext, businessTypeId: string, familyId: string, functionCd: FamilyRuleFunctionTypeEnum): SyncResult<SchemeConfigRuleInfo>;
        protected getRuleInfoByFamilyTypeIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        protected getRuleInfoByFamilyTypeIdGet(context: IContext, parameters: any, content: any): any;
        getRuleInfoByFamilyTypeIdAsync(context: IContext, businessTypeId: string, familyTypeId: string, functionCd: FamilyRuleFunctionTypeEnum): Promise<ResultObject<SchemeConfigRuleInfo>>;
        getRuleProcessIdByRuleIdAsync(context: IContext, ruleId: string): Promise<string>;
        getRuleProcessIdByRuleTypeIdAsync(context: IContext, ruleTypeId: string): Promise<string>;
        createElementByInfo(context: IContext, parent: BrepElement, info: ISpecificationFamilyInfo, typeCd?: any): Element;
        createElementByInfoIdAsync(context: IContext, parentElement: Element, familyInfoId: string, parameters?: any): Promise<ResultObject<Element>>;
        loadFamilyAsync(context: IContext, familyId: string, libraryId: string, libraryVersion: number): Promise<ResultObject>;
        getSchemeConfigPatternByIdAsync(context: IContext, id: string): Promise<ResultObject<ISpecificationPattern>>;
        getRuleInfoByFamilyIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getRuleInfoByFamilyIdGet(context: IContext, parameters: any, content: any): SchemeConfigRuleInfo;
        getRuleInfoByFamilyIdAsync(context: IContext, businessTypeId: string, familyId: string, functionCd: FamilyRuleFunctionTypeEnum): Promise<ResultObject<SchemeConfigRuleInfo>>;
        getRuleInfoByFamilyTypeId(context: IContext, businessTypeId: string, familyTypeId: string, functionCd: FamilyRuleFunctionTypeEnum): SyncResult<SchemeConfigRuleInfo>;
        getRuleInfoByPatternTypeIdGet(context: IContext, parameters: any, content: any): any;
        getRuleInfoByPatternTypeIdAsync(context: IContext, businessTypeId: string, patternTypeId: string, functionCd: FamilyRuleFunctionTypeEnum): Promise<ResultObject<SchemeConfigRuleInfo>>;
        getRuleInfoByPatternTypeId(context: IContext, businessTypeId: string, patternTypeId: string, functionCd: FamilyRuleFunctionTypeEnum): SyncResult<SchemeConfigRuleInfo>;
        getRuleInfoByPatternTypeIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getRuleInfoByBomInfoLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getRuleInfoByBomInfoGet(context: IContext, parameters: any, content: any): any;
        getRuleInfoByBomInfoAsync(context: IContext, businessTypeId: string, materialTypeId: string): Promise<ResultObject<SchemeConfigMaterialRuleInfo>>;
        getRuleInfoByBomInfo(context: IContext, businessTypeId: string, materialTypeId: string): SyncResult<SchemeConfigMaterialRuleInfo>;
        getFamilyByBusinessTypeIdAndMaterialIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<ISpecificationFamilyInfo>>;
        getFamilyByBusinessTypeIdAndMaterialIdGet(context: IContext, parameters: any, content: any): SpecificationFamilyInfo;
        getFamilyByBusinessTypeIdAndMaterialIdAsync(context: IContext, businessTypeId: string, materialId: string): Promise<ResultObject<ISpecificationFamilyInfo>>;
        getFamilyByBusinessTypeIdAndMaterialId(context: IContext, businessTypeId: string, materialId: string): SyncResult<ISpecificationFamilyInfo>;
        getMaterialByBusinessTypeIdAndPatternIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<any>>;
        getMaterialByBusinessTypeIdAndLinkCdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<any>>;
        getMaterialByBusinessTypeIdAndPatternIdGet(context: IContext, parameters: any, content: any): SchemeConfigMaterialInfo;
        getMaterialByBusinessTypeIdAndLinkCdGet(context: IContext, parameters: any, content: any): Array<SchemeConfigMaterialInfo>;
        getMaterialByBusinessTypeIdAndPatternIdAsync(context: IContext, businessTypeId: string, patternId: string, patternSymbolId?: string): Promise<ResultObject<SchemeConfigMaterialInfo>>;
        getMaterialByBusinessTypeIdAndLinkCdAsync(context: IContext, businessTypeId: string, linkCd: Number): Promise<ResultObject<SchemeConfigMaterialInfo[]>>;
        getMaterialByBusinessTypeIdAndPatternId(context: IContext, businessTypeId: string, patternId: string, patternSymbolId?: string): SyncResult<SchemeConfigMaterialInfo>;
        getMaterialByBusinessTypeIdAndLinkCd(context: IContext, businessTypeId: string, linkCd: Number): SyncResult<SchemeConfigMaterialInfo[]>;
        getMaterialByBusinessTypeIdAndFamilyIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<any>>;
        getMaterialByBusinessTypeIdAndFamilyIdGet(context: IContext, parameters: any, content: any): SchemeConfigMaterialInfo;
        getMaterialByBusinessTypeIdAndFamilyIdAsync(context: IContext, businessTypeId: string, familyId: string, familySymbolId?: string): Promise<ResultObject<SchemeConfigMaterialInfo>>;
        getMaterialByBusinessTypeIdAndFamilyId(context: IContext, businessTypeId: string, familyId: string, familySymbolId?: string): SyncResult<SchemeConfigMaterialInfo>;
        protected getMaterialByCodeLoadAsync(context: IContext, service: SchemeConfigService, code: string): Promise<ResultObject<any>>;
        protected getMaterialByCodeGet(context: IContext, parameters: any, content: any): SchemeConfigMaterialInfo;
        getMaterialByCodeAsync(context: IContext, code: string): Promise<ResultObject<SchemeConfigMaterialInfo>>;
        searchMaterialByFeatureLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<any>>;
        searchMaterialByFeatureGet(context: IContext, parameters: any, content: any): SchemeConfigMaterialInfo;
        searchMaterialByFeatureAsync(context: IContext, size: any, params: any): Promise<ResultObject<SchemeConfigMaterialInfo>>;
        getRuleInfoByBusinessTypeIdAndMaterialIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getRuleInfoByBusinessTypeIdAndMaterialIdGet(context: IContext, parameters: any, content: any): any;
        getRuleInfoByBusinessTypeIdAndMaterialIdAsync(context: IContext, businessTypeId: string, materialId: string, functionCd: MaterialRuleFunctionTypeEnum): Promise<ResultObject<SchemeConfigMaterialRuleInfo>>;
        getRuleInfoByBusinessTypeIdAndMaterialId(context: IContext, businessTypeId: string, materialId: string, functionCd: MaterialRuleFunctionTypeEnum): SyncResult<SchemeConfigMaterialRuleInfo>;
        getMeteringRuleInfoByBusinessTypeIdAndMaterialIdLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getMeteringRuleInfosByBusinessTypeIdAndMaterialIdGet(context: IContext, parameters: any, content: any): any;
        getMeteringRuleInfoByBusinessTypeIdAndMaterialIdAsync(context: IContext, businessTypeId: string, materialId: string, functionCd: MaterialRuleFunctionTypeEnum): Promise<ResultObject<Array<SchemeConfigMaterialRuleInfo>>>;
        getMeteringRuleInfoByBusinessTypeIdAndMaterialId(context: IContext, businessTypeId: string, materialId: string, functionCd: MaterialRuleFunctionTypeEnum): SyncResult<Array<SchemeConfigMaterialRuleInfo>>;
        getBusinessTypeListLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        getBusinessTypeListGet(context: IContext, parameter: any, content: any): any;
        getBusinessTypesListAsync(context: IContext): Promise<ResultObject<Array<SchemeConfigBusinessType>>>;
        protected getDigitizationMerchandiseItemListLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject<Array<ISchemeConfigDigitizationMerchandiseIteInfo>>>;
        protected getDigitizationMerchandiseItemListGet(context: IContext, parameters: any, content: any): Array<ISchemeConfigDigitizationMerchandiseIteInfo>;
        getDigitizationMerchandiseItemListAsync(context: IContext, categoryCode?: string, categoryId?: string, productId?: string): Promise<ResultObject<Array<ISchemeConfigDigitizationMerchandiseIteInfo>>>;
        protected getBomVariableListLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        protected getBomVariableListGet(context: IContext, parameters: any, content: any): Array<ISchemeConfigMaterialVariableInfo>;
        getBomVariableListAsync(context: IContext, categoryId?: string): Promise<ResultObject<Array<ISchemeConfigMaterialVariableInfo>>>;
        protected getSystemCodeListLoadAsync(context: IContext, service: SchemeConfigService, parameters: any): Promise<ResultObject>;
        protected getSystemCodeListGet(context: IContext, parameters: any, content: any): Array<ISchemeConfigSystemCodeInfo>;
        getSystemCodeListAsync(context: IContext, code: string): Promise<ResultObject<Array<ISchemeConfigSystemCodeInfo>>>;
    }
}
declare module "sk/data/scheme/config/SchemeConfigOpearteUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class SchemeConfigOpearteUtil {
        static isLogicCode(info: ISpecificationFamilyInfo, typeCd: string): boolean;
        static isFamilyInstanceTypeAsync(context: ContextObject, node: FamilyInstanceNode, typecode: string): Promise<boolean>;
        static isFamilyType(info: ISpecificationFamilyInfo, typecode: string): boolean;
        static getFamilyInfoByNodeAsync(context: ContextObject, node: FamilyInstanceNode): Promise<ISpecificationFamilyInfo>;
    }
}
declare module "sk/data/scheme/config/SchemeConfigOperateDeclare" {
    import { SchemeConfigOpearteEnum } from "sk/data/scheme/config/SchemeConfigOpearteEnum";
    export function SchemeConfigOperateDeclare(opearteCd: SchemeConfigOpearteEnum, level?: number): (target: any) => void;
}
declare module "sk/data/scheme/config/SchemeLibraryFamilyDocumentService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { SchemeConfigFamilyDocument } from "sk/data/scheme/config/SchemeConfigFamilyDocument";
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    export class SchemeLibraryFamilyDocumentService extends DataDocumentService<SchemeConfigFamilyDocument> {
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        makeCode(parameters: DataDocumentParameters): string;
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeConfigFamilyDocument;
        loadFamilyDocumentAsync(context: IContext, libraryId: string, libraryVersion: number, familyId: string, force?: boolean): Promise<DataDocumentResult<SchemeConfigFamilyDocument>>;
        getFamilyDocumentByfamilyInfoIdAsync(context: ContextObject, familyInfoId: string): Promise<DataDocumentResult<FamilyDocument>>;
    }
}
declare module "sk/data/scheme/config/SchemeLibraryPatternDocumentService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { PatternDataDocument } from 'sk/data/family/pattern/PatternDataDocument';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    export class SchemeLibraryPatternDocumentService extends DataDocumentService<PatternDocument> {
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        makeCode(parameters: DataDocumentParameters): string;
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): PatternDocument;
        loadPatternDocumentAsync(context: ContextObject, libraryId: string, libraryVersion: number, familyId: string, force?: boolean): Promise<DataDocumentResult<PatternDocument>>;
        getPatternDocumentByPatternInfoIdAsync(context: ContextObject, patternInfoId: string): Promise<DataDocumentResult<PatternDataDocument>>;
    }
}
declare module "sk/data/scheme/database/pattern/node/DecorateLayerNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class DecorateLayerNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): DecorateLayerNode;
    }
    export type DecorateLayerNodeMap = {
        [key: string]: DecorateLayerNode;
    };
}
declare module "sk/data/scheme/core/PatternInfoUtil" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { FamilyTypeEnum } from 'sk/data/family/enumeration/FamilyTypeEnum';
    export class PatternInfoUtil {
        static findDecorateLayerNode(entity: BrepNode): PatternInstanceNode;
        static findCompositePatternNode(entity: BrepNode): PatternInstanceNode;
        static isType(info: ISpecificationFamilyInfo, typeCd: FamilyTypeEnum): boolean;
        static isTypes(info: ISpecificationFamilyInfo, ...typeCds: Array<FamilyTypeEnum>): boolean;
        static isTypeCode(info: ISpecificationFamilyInfo, ...typeCodes: string[]): boolean;
        static isLogicCode(info: ISpecificationFamilyInfo, typeCd: string): boolean;
    }
}
declare module "sk/data/scheme/core/SchemeStatisticsEnum" {
    export class SchemeStatisticsEnum {
        static Process: string;
        static SchemeLoad: string;
        static SchemeStructureSave: string;
        static SchemeBuildPattern: string;
        static SchemeBuildPatternCompletion: string;
        static SchemeTechniqueCalculate: string;
        static SchemeTechniqueVision: string;
        static SchemeTechniqueValidate: string;
        static SchemeTechniqueBom: string;
        static SchemeTechniqueIpdCheck: string;
        static SchemeTechniqueDrawing: string;
        static SchemeTechniqueStorage: string;
    }
}
declare module "sk/data/scheme/database/assemble/element/AssembleParameterEnum" {
    export class AssembleParameterEnum {
        static WallSurfaceHasElectricWire: string;
        static WallSurfaceHasWaterPipe: string;
        static WallSurfaceSpaceDistance: string;
    }
}
declare module "sk/data/scheme/database/assemble/element/BathroomFloorDryPlankElement" {
    import { ComplexHoleSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/ComplexHoleSurfaceStructure';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    export class BathroomFloorDryPlankElement extends PlaneElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        static FIELD_POLYGON: string;
        static FIELD_UNFOLD_POLYGON: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        polygon: SectionSurfaceStructure;
        unfoldPolygon: ComplexHoleSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomFloorDryPlankElementMap = {
        [key: string]: BathroomFloorDryPlankElement;
    };
}
declare module "sk/data/scheme/database/assemble/node/BathroomFloorDryPlankNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { ComplexHoleSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/ComplexHoleSurfaceStructure';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class BathroomFloorDryPlankNode extends PlaneNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_UNFOLD_POLYGON: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        unfoldPolygon: ComplexHoleSurfaceStructure;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomFloorDryPlankNode;
    }
    export type BathroomFloorDryPlankNodeMap = {
        [key: string]: BathroomFloorDryPlankNode;
    };
}
declare module "sk/data/scheme/database/bom/element/BomStructureElement" {
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    export class BomStructureElement extends StructureElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BomStructureElementMap = {
        [key: string]: BomStructureElement;
    };
}
declare module "sk/data/scheme/database/bom/BomFamilyStructure" {
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { BomStructureElement } from "sk/data/scheme/database/bom/element/BomStructureElement";
    export class BomFamilyStructure extends FamilyStructure {
        static CLASS_NAME: string;
        structure: BomStructureElement;
        constructor();
        setup(): void;
    }
}
declare module "sk/data/scheme/database/electrical/element/CableTrayElement" {
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    export class CableTrayElement extends ComponentElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CableTrayElementMap = {
        [key: string]: CableTrayElement;
    };
}
declare module "sk/data/scheme/database/electrical/element/ConduitElement" {
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    export class ConduitElement extends ComponentElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type ConduitElementMap = {
        [key: string]: ConduitElement;
    };
}
declare module "sk/data/scheme/database/electrical/element/WireElement" {
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    export class WireElement extends ComponentElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type WireElementMap = {
        [key: string]: WireElement;
    };
}
declare module "sk/data/scheme/database/technology/element/TechnologyCavityElement" {
    import { ElementStructure } from 'foundation/data/common/element/ElementStructure';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    export class TechnologyCavityElement extends TechnologyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_RADIUS: string;
        static FIELD_DEPTH: string;
        protected _radius: FormulaProperty;
        protected _depth: FormulaProperty;
        constructor();
        get radius(): FormulaProperty;
        get depth(): FormulaProperty;
        static create(familyStructure: ElementStructure): TechnologyCavityElement;
        reset(): void;
        dispose(): void;
    }
    export type TechnologyCavityElementMap = {
        [key: string]: TechnologyCavityElement;
    };
}
declare module "sk/data/scheme/database/technology/element/TechnologyGrooveElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ElementStructure } from 'foundation/data/common/element/ElementStructure';
    import { PathCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PathCurve2dElement';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { Vector3Element } from 'sk/data/family/element/brep/Vector3Element';
    import { ParameterElement } from 'sk/data/family/element/config/ParameterElement';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    export class TechnologyGrooveElement extends TechnologyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_PATH: string;
        static FIELD_PATH_PROFILE_ID: string;
        static FIELD_PATH_PROFILE_PARAMETERS: string;
        static FIELD_DIRECTION: string;
        static FIELD_DEPTH: string;
        static FIELD_WIDTH: string;
        path: PathCurve2dElement;
        pathProfileId: string;
        pathProfileParameters: Types<ParameterElement>;
        protected _direction: Vector3Element;
        protected _depth: FormulaProperty;
        protected _width: FormulaProperty;
        constructor();
        get direction(): Vector3Element;
        get depth(): FormulaProperty;
        get width(): FormulaProperty;
        static create(familyStructure: ElementStructure): TechnologyGrooveElement;
        reset(): void;
        dispose(): void;
    }
    export type TechnologyGrooveElementMap = {
        [key: string]: TechnologyGrooveElement;
    };
}
declare module "sk/data/scheme/database/technology/element/TechnologyHoleElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ElementStructure } from 'foundation/data/common/element/ElementStructure';
    import { SectionSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SectionSurfaceElement';
    import { AngleTypeEnum } from 'sk/data/family/database/furniture/enumeration/AngleTypeEnum';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { ParameterElement } from 'sk/data/family/element/config/ParameterElement';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    import { HoleTypeEnum } from 'sk/data/family/enumeration/technology/HoleTypeEnum';
    export class TechnologyHoleElement extends TechnologyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SECTION: string;
        static FIELD_SECTION_PROFILE_ID: string;
        static FIELD_SECTION_PROFILE_PARAMETERS: string;
        static FIELD_DEPTH: string;
        section: SectionSurfaceElement;
        sectionProfileId: string;
        sectionProfileParameters: Types<ParameterElement>;
        protected _depth: FormulaProperty;
        static FIELD_HOLE_TYPE: string;
        static FIELD_DIAMETER: string;
        static FIELD_ANGLE: string;
        holeType: HoleTypeEnum;
        diameter: number;
        angle: AngleTypeEnum;
        constructor();
        get depth(): FormulaProperty;
        static create(familyStructure: ElementStructure): TechnologyHoleElement;
        reset(): void;
        dispose(): void;
    }
    export type TechnologyHoleElementMap = {
        [key: string]: TechnologyHoleElement;
    };
}
declare module "sk/data/scheme/database/technology/element/TechnologyMillingElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ElementStructure } from 'foundation/data/common/element/ElementStructure';
    import { PathCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PathCurve2dElement';
    import { SectionSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SectionSurfaceElement';
    import { ParameterElement } from 'sk/data/family/element/config/ParameterElement';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    export class TechnologyMillingElement extends TechnologyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_PATH: string;
        static FIELD_PATH_PROFILE_ID: string;
        static FIELD_PATH_PROFILE_PARAMETERS: string;
        static FIELD_SECTION_BEGIN: string;
        static FIELD_SECTION_BEGIN_PROFILE_ID: string;
        static FIELD_SECTION_BEGIN_PROFILE_PARAMETERS: string;
        static FIELD_SECTION_END: string;
        static FIELD_SECTION_END_PROFILE_ID: string;
        static FIELD_SURFACE_LOCATION: string;
        static FIELD_TOOL_POS_FLAG: string;
        static FIELD_SECTION_END_PROFILE_PARAMETERS: string;
        path: PathCurve2dElement;
        pathProfileId: string;
        pathProfileParameters: Types<ParameterElement>;
        sectionBegin: SectionSurfaceElement;
        sectionBeginProfileId: string;
        sectionBeginProfileParameters: Types<ParameterElement>;
        sectionEnd: SectionSurfaceElement;
        sectionEndProfileId: string;
        surfaceLocation: string;
        toolPosFlag: string;
        sectionEndProfileParameters: Types<ParameterElement>;
        constructor();
        static create(familyStructure: ElementStructure): TechnologyMillingElement;
        reset(): void;
        dispose(): void;
    }
    export type TechnologyMillingElementMap = {
        [key: string]: TechnologyMillingElement;
    };
}
declare module "sk/data/scheme/database/ElementToNodeUtil" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { BezierCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/BezierCurve2dNode';
    import { BSplineCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/BSplineCurve2dNode';
    import { CircleArc2Curve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/CircleArc2Curve2dNode';
    import { CircleArcCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/CircleArcCurve2dNode';
    import { CircleCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/CircleCurve2dNode';
    import { EllipseArcCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/EllipseArcCurve2dNode';
    import { EllipseCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/EllipseCurve2dNode';
    import { LineCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/LineCurve2dNode';
    import { NurbsCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/NurbsCurve2dNode';
    import { PathCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/PathCurve2dNode';
    import { PolygonCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/PolygonCurve2dNode';
    import { PolylineCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/PolylineCurve2dNode';
    import { BezierCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/BezierCurve3dNode';
    import { BSplineCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/BSplineCurve3dNode';
    import { CircleArc2Curve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/CircleArc2Curve3dNode';
    import { CircleArcCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/CircleArcCurve3dNode';
    import { CircleCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/CircleCurve3dNode';
    import { EllipseArcCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/EllipseArcCurve3dNode';
    import { EllipseCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/EllipseCurve3dNode';
    import { LineCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/LineCurve3dNode';
    import { NurbsCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/NurbsCurve3dNode';
    import { PathCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/PathCurve3dNode';
    import { PolygonCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/PolygonCurve3dNode';
    import { PolylineCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/PolylineCurve3dNode';
    import { BoxSolidNode } from 'foundation/data/common/model/brep/geometric/solid/BoxSolidNode';
    import { ComplexHoleSolidNode } from 'foundation/data/common/model/brep/geometric/solid/ComplexHoleSolidNode';
    import { ComplexSolidNode } from 'foundation/data/common/model/brep/geometric/solid/ComplexSolidNode';
    import { ConeSolidNode } from 'foundation/data/common/model/brep/geometric/solid/ConeSolidNode';
    import { CylinderSolidNode } from 'foundation/data/common/model/brep/geometric/solid/CylinderSolidNode';
    import { EllipsoidSolidNode } from 'foundation/data/common/model/brep/geometric/solid/EllipsoidSolidNode';
    import { PointSolidNode } from 'foundation/data/common/model/brep/geometric/solid/PointSolidNode';
    import { RevolutionSolidNode } from 'foundation/data/common/model/brep/geometric/solid/RevolutionSolidNode';
    import { RoundTableSolidNode } from 'foundation/data/common/model/brep/geometric/solid/RoundTableSolidNode';
    import { SettingOut2dSolidNode } from 'foundation/data/common/model/brep/geometric/solid/SettingOut2dSolidNode';
    import { SettingOut3dSolidNode } from 'foundation/data/common/model/brep/geometric/solid/SettingOut3dSolidNode';
    import { SettingOutVectoring3dSolidNode } from 'foundation/data/common/model/brep/geometric/solid/SettingOutVectoring3dSolidNode';
    import { SphereSolidNode } from 'foundation/data/common/model/brep/geometric/solid/SphereSolidNode';
    import { StretchingSolidNode } from 'foundation/data/common/model/brep/geometric/solid/StretchingSolidNode';
    import { Sweeping2dSolidNode } from 'foundation/data/common/model/brep/geometric/solid/Sweeping2dSolidNode';
    import { Sweeping3dSolidNode } from 'foundation/data/common/model/brep/geometric/solid/Sweeping3dSolidNode';
    import { SweepingVectoring3dSolidNode } from 'foundation/data/common/model/brep/geometric/solid/SweepingVectoring3dSolidNode';
    import { BezierSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/BezierSurfaceNode';
    import { BSplineSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/BSplineSurfaceNode';
    import { ComplexHole3dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/ComplexHole3dSurfaceNode';
    import { ComplexHoleSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/ComplexHoleSurfaceNode';
    import { ComplexPlaneSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/ComplexPlaneSurfaceNode';
    import { ConeSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/ConeSurfaceNode';
    import { CylinderSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/CylinderSurfaceNode';
    import { EllipsoidSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/EllipsoidSurfaceNode';
    import { EllipticConeSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/EllipticConeSurfaceNode';
    import { EllipticCylinderSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/EllipticCylinderSurfaceNode';
    import { NurbsSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/NurbsSurfaceNode';
    import { PlaneSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/PlaneSurfaceNode';
    import { PointSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/PointSurfaceNode';
    import { Polygon3dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/Polygon3dSurfaceNode';
    import { PolygonSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/PolygonSurfaceNode';
    import { PortionSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/PortionSurfaceNode';
    import { RevolutionSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/RevolutionSurfaceNode';
    import { RoundTableSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/RoundTableSurfaceNode';
    import { Section3dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/Section3dSurfaceNode';
    import { SectionSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SectionSurfaceNode';
    import { SettingOut2dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SettingOut2dSurfaceNode';
    import { SettingOut3dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SettingOut3dSurfaceNode';
    import { SettingOutVectoring3dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SettingOutVectoring3dSurfaceNode';
    import { SliceSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SliceSurfaceNode';
    import { SphereSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SphereSurfaceNode';
    import { StretchingSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/StretchingSurfaceNode';
    import { Sweeping2dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/Sweeping2dSurfaceNode';
    import { Sweeping3dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/Sweeping3dSurfaceNode';
    import { SweepingVectoring3dSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SweepingVectoring3dSurfaceNode';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { Curve3dNode } from 'foundation/data/common/model/brep/geometric/Curve3dNode';
    import { CurveNode } from 'foundation/data/common/model/brep/geometric/CurveNode';
    import { SolidNode } from 'foundation/data/common/model/brep/geometric/SolidNode';
    import { SurfaceNode } from 'foundation/data/common/model/brep/geometric/SurfaceNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BezierCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/BezierCurve2dElement';
    import { BSplineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/BSplineCurve2dElement';
    import { CircleArc2Curve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArc2Curve2dElement';
    import { CircleArc3Curve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArc3Curve2dElement';
    import { CircleArcCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArcCurve2dElement';
    import { CircleCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleCurve2dElement';
    import { EllipseArc2Curve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/EllipseArc2Curve2dElement';
    import { EllipseArcCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/EllipseArcCurve2dElement';
    import { EllipseCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/EllipseCurve2dElement';
    import { LineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/LineCurve2dElement';
    import { NurbsCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/NurbsCurve2dElement';
    import { PathCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PathCurve2dElement';
    import { PolygonCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PolygonCurve2dElement';
    import { PolylineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PolylineCurve2dElement';
    import { BezierCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/BezierCurve3dElement';
    import { BSplineCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/BSplineCurve3dElement';
    import { CircleArc2Curve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/CircleArc2Curve3dElement';
    import { CircleArc3Curve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/CircleArc3Curve3dElement';
    import { CircleArcCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/CircleArcCurve3dElement';
    import { CircleCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/CircleCurve3dElement';
    import { EllipseArc2Curve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/EllipseArc2Curve3dElement';
    import { EllipseArcCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/EllipseArcCurve3dElement';
    import { EllipseCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/EllipseCurve3dElement';
    import { LineCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/LineCurve3dElement';
    import { NurbsCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/NurbsCurve3dElement';
    import { PathCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/PathCurve3dElement';
    import { PolygonCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/PolygonCurve3dElement';
    import { PolylineCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/PolylineCurve3dElement';
    import { Box2SolidElement } from 'sk/data/family/element/brep/geometric/solid/Box2SolidElement';
    import { BoxSolidElement } from 'sk/data/family/element/brep/geometric/solid/BoxSolidElement';
    import { ComplexHoleSolidElement } from 'sk/data/family/element/brep/geometric/solid/ComplexHoleSolidElement';
    import { ComplexSolidElement } from 'sk/data/family/element/brep/geometric/solid/ComplexSolidElement';
    import { ConeSolidElement } from 'sk/data/family/element/brep/geometric/solid/ConeSolidElement';
    import { CylinderSolidElement } from 'sk/data/family/element/brep/geometric/solid/CylinderSolidElement';
    import { EllipsoidSolidElement } from 'sk/data/family/element/brep/geometric/solid/EllipsoidSolidElement';
    import { PointSolidElement } from 'sk/data/family/element/brep/geometric/solid/PointSolidElement';
    import { RevolutionSolidElement } from 'sk/data/family/element/brep/geometric/solid/RevolutionSolidElement';
    import { RoundTableSolidElement } from 'sk/data/family/element/brep/geometric/solid/RoundTableSolidElement';
    import { SettingOut2dSolidElement } from 'sk/data/family/element/brep/geometric/solid/SettingOut2dSolidElement';
    import { SettingOut3dSolidElement } from 'sk/data/family/element/brep/geometric/solid/SettingOut3dSolidElement';
    import { SettingOutVectoring3dSolidElement } from 'sk/data/family/element/brep/geometric/solid/SettingOutVectoring3dSolidElement';
    import { Sphere2SolidElement } from 'sk/data/family/element/brep/geometric/solid/Sphere2SolidElement';
    import { SphereSolidElement } from 'sk/data/family/element/brep/geometric/solid/SphereSolidElement';
    import { StretchingSolidElement } from 'sk/data/family/element/brep/geometric/solid/StretchingSolidElement';
    import { Sweeping2dSolidElement } from 'sk/data/family/element/brep/geometric/solid/Sweeping2dSolidElement';
    import { Sweeping3dSolidElement } from 'sk/data/family/element/brep/geometric/solid/Sweeping3dSolidElement';
    import { SweepingVectoring3dSolidElement } from 'sk/data/family/element/brep/geometric/solid/SweepingVectoring3dSolidElement';
    import { BezierSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/BezierSurfaceElement';
    import { BSplineSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/BSplineSurfaceElement';
    import { ComplexHole3dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/ComplexHole3dSurfaceElement';
    import { ComplexHoleSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/ComplexHoleSurfaceElement';
    import { ComplexPlaneSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/ComplexPlaneSurfaceElement';
    import { ConeSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/ConeSurfaceElement';
    import { Cylinder2SurfaceElement } from 'sk/data/family/element/brep/geometric/surface/Cylinder2SurfaceElement';
    import { CylinderSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/CylinderSurfaceElement';
    import { EllipsoidSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/EllipsoidSurfaceElement';
    import { EllipticConeSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/EllipticConeSurfaceElement';
    import { EllipticCylinderSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/EllipticCylinderSurfaceElement';
    import { NurbsSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/NurbsSurfaceElement';
    import { PlaneSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/PlaneSurfaceElement';
    import { PointSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/PointSurfaceElement';
    import { Polygon3dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/Polygon3dSurfaceElement';
    import { PolygonSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/PolygonSurfaceElement';
    import { PortionSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/PortionSurfaceElement';
    import { RevolutionSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/RevolutionSurfaceElement';
    import { RoundTableSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/RoundTableSurfaceElement';
    import { Section3dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/Section3dSurfaceElement';
    import { SectionSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SectionSurfaceElement';
    import { SettingOut2dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SettingOut2dSurfaceElement';
    import { SettingOut3dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SettingOut3dSurfaceElement';
    import { SettingOutVectoring3dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SettingOutVectoring3dSurfaceElement';
    import { SliceSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SliceSurfaceElement';
    import { Sphere2SurfaceElement } from 'sk/data/family/element/brep/geometric/surface/Sphere2SurfaceElement';
    import { SphereSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SphereSurfaceElement';
    import { StretchingSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/StretchingSurfaceElement';
    import { Sweeping2dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/Sweeping2dSurfaceElement';
    import { Sweeping3dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/Sweeping3dSurfaceElement';
    import { SweepingVectoring3dSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SweepingVectoring3dSurfaceElement';
    import { TechnologyCavityComponentElement } from 'sk/data/family/database/technology/element/TechnologyCavityComponentElement';
    import { TechnologyGrooveComponentElement } from 'sk/data/family/database/technology/element/TechnologyGrooveComponentElement';
    import { TechnologyHoleComponentElement } from 'sk/data/family/database/technology/element/TechnologyHoleComponentElement';
    import { TechnologyMillingComponentElement } from 'sk/data/family/database/technology/element/TechnologyMillingComponentElement';
    import { TechnologyCavityNode } from 'sk/data/family/database/technology/model/TechnologyCavityNode';
    import { TechnologyGrooveNode } from 'sk/data/family/database/technology/model/TechnologyGrooveNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { TechnologyMillingNode } from 'sk/data/family/database/technology/model/TechnologyMillingNode';
    import { Curve2dElement } from 'sk/data/family/element/brep/geometric/Curve2dElement';
    import { Curve3dElement } from 'sk/data/family/element/brep/geometric/Curve3dElement';
    import { CurveElement } from 'sk/data/family/element/brep/geometric/CurveElement';
    import { SolidElement } from 'sk/data/family/element/brep/geometric/SolidElement';
    import { SurfaceElement } from 'sk/data/family/element/brep/geometric/SurfaceElement';
    import { SpatialElement } from 'sk/data/family/element/brep/SpatialElement';
    import { TechnologyComponentElement } from 'sk/data/family/element/component/TechnologyComponentElement';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { TechnologyCavityElement } from "sk/data/scheme/database/technology/element/TechnologyCavityElement";
    import { TechnologyGrooveElement } from "sk/data/scheme/database/technology/element/TechnologyGrooveElement";
    import { TechnologyHoleElement } from "sk/data/scheme/database/technology/element/TechnologyHoleElement";
    import { TechnologyMillingElement } from "sk/data/scheme/database/technology/element/TechnologyMillingElement";
    export class ElementToNodeUtil {
        static elememtToNode(context: IContext, element: SpatialElement, doc: Document, valueProvider?: IValueProvider, result?: GeometricNode): GeometricNode;
        static curveToNode(context: IContext, element: CurveElement, doc: Document, valueProvider?: IValueProvider, result?: CurveNode): CurveNode;
        static curve2dToNode(context: IContext, element: Curve2dElement, doc: Document, valueProvider?: IValueProvider, result?: Curve2dNode): Curve2dNode;
        static curve3dToNode(context: IContext, element: Curve3dElement, doc: Document, valueProvider?: IValueProvider, result?: Curve3dNode): Curve3dNode;
        static solidToNode(context: IContext, element: SolidElement, doc: Document, valueProvider?: IValueProvider, result?: SolidNode): SolidNode;
        static surfaceToNode(context: IContext, element: SurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SurfaceNode): SurfaceNode;
        static technologyElementToNode(context: IContext, element: TechnologyComponentElement, doc: Document, valueProvider?: IValueProvider, result?: TechnologyNode): TechnologyNode;
        static bezierCurve2dToNode(context: IContext, element: BezierCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: BezierCurve2dNode): BezierCurve2dNode;
        static bSplineCurve2dToNode(context: IContext, element: BSplineCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: BSplineCurve2dNode): BSplineCurve2dNode;
        static circleArc2Curve2dToNode(context: IContext, element: CircleArc2Curve2dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleArc2Curve2dNode): CircleArc2Curve2dNode;
        static circleArc3Curve2dToNode(context: IContext, element: CircleArc3Curve2dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleArcCurve2dNode): CircleArcCurve2dNode;
        static circleArcCurve2dToNode(context: IContext, element: CircleArcCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleArcCurve2dNode): CircleArcCurve2dNode;
        static circleCurve2dToNode(context: IContext, element: CircleCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleCurve2dNode): CircleCurve2dNode;
        static ellipseArc2Curve2dToNode(context: IContext, element: EllipseArc2Curve2dElement, doc: Document, valueProvider?: IValueProvider, result?: EllipseArcCurve2dNode): EllipseArcCurve2dNode;
        static ellipseArcCurve2dToNode(context: IContext, element: EllipseArcCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: EllipseArcCurve2dNode): EllipseArcCurve2dNode;
        static ellipseCurve2dToNode(context: IContext, element: EllipseCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: EllipseCurve2dNode): EllipseCurve2dNode;
        static lineCurve2dToNode(context: IContext, element: LineCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: LineCurve2dNode): LineCurve2dNode;
        static nurbsCurve2dToNode(context: IContext, element: NurbsCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: NurbsCurve2dNode): NurbsCurve2dNode;
        static pathCurve2dToNode(context: IContext, element: PathCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: PathCurve2dNode): PathCurve2dNode;
        static polygonCurve2dToNode(context: IContext, element: PolygonCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: PolygonCurve2dNode): PolygonCurve2dNode;
        static polylineCurve2dToNode(context: IContext, element: PolylineCurve2dElement, doc: Document, valueProvider?: IValueProvider, result?: PolylineCurve2dNode): PolylineCurve2dNode;
        static bezierCurve3dToNode(context: IContext, element: BezierCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: BezierCurve3dNode): BezierCurve3dNode;
        static bSplineCurve3dToNode(context: IContext, element: BSplineCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: BSplineCurve3dNode): BSplineCurve3dNode;
        static circleArc2Curve3dToNode(context: IContext, element: CircleArc2Curve3dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleArc2Curve3dNode): CircleArc2Curve3dNode;
        static circleArc3Curve3dToNode(context: IContext, element: CircleArc3Curve3dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleArcCurve3dNode): CircleArcCurve3dNode;
        static circleArcCurve3dToNode(context: IContext, element: CircleArcCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleArcCurve3dNode): CircleArcCurve3dNode;
        static circleCurve3dToNode(context: IContext, element: CircleCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: CircleCurve3dNode): CircleCurve3dNode;
        static ellipseArc2Curve3dToNode(context: IContext, element: EllipseArc2Curve3dElement, doc: Document, valueProvider?: IValueProvider, result?: EllipseArcCurve3dNode): EllipseArcCurve3dNode;
        static ellipseArcCurve3dToNode(context: IContext, element: EllipseArcCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: EllipseArcCurve3dNode): EllipseArcCurve3dNode;
        static ellipseCurve3dToNode(context: IContext, element: EllipseCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: EllipseCurve3dNode): EllipseCurve3dNode;
        static lineCurve3dToNode(context: IContext, element: LineCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: LineCurve3dNode): LineCurve3dNode;
        static nurbsCurve3dToNode(context: IContext, element: NurbsCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: NurbsCurve3dNode): NurbsCurve3dNode;
        static pathCurve3dToNode(context: IContext, element: PathCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: PathCurve3dNode): PathCurve3dNode;
        static polygonCurve3dToNode(context: IContext, element: PolygonCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: PolygonCurve3dNode): PolygonCurve3dNode;
        static polylineCurve3dToNode(context: IContext, element: PolylineCurve3dElement, doc: Document, valueProvider?: IValueProvider, result?: PolylineCurve3dNode): PolylineCurve3dNode;
        static box2SolidToNode(context: IContext, element: Box2SolidElement, doc: Document, valueProvider?: IValueProvider, result?: BoxSolidNode): BoxSolidNode;
        static boxSolidToNode(context: IContext, element: BoxSolidElement, doc: Document, valueProvider?: IValueProvider, result?: BoxSolidNode): BoxSolidNode;
        static complexSolidToNode(context: IContext, element: ComplexSolidElement, doc: Document, valueProvider?: IValueProvider, result?: ComplexSolidNode): ComplexSolidNode;
        static coneSolidToNode(context: IContext, element: ConeSolidElement, doc: Document, valueProvider?: IValueProvider, result?: ConeSolidNode): ConeSolidNode;
        static cylindersolidToNode(context: IContext, element: CylinderSolidElement, doc: Document, valueProvider?: IValueProvider, result?: CylinderSolidNode): CylinderSolidNode;
        static ellipsoidSolidToNode(context: IContext, element: EllipsoidSolidElement, doc: Document, valueProvider?: IValueProvider, result?: EllipsoidSolidNode): EllipsoidSolidNode;
        static pointSolidToNode(context: IContext, element: PointSolidElement, doc: Document, valueProvider?: IValueProvider, result?: PointSolidNode): PointSolidNode;
        static revolutionSolidToNode(context: IContext, element: RevolutionSolidElement, doc: Document, valueProvider?: IValueProvider, result?: RevolutionSolidNode): RevolutionSolidNode;
        static roundTableSolidToNode(context: IContext, element: RoundTableSolidElement, doc: Document, valueProvider?: IValueProvider, result?: RoundTableSolidNode): RoundTableSolidNode;
        static settingOut2dSolidToNode(context: IContext, element: SettingOut2dSolidElement, doc: Document, valueProvider?: IValueProvider, result?: SettingOut2dSolidNode): SettingOut2dSolidNode;
        static settingOut3dSolidToNode(context: IContext, element: SettingOut3dSolidElement, doc: Document, valueProvider?: IValueProvider, result?: SettingOut3dSolidNode): SettingOut3dSolidNode;
        static settingOutVectoring3dSolidToNode(context: IContext, element: SettingOutVectoring3dSolidElement, doc: Document, valueProvider?: IValueProvider, result?: SettingOutVectoring3dSolidNode): SettingOutVectoring3dSolidNode;
        static sphere2SolidToNode(context: IContext, element: Sphere2SolidElement, doc: Document, valueProvider?: IValueProvider, result?: SphereSolidNode): SphereSolidNode;
        static sphereSolidToNode(context: IContext, element: SphereSolidElement, doc: Document, valueProvider?: IValueProvider, result?: SphereSolidNode): SphereSolidNode;
        static stretchingSolidToNode(context: IContext, element: StretchingSolidElement, doc: Document, valueProvider?: IValueProvider, result?: StretchingSolidNode): StretchingSolidNode;
        static sweeping2dSolidToNode(context: IContext, element: Sweeping2dSolidElement, doc: Document, valueProvider?: IValueProvider, result?: Sweeping2dSolidNode): Sweeping2dSolidNode;
        static sweeping3dSolidToNode(context: IContext, element: Sweeping3dSolidElement, doc: Document, valueProvider?: IValueProvider, result?: Sweeping3dSolidNode): Sweeping3dSolidNode;
        static sweepingVectoring3dSolidToNode(context: IContext, element: SweepingVectoring3dSolidElement, doc: Document, valueProvider?: IValueProvider, result?: SweepingVectoring3dSolidNode): SweepingVectoring3dSolidNode;
        static complexHoleSolidToNode(context: IContext, element: ComplexHoleSolidElement, doc: Document, valueProvider?: IValueProvider, result?: ComplexHoleSolidNode): ComplexHoleSolidNode;
        static bezierSurfaceToNode(context: IContext, element: BezierSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: BezierSurfaceNode): BezierSurfaceNode;
        static bSplineSurfaceToNode(context: IContext, element: BSplineSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: BSplineSurfaceNode): BSplineSurfaceNode;
        static complexPlaneSurfaceToNode(context: IContext, element: ComplexPlaneSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: ComplexPlaneSurfaceNode): ComplexPlaneSurfaceNode;
        static coneSurfaceToNode(context: IContext, element: ConeSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: ConeSurfaceNode): ConeSurfaceNode;
        static cylinder2SurfaceToNode(context: IContext, element: Cylinder2SurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: CylinderSurfaceNode): CylinderSurfaceNode;
        static cylinderSurfaceToNode(context: IContext, element: CylinderSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: CylinderSurfaceNode): CylinderSurfaceNode;
        static ellipsoidSurfaceToNode(context: IContext, element: EllipsoidSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: EllipsoidSurfaceNode): EllipsoidSurfaceNode;
        static nurbsSurfaceToNode(context: IContext, element: NurbsSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: NurbsSurfaceNode): NurbsSurfaceNode;
        static planeSurfaceToNode(context: IContext, element: PlaneSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: PlaneSurfaceNode): PlaneSurfaceNode;
        static pointSurfaceToNode(context: IContext, wlement: PointSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: PointSurfaceNode): PointSurfaceNode;
        static polygonSurfaceToNode(context: IContext, element: PolygonSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: PolygonSurfaceNode): PolygonSurfaceNode;
        static revolutionSurfaceToNode(context: IContext, element: RevolutionSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: RevolutionSurfaceNode): RevolutionSurfaceNode;
        static roundTableSurfaceToNode(context: IContext, element: RoundTableSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: RoundTableSurfaceNode): RoundTableSurfaceNode;
        static sectionSurfaceToNode(context: IContext, element: SectionSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SectionSurfaceNode): SectionSurfaceNode;
        static section3dSurfaceToNode(context: IContext, element: Section3dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: Section3dSurfaceNode): Section3dSurfaceNode;
        static settingOut2dSurfaceToNode(context: IContext, element: SettingOut2dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SettingOut2dSurfaceNode): SettingOut2dSurfaceNode;
        static settingOut3dSurfaceToNode(context: IContext, element: SettingOut3dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SettingOut3dSurfaceNode): SettingOut3dSurfaceNode;
        static settingOutVectoring3dSurfaceToNode(context: IContext, element: SettingOutVectoring3dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SettingOutVectoring3dSurfaceNode): SettingOutVectoring3dSurfaceNode;
        static sphere2SurfaceToNode(context: IContext, element: Sphere2SurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SphereSurfaceNode): SphereSurfaceNode;
        static sphereSurfaceToNode(context: IContext, element: SphereSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SphereSurfaceNode): SphereSurfaceNode;
        static stretchingSurfaceToNode(context: IContext, element: StretchingSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: StretchingSurfaceNode): StretchingSurfaceNode;
        static sweeping2dSurfaceToNode(context: IContext, element: Sweeping2dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: Sweeping2dSurfaceNode): Sweeping2dSurfaceNode;
        static sweeping3dSurfaceToNode(context: IContext, element: Sweeping3dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: Sweeping3dSurfaceNode): Sweeping3dSurfaceNode;
        static sweepingVectoring3dSurfaceToNode(context: IContext, element: SweepingVectoring3dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SweepingVectoring3dSurfaceNode): SweepingVectoring3dSurfaceNode;
        static complexHole3dSurfaceToNode(context: IContext, element: ComplexHole3dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: ComplexHole3dSurfaceNode): ComplexHole3dSurfaceNode;
        static complexHoleSurfaceToNode(context: IContext, element: ComplexHoleSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: ComplexHoleSurfaceNode): ComplexHoleSurfaceNode;
        static ellipticConeSurfaceToNode(context: IContext, element: EllipticConeSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: EllipticConeSurfaceNode): EllipticConeSurfaceNode;
        static ellipticCylinderSurfaceToNode(context: IContext, element: EllipticCylinderSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: EllipticCylinderSurfaceNode): EllipticCylinderSurfaceNode;
        static portionSurfaceToNode(context: IContext, element: PortionSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: PortionSurfaceNode): PortionSurfaceNode;
        static polygon3dSurfaceToNode(context: IContext, element: Polygon3dSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: Polygon3dSurfaceNode): Polygon3dSurfaceNode;
        static sliceSurfaceToNode(context: IContext, element: SliceSurfaceElement, doc: Document, valueProvider?: IValueProvider, result?: SliceSurfaceNode): SliceSurfaceNode;
        static cavityComponentToNode(context: IContext, element: TechnologyCavityElement | TechnologyCavityComponentElement, doc: Document, valueProvider?: IValueProvider, result?: TechnologyCavityNode): TechnologyCavityNode;
        static grooveComponentToNode(context: IContext, element: TechnologyGrooveElement | TechnologyGrooveComponentElement, doc: Document, valueProvider?: IValueProvider, result?: TechnologyGrooveNode): TechnologyGrooveNode;
        static holeComponentToNode(context: IContext, element: TechnologyHoleElement | TechnologyHoleComponentElement, doc: Document, valueProvider?: IValueProvider, result?: TechnologyHoleNode): TechnologyHoleNode;
        static millingComponentElementToNode(context: IContext, element: TechnologyMillingElement | TechnologyMillingComponentElement, doc: Document, valueProvider?: IValueProvider, result?: TechnologyMillingNode): TechnologyMillingNode;
    }
}
declare module "sk/data/scheme/database/floorplan/element/BaseboardElement" {
    import { LinearElement } from 'sk/data/family/element/instance/LinearElement';
    export class BaseboardElement extends LinearElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BaseboardElementMap = {
        [key: string]: BaseboardElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/BeamElement" {
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    export class BeamElement extends FamilyInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HEIGHT: string;
        static FIELD_LEFT_WORK_DISTANCE: string;
        static FIELD_RIGHT_WORK_DISTANCE: string;
        static FIELD_BOTTOM_WORK_DISTANCE: string;
        height: number;
        protected _leftWorkDistance: FormulaProperty;
        protected _rightWorkDistance: FormulaProperty;
        protected _bottomWorkDistance: FormulaProperty;
        fromX: number;
        fromY: number;
        toX: number;
        toY: number;
        height3d: number;
        constructor();
        get leftWorkDistance(): FormulaProperty;
        get rightWorkDistance(): FormulaProperty;
        get bottomWorkDistance(): FormulaProperty;
        reset(): void;
        dispose(): void;
    }
    export type BeamElementMap = {
        [key: string]: BeamElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/CeilingSurfaceElement" {
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { SurfaceElement } from 'sk/data/family/element/instance/SurfaceElement';
    export class CeilingSurfaceElement extends SurfaceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        protected _thickness: FormulaProperty;
        constructor();
        set thickness(value: number);
        get thickness(): number;
        protected innerDump(info: StringBuffer, level: number): void;
        reset(): void;
        dispose(): void;
    }
    export type CeilingSurfaceElementMap = {
        [key: string]: CeilingSurfaceElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/CeilingElement" {
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { LayerElement } from 'sk/data/family/element/instance/LayerElement';
    import { CeilingSurfaceElement } from "sk/data/scheme/database/floorplan/element/CeilingSurfaceElement";
    export class CeilingElement extends LayerElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_DISTANCE: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        protected _surfaceDistance: FormulaProperty;
        protected _spaceDistance: FormulaProperty;
        protected _workDistance: FormulaProperty;
        constructor();
        get surfaceDistance(): FormulaProperty;
        get spaceDistance(): FormulaProperty;
        get workDistance(): FormulaProperty;
        get surface(): CeilingSurfaceElement;
        get firstSurface(): CeilingSurfaceElement;
        reset(): void;
        dispose(): void;
    }
    export type CeilingElementMap = {
        [key: string]: CeilingElement;
    };
}
declare module "sk/data/scheme/database/floorplan/model/ColumnTypeEnum" {
    export class ColumnTypeEnum {
        static Surface: string;
        static Model: string;
    }
}
declare module "sk/data/scheme/database/furniture/element/ChestElement" {
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    export class ChestElement extends AssemblyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type ChestElementMap = {
        [key: string]: ChestElement;
    };
}
declare module "sk/data/scheme/database/furniture/element/PlankElement" {
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    export class PlankElement extends PlaneElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_COMPOSITE_CD: string;
        static FIELD_TYPE_CD: string;
        static FIELD_PLACE_CD: string;
        static FIELD_AMOUNT: string;
        amount: number;
        static FIELD_SUBSTRATE_DECORATE_ID: string;
        static FIELD_BANDING_RULE_ID: string;
        static FIELD_EDGES: string;
        substrateDecorateId: string;
        bandingRuleId: string;
        rowId: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type PlankElementMap = {
        [key: string]: PlankElement;
    };
}
declare module "sk/data/scheme/database/floorplan/model/ColorThemeEnum" {
    export class ColorThemeEnum {
        static White: string;
        static Grey: string;
        static Black: string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/FloorplanConstants" {
    export class FloorplanConstants {
        static PRECISION: number;
        static TOLERANCE: number;
        static TOLERANCE_PRECISION: number;
        static TOLERANCE_PRECISION_DIGITS: number;
        static DISPLAY_PRECISION_DIGITS: number;
        static RAD_PRECISION: number;
        static RAD_TOLERANCE: number;
        static AREA_PRECISION: number;
        static AREA_TOLERANCE: number;
        static DEFAULT_BACKGROUND_COLOR: number;
        static DEFAULT_ENVIRONMENT_COLOR: number;
        static DISPLAY_HEIGHT_MAX: number;
        static ROOM_SIZE_MIN: number;
        static ROOM_SIZE_MAX: number;
        static WALL_DISTANCEE_WALL_MIN: number;
        static WALL_SPLIT_RATE_MIN: number;
        static WALL_WIDTH_DEFAULT: number;
        static WALL_WIDTH_MIN: number;
        static WALL_WIDTH_MAX: number;
        static WALL_LENGTH_MIN: number;
        static WALL_LENGTH_MAX: number;
        static WALL_HEIGHT3D_DEFAULT: number;
        static WALL_HEIGHT3D_MIN: number;
        static WALL_HEIGHT3D_MAX: number;
        static WALL_LOADBEAR_WIDTH: number;
        static WALL_INTERIOR_WIDTH: number;
        static WALL_PARTIAL_HEIGHT3D: number;
        static WALL_SPACE_MATERIAL: string;
        static WALL_WORK_MATERIAL: string;
        static WALL_JOINNER_RANGE: number;
        static WARE_LENGTH_X_DEFAULT: number;
        static WARE_LENGTH_Y_DEFAULT: number;
        static WARE_LENGTH_Z_DEFAULT: number;
        static MOLDING_PARAMS: {
            ID: string;
            HEIGHT: number;
            MIN_HEIGHT: number;
            MAX_HEIGHT: number;
            THICKNESS: number;
        };
        static CONTENT_PRELOADED_BOX_COLOR: number;
        static CONTENT_PRELOADED_BOX_OPACITY: number;
        static CONTENT_PRELOADED_FAILED_BOX_COLOR: number;
        static CONTENT_PRELOADED_FAILED_BOX_OPACITY: number;
        static DEFAULT_DATA_PRECISION: number;
        static DEFAULT_NONE_IMG: string;
        static TopviewUrl: string;
    }
}
declare module "sk/data/scheme/database/floorplan/element/FloorplanElementDirtyEnum" {
    export class FloorplanElementDirtyEnum {
        static Floorplan: number;
    }
}
declare module "sk/data/scheme/database/scheme/SchemeFamilyStructure" {
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { SchemeStructureElement } from "sk/data/scheme/database/scheme/element/SchemeStructureElement";
    export class SchemeFamilyStructure extends FamilyStructure {
        static CLASS_NAME: string;
        structure: SchemeStructureElement;
        constructor();
        setup(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/SpaceShapeNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class SpaceShapeNode extends ContentNode {
        static CLASS_NAME: string;
        static CLASS_ID: string;
        addIds: string[];
        cutIds: string[];
        display: any;
        constructor(addIds?: string[], cutIds?: string[]);
        isSameIds(addIds: string[], cutIds: string[]): boolean;
    }
}
declare module "sk/data/scheme/database/pattern/element/AssembleLinkCodeEnum" {
    export enum AssembleLinkCodeEnum {
        BathroomLayoutArea = "bathroom.layoutArea",
        AssembleRoom = "assemble.room",
        BathroomWall = "bathroom.wall",
        BathroomFloor = "bathroom.floor",
        LevelingWall = "leveling.wall",
        LevelingFloor = "leveling.floor",
        LevelingCeiling = "leveling.ceiling",
        LappedCeiling = "lapped.ceiling",
        FlatWall = "flat.wall",
        AssembleWindow = "assemble.window",
        AssembleBeam = "assemble.beam",
        AssembleDoor = "assemble.door",
        Pelmet = "pelmet",
        AssembleDoorLinkLevelingWall = "assemble.door.link.leveling.wall",
        AssembleWindowLinkLevelingWall = "assemble.window.link.leveling.wall",
        OuterBegin = "outer.begin.plank",
        OuterEnd = "outer.end.plank",
        CompositeWall = "composite.wall",
        CompositeCeiling = "composite.ceiling",
        AreaLine = "area.line",
        DecorateLayer = "decorate.layer"
    }
}
declare module "sk/data/scheme/database/floorplan/element/CorniceElement" {
    import { LinearElement } from 'sk/data/family/element/instance/LinearElement';
    export class CorniceElement extends LinearElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CorniceElementMap = {
        [key: string]: CorniceElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/WallSurfaceElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { SurfaceElement } from 'sk/data/family/element/instance/SurfaceElement';
    import { BaseboardElement } from "sk/data/scheme/database/floorplan/element/BaseboardElement";
    import { CorniceElement } from "sk/data/scheme/database/floorplan/element/CorniceElement";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    export class WallSurfaceElement extends SurfaceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_TYPE_CD: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_COWALLS: string;
        static FIELD_MOLDINGS: string;
        surfaceTypeCd: WallSurfaceTypeEnum;
        protected _spaceDistance: FormulaProperty;
        protected _workDistance: FormulaProperty;
        protected _cowalls: Types<CowallElement>;
        protected _moldings: Types<ContentInstanceElement>;
        constructor();
        get spaceDistance(): FormulaProperty;
        get workDistance(): FormulaProperty;
        get cowalls(): Types<CowallElement>;
        get moldings(): Types<ContentInstanceElement>;
        addRelation(relation: RelationElement): void;
        removeRelation(relation: RelationElement): void;
        getRoom(): RoomElement;
        getBaseboard(): BaseboardElement;
        getCornice(): CorniceElement;
        addMolding(molding: ContentInstanceElement): void;
        removeMolding(molding: ContentInstanceElement): void;
        detach(cowall: CowallElement): void;
        reset(): void;
        dispose(): void;
    }
    export type WallSurfaceElementMap = {
        [key: string]: WallSurfaceElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/WindowElement" {
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    export class WindowElement extends OpeningElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type WindowElementMap = {
        [key: string]: WindowElement;
    };
}
declare module "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class DecorateLayerMaterialTypeEnum extends EnumerationObject {
        static none: string;
        static material: string;
        static materialLayout: string;
        static materialColor: string;
        static layout: string;
        static plankDecorateWall: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/database/pattern/element/AssembleColumnElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleColumnElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_FINISH_LEFT_DISTANCE: string;
        static FIELD_FINISH_FRONT_DISTANCE: string;
        static FIELD_FINISH_RIGHT_DISTANCE: string;
        finishLeftDistance: number;
        finishFrontDistance: number;
        finishRightDistance: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleColumnElementMap = {
        [key: string]: AssembleColumnElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleLevelingWallElement" {
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleWallSeamParameterEnum extends EnumerationObject {
        static FrontSeam: string;
        static BackSeam: string;
        static LeftSeam: string;
        static RightSeam: string;
        static HorizonSeam: string;
        static VerticalSeam: string;
    }
    export class AssembleLevelingWallElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HORIZONTAL_GAP: string;
        static FIELD_HORIZONTAL_ITERATOR_STEP: string;
        static FIELD_HORIZONTAL_SEAM: string;
        static FIELD_PLANK_HEIGHT: string;
        static FIELD_PLANK_WIDTH: string;
        static FIELD_THICKNESS: string;
        static FIELD_VERTICAL_GAP: string;
        static FIELD_VERTICAL_ITERATOR_STEP: string;
        static FIELD_VERTICAL_SEAM: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_TOP_DISTANCE: string;
        static FIELD_BASE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_TOP_DISTANCE: string;
        static FIELD_SURFACE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_TOP_DISTANCE: string;
        static FIELD_DECORATE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        horizontalGap: number;
        horizontalIteratorStep: string;
        horizontalSeam: number;
        plankHeight: number;
        plankWidth: number;
        thickness: number;
        verticalGap: number;
        verticalIteratorStep: string;
        verticalSeam: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankTopDistance: number;
        basePlankBottomDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankTopDistance: number;
        surfacePlankBottomDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankTopDistance: number;
        decoratePlankBottomDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        constructor();
        get totalThickness(): number;
        getSurfaceLengthX(): number;
        reset(): void;
        dispose(): void;
    }
    export type AssembleLevelingWallElementMap = {
        [key: string]: AssembleLevelingWallElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleRoomElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    export class AssembleRoomElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        static CONTENT_DECORATE_CODE: string;
        constructor();
        getRoom(): RoomElement;
        protected checkInRoom(roomElement: RoomElement): boolean;
        protected getRoomElements(): InstanceElement[];
        reset(): void;
        dispose(): void;
    }
    export type AssembleRoomElementMap = {
        [key: string]: AssembleRoomElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/DecorateHostTypeEnum" {
    export class DecorateHostTypeEnum {
        static WallDecorate: string;
        static FloorDecorate: string;
        static CeilinigDecorate: string;
        static BeamDecorate: string;
        static DoorDecorate: string;
    }
}
declare module "sk/data/scheme/database/pattern/element/DecorateLayerElement" {
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { CutHoleStructure } from 'foundation/data/common/structure/CutHoleStructure';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { TileInfoStructure } from 'sk/data/family/database/family/element/layout/TileInfoStructure';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { DecorateLayerMaterialTypeEnum } from "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum";
    import { DecorateHostTypeEnum } from "sk/data/scheme/database/pattern/element/DecorateHostTypeEnum";
    export class DecorateLayerElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        static DECORATE_CODE: string;
        plankInfo: ISpecificationFamilyInfo;
        decorateLayerMaterialType: DecorateLayerMaterialTypeEnum;
        decorateLayerMaterialInfoId: string;
        cutHoles: Array<CutHoleStructure>;
        decorateHostType: DecorateHostTypeEnum;
        polygon: AreaPolygonElement;
        spaceToWall: number;
        cutPolygon: Array<Array<Vector2>>;
        materialInfo: any;
        decorateLayerLayoutInfo: string;
        tileInfoStructure: TileInfoStructure;
        constructor();
        hostElements(): Array<PatternInstanceElement>;
        loadJson(jconfig: any, context?: any): void;
        loadBinary(context: PersistentContext): any;
        reset(): void;
        dispose(): void;
    }
    export type DecorateLayerElementMap = {
        [key: string]: DecorateLayerElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleWindowElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { WallSurfaceElement } from "sk/data/scheme/database/floorplan/element/WallSurfaceElement";
    import { DecorateLayerMaterialTypeEnum } from "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class AssembleWindowElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_INNER_DEPTH: string;
        static FIELD_WALL_THICKNESS: string;
        static FIELD_WALL_ROTATION: string;
        static FIELD_LEVELER_MIN_DISTANCE: string;
        static FIELD_OUTLINE: string;
        innerDepth: number;
        wallThickness: number;
        wallRotation: number;
        levelerMinDistance: number;
        outline: PolygonSurfaceStructure;
        edgeId: string;
        groundId: string;
        bindWallSurface: WallSurfaceElement;
        decorateLayer: DecorateLayerElement;
        decorateLayerMaterialType: DecorateLayerMaterialTypeEnum;
        decorateLayerMaterialInfoId: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleWindowElementMap = {
        [key: string]: AssembleWindowElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleFlatWallElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export type FlatWallPoint = {
        keelDistance: number;
        innerBaseDistance: number;
        outerBaseDistance: number;
    };
    export class AssembleFlatWallElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_KEEL_BEGIN_DISTANCE: string;
        static FIELD_KEEL_END_DISTANCE: string;
        static FIELD_KEEL_BEGIN_FLAGS: string;
        static FIELD_KEEL_END_FLAGS: string;
        static FIELD_INNER_EXTENSION: string;
        static FIELD_OUTER_EXTENSION: string;
        static FIELD_REVERSE: string;
        static FIELD_INNER_BASE_ENABLE: string;
        static FIELD_INNER_DECORATE_ENABLE: string;
        static FIELD_INNER_SURFACE_ENABLE: string;
        static FIELD_INNER_BASE_BEGIN_DISTANCE: string;
        static FIELD_INNER_DECORATE_BEGIN_DISTANCE: string;
        static FIELD_INNER_SURFACE_BEGIN_DISTANCE: string;
        static FIELD_INNER_BASE_END_DISTANCE: string;
        static FIELD_INNER_DECORATE_END_DISTANCE: string;
        static FIELD_INNER_SURFACE_END_DISTANCE: string;
        static FIELD_OUTER_BASE_ENABLE: string;
        static FIELD_OUTER_DECORATE_ENABLE: string;
        static FIELD_OUTER_SURFACE_ENABLE: string;
        static FIELD_OUTER_BASE_BEGIN_DISTANCE: string;
        static FIELD_OUTER_DECORATE_BEGIN_DISTANCE: string;
        static FIELD_OUTER_SURFACE_BEGIN_DISTANCE: string;
        static FIELD_OUTER_BASE_END_DISTANCE: string;
        static FIELD_OUTER_DECORATE_END_DISTANCE: string;
        static FIELD_OUTER_SURFACE_END_DISTANCE: string;
        static FIELD_INNER_HEIGHT: string;
        static FIELD_OUTER_HEIGHT: string;
        static FIELD_INNER_SPACE_THICKNESS: string;
        static FIELD_OUTER_SPACE_THICKNESS: string;
        static FIELD_INNER_SPACE_ENABLE: string;
        static FIELD_OUTER_SPACE_ENABLE: string;
        baseThickness: number;
        keelBeginDistance: number;
        keelEndDistance: number;
        keelBeginFlags: number;
        keelEndFlags: number;
        innerExtension: number;
        outerExtension: number;
        reverse: boolean;
        innerBaseEnable: boolean;
        innerDecorateEnable: boolean;
        innerSurfaceEnable: boolean;
        innerBaseBeginDistance: number;
        innerDecorateBeginDistance: number;
        innerSurfaceBeginDistance: number;
        innerBaseEndDistance: number;
        innerDecorateEndDistance: number;
        innerSurfaceEndDistance: number;
        outerBaseEnable: boolean;
        outerDecorateEnable: boolean;
        outerSurfaceEnable: boolean;
        outerBaseBeginDistance: number;
        outerDecorateBeginDistance: number;
        outerSurfaceBeginDistance: number;
        outerBaseEndDistance: number;
        outerDecorateEndDistance: number;
        outerSurfaceEndDistance: number;
        innerHeight: number;
        outerHeight: number;
        innerSpaceThickness: number;
        outerSpaceThickness: number;
        innerSpaceEnable: boolean;
        outerSpaceEnable: boolean;
        constructor();
        get begin(): FlatWallPoint;
        get end(): FlatWallPoint;
        set begin(point: FlatWallPoint);
        set end(point: FlatWallPoint);
        assign(node: AssembleFlatWallElement): void;
        reverseFlatwall(): void;
        resetChildren(): void;
        reset(): void;
        dispose(): void;
    }
    export type AssembleFlatWallElementMap = {
        [key: string]: AssembleFlatWallElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/FlatWallElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2dStructure } from 'foundation/data/common/structure/geometric/curve2d/LineCurve2dStructure';
    import { CubeHoleStructure } from 'foundation/data/common/structure/CubeHoleStructure';
    import { FrameLayerStructure } from 'foundation/data/common/structure/FrameLayerStructure';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssembleFlatWallElement } from "sk/data/scheme/database/pattern/element/AssembleFlatWallElement";
    export class FlatWallElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HOLES: string;
        static FIELD_ORIGINAL_WALL_LINE: string;
        static FIELD_THICKNESS: string;
        static FIELD_NEXT: string;
        static FIELD_PREV: string;
        static FIELD_ASSEMBLE_WALL: string;
        static FIELD_FLATWALL_TYPE: string;
        holes: Types<CubeHoleStructure>;
        originalWallLine: LineCurve2dStructure;
        thickness: number;
        next: FlatWallElement;
        prev: FlatWallElement;
        assembleWall: AssembleFlatWallElement;
        flatwallType: string;
        frameLayer: FrameLayerStructure;
        show2d: boolean;
        show3d: boolean;
        constructor();
        getKeelHeight(): number;
        reverseFlatWall(): void;
        get originaCenterlLine(): Line2;
        get originalLine(): Line2;
        get originalInnerLine(): Line2;
        get originalOuterLine(): Line2;
        get normal(): Vector2;
        get direction(): Vector2;
        get innerLine(): Line2;
        get outerLine(): Line2;
        get centerLine(): Line2;
        addChild(element: BrepElement, dispatch?: boolean): void;
        resetChildren(): void;
        reset(): void;
        dispose(): void;
    }
    export type FlatWallElementMap = {
        [key: string]: FlatWallElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LevelingWallTypeEnumEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class LevelingWallTypeEnumEnum extends EnumerationObject {
        static Unknown: string;
        static Traditional: string;
        static Leveller: string;
        static SinglePlank: string;
        static DoublePlank: string;
        static SurfacePlank: string;
        static Default: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/database/pattern/element/LevelingWallElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { CutHoleStructure } from 'foundation/data/common/structure/CutHoleStructure';
    import { FlatWallSegStructure } from 'foundation/data/common/structure/FlatWallSegStructure';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { DecorateLayerMaterialTypeEnum } from "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum";
    import { AssembleLevelingWallElement } from "sk/data/scheme/database/pattern/element/AssembleLevelingWallElement";
    import { AssembleRoomElement } from "sk/data/scheme/database/pattern/element/AssembleRoomElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    import { LevelingWallTypeEnumEnum } from "sk/data/scheme/database/pattern/element/LevelingWallTypeEnumEnum";
    export class LevelingWallElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_TOP_DISTANCE: string;
        static FIELD_BASE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_TOP_DISTANCE: string;
        static FIELD_SURFACE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_TOP_DISTANCE: string;
        static FIELD_DECORATE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_START_WALL: string;
        static FIELD_IS_PRESS_PRE: string;
        static FIELD_IS_PRESS_NEXT: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankTopDistance: number;
        basePlankBottomDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankTopDistance: number;
        surfacePlankBottomDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankTopDistance: number;
        decoratePlankBottomDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        isStartWall: boolean;
        isPressPre: boolean;
        isPressNext: boolean;
        assembleWall: AssembleLevelingWallElement;
        decorateLayer: DecorateLayerElement;
        prev: LevelingWallElement;
        next: LevelingWallElement;
        idx: number;
        bindElement: ContentInstanceElement;
        holes: Array<any>;
        polygon: AreaPolygonElement;
        cutHoles: Types<CutHoleStructure>;
        flatWallSegs: Types<FlatWallSegStructure>;
        layerOptionFlags: Number;
        levelingType: string;
        decorateLayerMaterialType: DecorateLayerMaterialTypeEnum;
        decorateLayerMaterialInfoId: string;
        decorateLayerLayoutInfo: string;
        constructor();
        addChild(element: BrepElement, dispatch?: boolean): void;
        getAssembleRoom(): AssembleRoomElement;
        isWallPlank(): boolean;
        isWindowPlank(): boolean;
        isBeamPlank(): boolean;
        private isIndependentColumn;
        addRelation(relation: RelationElement): void;
        removeRelation(relation: RelationElement): void;
        getRoom(): RoomElement;
        getLevelingWallType(): LevelingWallTypeEnumEnum;
        getQuadratePipePos(): number;
        private findQuadratePipe;
        reset(): void;
        dispose(): void;
    }
    export type LevelingWallElementMap = {
        [key: string]: LevelingWallElement;
    };
}
declare module "sk/data/scheme/database/pattern/node/FlatWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class FlatWallNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        static FIELD_PREV: string;
        static FIELD_NEXT: string;
        protected _prev: FlatWallNode;
        protected _next: FlatWallNode;
        show2d: boolean;
        show3d: boolean;
        constructor();
        updateBoundary(): void;
        getSpaceOutline(): Array<Vector2>;
        get originalLine(): Line2;
        get originalInnerLine(): Line2;
        get originalOuterLine(): Line2;
        get originalInnerSpaceLine(): Line2;
        get originalOuterSpaceLine(): Line2;
        get normal(): Vector2;
        get direction(): Vector2;
        dispose(): void;
        static create(document: Document): FlatWallNode;
    }
    export type FlatWallNodeMap = {
        [key: string]: FlatWallNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryLine" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class CowallGeometryLine extends Line2 {
        statusValid: boolean;
        constructor();
        set(from: Vector2, to: Vector2): CowallGeometryLine;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { CowallGeometryLine } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryLine";
    export class CowallGeometryInfo extends InstanceObject {
        private cowall;
        private _innerLine;
        private _outerLine;
        private _innerFromLine;
        private _outerFromLine;
        private _innerToLine;
        private _outerToLine;
        private _fromLine;
        private _toLine;
        constructor(cowall?: CowallNode);
        set innerFrom(value: Vector2);
        set innerTo(value: Vector2);
        set outerFrom(value: Vector2);
        set outerTo(value: Vector2);
        get innerLine(): Line2;
        get outerLine(): Line2;
        get innerFrom(): Vector2;
        get innerTo(): Vector2;
        get outerFrom(): Vector2;
        get outerTo(): Vector2;
        get innerFromLine(): CowallGeometryLine;
        get innerToLine(): CowallGeometryLine;
        get outerFromLine(): CowallGeometryLine;
        get outerToLine(): CowallGeometryLine;
        get fromLine(): CowallGeometryLine;
        get toLine(): CowallGeometryLine;
        clear(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/BeamGeometry" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class BeamGeometry extends InstanceObject {
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/FloorplanMathUtil" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class FloorplanMathUtil {
        static isZero(value: number): boolean;
        static isNotZero(value: number): boolean;
        static nearlyEquals(value1: number, value2: number): boolean;
        static nearlyLess(value1: number, value2: number): boolean;
        static nearlyLessEquals(value1: number, value2: number): boolean;
        static nearlyGreater(value1: number, value2: number): boolean;
        static nearlyGreaterEquals(value1: number, value2: number): boolean;
        static locationNearlyEquals(value1: Value2, value2: Value2): boolean;
        static locationNearlyFind(points: Array<Value2>, point: Value2): Value2;
        static locationNearlyConstains(points: Array<Value2>, point: Value2): boolean;
        static isLineParallel(begin1: Value2, begin2: Value2, end1: Value2, end2: Value2): boolean;
        static isLinePerpendicular(begin1: Value2, begin2: Value2, end1: Value2, end2: Value2): boolean;
        static lineLineIntersection(begin1: Value2, begin2: Value2, end1: Value2, end2: Value2): Vector2;
        static isPointInLine(point: Value2, linePoint1: Value2, linePoint2: Value2): boolean;
        static isPointInPolygon(point: Value2, points: Array<Value2>, border?: boolean): boolean;
        static isSameLine(point1: Value2, point2: Value2, point3: Value2, point4: Value2): boolean;
        private static isValueBetweenTwoValue;
        private static addUniquePointToPoints;
        static segmentSegmentIntersections(begin1: Value2, begin2: Value2, end1: Value2, end2: Value2): Array<Value2>;
        static getSegmentPolygonOnLine(from: Value2, to: Value2, polygon: Array<Value2>, checkDir?: boolean): any;
    }
}
declare module "sk/data/scheme/database/floorplan/element/WallJoinnerElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { JoinnerElement } from 'sk/data/family/element/brep/JoinnerElement';
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    export class WallJoinnerElement extends JoinnerElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_POINTS: string;
        optionTechnologyValid: boolean;
        protected _points: Types<WallPointElement>;
        constructor();
        get points(): Types<WallPointElement>;
        get pointCount(): number;
        isSamePoint(): boolean;
        fetchJoinners(targets?: Types<WallJoinnerElement>): Types<WallJoinnerElement>;
        fetchWalls(targets?: Types<WallElement>): Types<WallElement>;
        fetchCowalls(targets?: Types<CowallElement>): Types<CowallElement>;
        fetchRooms(targets?: Types<RoomElement>): Types<RoomElement>;
        containsPoint(point: WallPointElement): boolean;
        addPoint(point: WallPointElement): void;
        removePoint(point: WallPointElement): void;
        setLocation(x: number, y: number): void;
        moveLocation(x: number, y: number): void;
        computePoint(): void;
        mergerJoinner(joinner: WallJoinnerElement): void;
        detach(): void;
        isValid(): boolean;
        protected innerDump(info: StringBuffer, level: number): void;
        toString(): string;
        reset(): void;
        dispose(): void;
    }
    export type WallJoinnerElementMap = {
        [key: string]: WallJoinnerElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/FloorSurfaceElement" {
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { SurfaceElement } from 'sk/data/family/element/instance/SurfaceElement';
    export class FloorSurfaceElement extends SurfaceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        protected _thickness: FormulaProperty;
        constructor();
        set thickness(value: number);
        get thickness(): number;
        protected innerDump(info: StringBuffer, level: number): void;
        reset(): void;
        dispose(): void;
    }
    export type FloorSurfaceElementMap = {
        [key: string]: FloorSurfaceElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/FloorElement" {
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { LayerElement } from 'sk/data/family/element/instance/LayerElement';
    import { FloorSurfaceElement } from "sk/data/scheme/database/floorplan/element/FloorSurfaceElement";
    export class FloorElement extends LayerElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_DISTANCE: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_SURFACE: string;
        protected _surfaceDistance: FormulaProperty;
        protected _spaceDistance: FormulaProperty;
        protected _workDistance: FormulaProperty;
        surface: FloorSurfaceElement;
        constructor();
        get surfaceDistance(): FormulaProperty;
        get spaceDistance(): FormulaProperty;
        get workDistance(): FormulaProperty;
        reset(): void;
        dispose(): void;
    }
    export type FloorElementMap = {
        [key: string]: FloorElement;
    };
}
declare module "sk/data/scheme/model/SchemeDataDocument" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class SchemeDataDocument extends SchemeDocument {
        protected static _factory: PersistentFactory;
        static get Factory(): PersistentFactory;
        protected constructor();
        get factory(): PersistentFactory;
        static createEmptyDocument(json?: any): SchemeDataDocument;
        static createDefaultDocument(): SchemeDataDocument;
        loadJson(jconfig: any, options?: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/ColumnGeometry" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonEdgeGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonEdgeGeometry';
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    export class ColumnGeometry extends InstanceObject {
        node: ColumnNode;
        primitivePoints: Array<Vector2>;
        points: Array<Vector2>;
        sideGeometries: Types<any>;
        topGeometry: PolygonEdgeGeometry;
        sideCount: number;
        protected _dirty: boolean;
        useEdgeMode: boolean;
        constructor();
        setup(): void;
        isDirty(): boolean;
        compute(): void;
        protected setSideGeometry(point1: Vector2, point2: Vector2, surfaceIdx?: number): PolygonEdgeGeometry;
        protected setGeometrySurfaceTop(points: Array<Vector2>): void;
        clear(): void;
        dirty(): void;
        dispose(flag?: boolean): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/ColumnNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { BrepFace } from 'foundation/runtime/geometry/brep/Brep';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ColumnComponentElement } from 'sk/data/family/database/architecture/element/ColumnComponentElement';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { ColumnElement } from "sk/data/scheme/database/floorplan/element/ColumnElement";
    import { ColumnGeometry } from "sk/data/scheme/database/floorplan/model/geometry/ColumnGeometry";
    import { ColumnTypeEnum } from "sk/data/scheme/database/floorplan/model/ColumnTypeEnum";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { WallSurfaceSpatialNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode";
    export class ColumnNode extends FamilyInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_COWALLS: string;
        static FIELD_BACK_WORK_DISTANCE: string;
        static FIELD_FRONT_WORK_DISTANCE: string;
        static FIELD_LEFT_WORK_DISTANCE: string;
        static FIELD_RIGHT_WORK_DISTANCE: string;
        protected _cowalls: Types<CowallNode>;
        backWorkDistance: number;
        frontWorkDistance: number;
        leftWorkDistance: number;
        rightWorkDistance: number;
        element: ColumnComponentElement | ColumnElement;
        modelType: ColumnTypeEnum;
        surfaceCount: number;
        protected _geometry: ColumnGeometry;
        height3d: number;
        brep: BrepBody;
        constructor();
        get cowalls(): Types<CowallNode>;
        setup(): void;
        getHost(): any;
        get sizeZ(): number;
        onFieldChanged(sender: any, event: DataNodeFieldEvent): void;
        get geometry(): ColumnGeometry;
        dirtySelf(): void;
        getFaceByDataAndName(face: BrepFace): WallSurfaceSpatialNode;
        beforBuildShape(): boolean;
        getArea(): number;
        getBoundaryPoints(): Value2[];
        dispose(): void;
        static create(document: Document): ColumnNode;
    }
    export type ColumnNodeMap = {
        [key: string]: ColumnNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/molding/CowallGraphic3dStructure" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PolygonEdgeGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonEdgeGeometry';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    export type CowallGraphic3dStructureSideInfo = {
        id: number;
        surfaceCd: WallSurfaceTypeEnum;
        positionX: number;
        positionY: number;
        rotation: number;
        geometry: BufferGeometry;
    };
    export class CowallGraphic3dStructure extends MoldingGeometryStructure {
        modelInnerFrom: Vector3;
        modelInnerTo: Vector3;
        modelOuterFrom: Vector3;
        modelOuterTo: Vector3;
        modelSpaceFrom: Vector3;
        modelSpaceTo: Vector3;
        modelWorkFrom: Vector3;
        modelWorkTo: Vector3;
        surfaceGeometries: Dictionary<PolygonEdgeGeometry>;
        openingGeometries: Types<any>;
        rangeBox: Box3;
        sideGeometries: Dictionary<any>;
        constructor();
        reset(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/GeometryObject" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class GeometryObject extends InstanceObject {
        node: DataNode;
        protected _dirty: boolean;
        constructor();
        setup(): void;
        isDirty(): boolean;
        dirty(): void;
        compute(): void;
        update(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/WallJoinnerGeometry" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { GeometryObject } from "sk/data/scheme/database/floorplan/model/geometry/GeometryObject";
    type WallJoinnerInfo = {
        wall: WallNode;
        angle: number;
    };
    export class WallJoinnerGeometry extends GeometryObject {
        node: WallJoinnerNode;
        data: {
            [key: string]: Array<Vector2>;
        };
        private _wallInfos;
        constructor();
        setup(): void;
        findPriorCowall(cowall: CowallNode): CowallNode;
        get wallInfos(): Types<WallJoinnerInfo>;
        findNextCowall(cowall: CowallNode): CowallNode;
        compute(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/WallPointGeometry" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    import { GeometryObject } from "sk/data/scheme/database/floorplan/model/geometry/GeometryObject";
    export class WallPointGeometry extends GeometryObject {
        node: WallPointNode;
        data: {
            [key: string]: Array<Vector2>;
        };
        constructor();
        setup(): void;
        getWallPoints(id: any): Array<Vector2>;
        compute(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallPointNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    import { WallPointGeometry } from "sk/data/scheme/database/floorplan/model/geometry/WallPointGeometry";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    export class WallPointNode extends VertexNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_JOINNER: string;
        joinner: WallJoinnerNode;
        element: WallPointElement;
        protected _geometry: WallPointGeometry;
        constructor();
        get geometry(): WallPointGeometry;
        getFloorplan(): FloorplanNode;
        getJoinnerCount(): number;
        getCowallCount(): number;
        getRoomCount(): number;
        fetchWalls(targets?: Types<WallNode>): Types<WallNode>;
        fetchCowalls(targets?: Types<CowallNode>, excludes?: Types<CowallNode>): Types<CowallNode>;
        fetchRooms(targets?: Types<RoomNode>): Types<RoomNode>;
        fetchPartialWalls(targets?: Types<WallNode>): Types<WallNode>;
        isConnect(point: WallPointNode): boolean;
        attachJoinner(joinner: WallJoinnerNode): void;
        detachJoinner(withRemove?: boolean, dispatch?: boolean): void;
        dirtyGeometry(): void;
        dirtySelf(): void;
        get runtimeInfo(): string;
        get joinnerInfo(): string;
        protected innerDump(info: StringBuffer, level: number): void;
        dispose(): void;
        static create(document: Document): WallPointNode;
    }
    export type WallPointNodeMap = {
        [key: string]: WallPointNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/WallJoinnerNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { JoinnerNode } from 'foundation/data/common/model/brep/JoinnerNode';
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { WallJoinnerGeometry } from "sk/data/scheme/database/floorplan/model/geometry/WallJoinnerGeometry";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    export class WallJoinnerNode extends JoinnerNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_POINTS: string;
        optionTechnologyValid: boolean;
        protected _points: Types<WallPointNode>;
        element: WallJoinnerElement;
        protected _geometry: WallJoinnerGeometry;
        constructor();
        get points(): Types<WallPointNode>;
        get pointCount(): number;
        isSingle(): boolean;
        containsPoint(point: WallPointNode): boolean;
        get geometry(): WallJoinnerGeometry;
        isSamePoint(): boolean;
        fetchWalls(targets?: Types<WallNode>): Types<WallNode>;
        fetchCowalls(targets?: Types<CowallNode>): Types<CowallNode>;
        fetchRooms(targets?: Types<RoomNode>): Types<RoomNode>;
        addPoint(point: WallPointNode): void;
        removePoint(point: WallPointNode): void;
        setLocation(x?: number, y?: number, z?: number): void;
        moveLocation(x?: number, y?: number, z?: number): void;
        computeCenter(): void;
        mergerJoinner(joinner: WallJoinnerNode): void;
        findPriorWall(node: CowallNode): WallNode;
        private getPriorValidWall;
        findPriorValidWall(node: CowallNode, checkFunction?: (wall: WallNode, findWall: WallNode, wallJoinner: WallJoinnerNode, type: string) => boolean): WallNode;
        private getNextValidWall;
        findNextWall(node: CowallNode): WallNode;
        findNextValidWall(node: CowallNode, checkFunction?: Function): WallNode;
        detach(withRemove?: boolean, dispatch?: boolean): void;
        getRelationWallPointsCount(): number;
        clearPoints(): void;
        protected innerDump(info: StringBuffer, level: number): void;
        private arrangeWallByHorizontalAngle;
        getJoinnerPoint(): Vector3;
        dispose(): void;
        static create(document: Document): WallJoinnerNode;
    }
    export type WallJoinnerNodeMap = {
        [key: string]: WallJoinnerNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/util/ColumnNodeUtil" {
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    export class ColumnNodeUtil {
        static findColumnsInRoom(room: RoomNode): ColumnNode[];
        static isInRoom(instance: ColumnNode, room: RoomNode): boolean;
        static findIndependentColumnsInRoom(room: RoomNode): ColumnNode[];
        static isFlue(node: ColumnNode): boolean;
        static isWindFlue(node: ColumnNode): boolean;
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaLineElement } from 'sk/data/family/element/brep/area/AreaLineElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FlatWallElement } from "sk/data/scheme/database/pattern/element/FlatWallElement";
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    type ColumnBeamInfo = {
        columns: Types<ColumnNode>;
        beams: Types<BeamNode>;
    };
    export class WallSurfaceInfo {
        cowall: CowallNode;
        surface: WallSurfaceNode;
        width: number;
        height: number;
        position: Vector2;
        rotationZ: number;
        contents: Array<WallSurfaceContentInfo>;
        constructor();
    }
    export class WallSurfaceContentInfo {
        node: FamilyInstanceNode;
        x: number;
        y: number;
        width: number;
        height: number;
    }
    export enum WallSurfaceLineInfoTypeEnum {
        WALL_SURFACE = 0,
        FLATWALL_SURFACE = 1,
        COLUMN_SURFACE = 2,
        COMBINE_WALL_FALTWALL_SURFACE = 3,
        LEVELINGWALL_SUFACE = 4
    }
    export type WallSurfaceLineInfo = {
        wallSurface: WallSurfaceNode;
        from: Vector2;
        to: Vector2;
        element: ContentInstanceElement;
        space?: number;
        typeCd?: WallSurfaceLineInfoTypeEnum;
        doors?: Array<any>;
        beams?: Array<any>;
        flatWallElements?: Array<FlatWallElement>;
        levelingElement?: any;
    };
    export type DecorateSurfaceLineInfo = {
        from: Vector2;
        to: Vector2;
        edge: AreaLineElement;
    };
    export type MergedWallCache = {
        mergedFromJoinner: WallJoinnerNode;
        mergedToJoinner: WallJoinnerNode;
        wallSurfaceGeometryInfos: WallSurfaceGeometryInfo[];
        cowalls: Types<CowallNode>;
    };
    type WallSurfaceGeometryInfo = {
        floorHeight: number;
        height: number;
        from: Vector2;
        to: Vector2;
        halfMode: boolean;
        ceilingThickness: number;
    };
    export class WallSurfaceNodeUtil {
        static getSurface2dInfo(cowall: CowallNode): WallSurfaceInfo;
        static getOpengingProfileLocalPoints(wallSurface: WallSurfaceNode, target?: Array<any>): Array<Array<Vector2>>;
        static getContentAttachPoints(content: ContentInstanceNode, line: Line2): Array<Vector2>;
        static getRoomOfOpenCowall(wallSurface: WallSurfaceNode): RoomNode;
        static getSurfaceRoom(wallSurfaceNode: WallSurfaceNode): RoomNode;
        static getWallSurfaceLineInfos(wallSurface: WallSurfaceNode, computeDoor?: boolean, computeBeam?: boolean): Array<WallSurfaceLineInfo>;
        static getInnerFromOffset(from: Vector2, content: ContentInstanceNode): number;
        static getColumnsOfSurface(wallSurface: WallSurfaceNode, original?: boolean): ColumnNode[];
        static getAllContentOfSurface(wallSurface: WallSurfaceNode, original?: boolean): FamilyInstanceNode[];
        static getWallSurfaceNeighbour(wallSurfaceNode: WallSurfaceNode, isPrev: boolean): WallSurfaceNode;
        static isWallSurfaceAllFlatWalls(wallSurfaceNode: WallSurfaceNode): boolean;
        static getWallSurfaceFlatWalls(wallSurfaceNode: WallSurfaceNode): Array<FlatWallElement>;
        static computeWallSurfaceArea(wallSurface: WallSurfaceNode): Array<Array<Vector2>>;
        static isShowSurfaceValid(showSurface: WallSurfaceNode): boolean;
        static findColumnBeamOfWallSurface(wallSurface: WallSurfaceNode): ColumnBeamInfo;
        static getCowallCeilingHeight(cowall: CowallNode): number;
        static computeMergedShowSurfaceFromToPoint(showSurface: WallSurfaceNode): MergedWallCache;
        private static buildSurfaceGeometryInfo;
        private static makeMergedWallSurfaceInfo;
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallSurfaceNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { WallSurfaceElement } from "sk/data/scheme/database/floorplan/element/WallSurfaceElement";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    export class WallSurfaceNode extends SurfaceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_SURFACE_TYPE_CD: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_COWALLS: string;
        static FIELD_IDENTIFIER: string;
        static FIELD_MOLDINGS: string;
        optionTechnologyValid: boolean;
        surfaceTypeCd: WallSurfaceTypeEnum;
        spaceDistance: number;
        workDistance: number;
        protected _cowalls: Types<CowallNode>;
        identifier: number;
        protected _moldings: Types<ContentInstanceNode>;
        element: WallSurfaceElement;
        showSurface: WallSurfaceNode;
        _hideSurfaces: Types<WallSurfaceNode>;
        protected _from: Vector2;
        protected _to: Vector2;
        constructor();
        get cowalls(): Types<CowallNode>;
        get moldings(): Types<ContentInstanceNode>;
        get from(): Vector2;
        get to(): Vector2;
        get hideSurfaces(): Types<WallSurfaceNode>;
        get cowallCount(): number;
        containsCowall(cowall: CowallNode): boolean;
        addCowall(cowall: CowallNode): void;
        removePoint(cowall: CowallNode): void;
        clearCowalls(): void;
        getSurfaceOriginalLine2(): Line2;
        getSurfaceLine2(): Line2;
        fetchOpenings(): Types<OpeningNode>;
        getColumns(original?: boolean): Array<ColumnNode>;
        getAllContents(original?: boolean): Array<FamilyInstanceNode>;
        fetchCowalls(): Types<CowallNode>;
        fetchMainCowalls(): Types<CowallNode>;
        isShowSurface(): boolean;
        getRoom(): RoomNode;
        dispose(): void;
        static create(document: Document): WallSurfaceNode;
    }
    export type WallSurfaceNodeMap = {
        [key: string]: WallSurfaceNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/util/BeamNodeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { BeamElement } from "sk/data/scheme/database/floorplan/element/BeamElement";
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    export type BeamWallIntersectInfo = {
        element: BeamElement;
        line: Line2;
        idxes: Array<number>;
        faceIdx: number;
    };
    export class BeamNodeUtil {
        static findBeamsInRoom(room: RoomNode): BeamNode[];
        static isInRoom(beam: BeamNode, room: RoomNode): boolean;
        static isInArea(beam: BeamNode, areaElement: AreaPolygonElement): boolean;
        static isColumnInRoom(node: ColumnNode, room: RoomNode): boolean;
        static getBeamInfoOnLine(beam: BeamNode, line: Line2): BeamWallIntersectInfo;
        private static getBeamBoxInWorld;
        private static isRelated;
        private static isLinesRelated;
        static getWallSurface(node: BeamNode): Types<WallSurfaceNode>;
        static getRoomWallSurfaceFromBeam(beamnode: BeamNode, roomnode: RoomNode): Types<WallSurfaceNode>;
        static getRoomColumnFromBeam(beamnode: BeamNode, roomnode: RoomNode, lines?: Array<Line2>): ColumnNode[];
        static computeLinesFromPolygonPoints(points: Vector2[]): Line2[];
        static getRoomFromBeam(beamnode: BeamNode): RoomNode;
        static getRoomsByBeam(beamNode: BeamNode): Array<RoomNode>;
        static getRoomWallSurfaceFromBeamInter(beamnode: BeamNode, roomnode: RoomNode): Types<WallSurfaceNode>;
        private static isIntrBeamLineAndWallLine;
        private static cowallsFilterInvalid;
        static getBeamOutLine(beam: BeamNode, polygon: Vector2[]): Vector2[];
        static getBeamPolygonInRoom(beam: BeamNode, room: RoomNode): Vector2[][];
        static isLBeam(beam: BeamNode, room: RoomNode): boolean;
    }
}
declare module "sk/data/scheme/database/floorplan/element/DoorElement" {
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    export class DoorElement extends OpeningElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type DoorElementMap = {
        [key: string]: DoorElement;
    };
}
declare module "sk/data/scheme/database/floorplan/model/CeilingSurfaceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { CeilingSurfaceElement } from "sk/data/scheme/database/floorplan/element/CeilingSurfaceElement";
    export class CeilingSurfaceNode extends SurfaceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        element: CeilingSurfaceElement;
        thickness: number;
        constructor();
        dispose(): void;
        static create(document: Document): CeilingSurfaceNode;
    }
    export type CeilingSurfaceNodeMap = {
        [key: string]: CeilingSurfaceNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/DoorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { DoorComponentElement } from 'sk/data/family/database/architecture/element/DoorComponentElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { DoorElement } from "sk/data/scheme/database/floorplan/element/DoorElement";
    export const gmsDropValue: number;
    export class DoorNode extends OpeningNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        element: DoorComponentElement | DoorElement;
        craftLength: number;
        craftHeight: number;
        craftOpen: string;
        craftJoint: string;
        private lastEntity;
        constructor();
        getCraftRemark(type?: string): string;
        setCraftSize(size: string): void;
        assignTo(entity: any): void;
        dispose(): void;
        static create(document: Document): DoorNode;
    }
    export type DoorNodeMap = {
        [key: string]: DoorNode;
    };
}
declare module "sk/data/scheme/database/floorplan/element/HoleElement" {
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    export class HoleElement extends OpeningElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_INNER_DEPTH: string;
        static FIELD_OUTER_DEPTH: string;
        innerDepth: number;
        outerDepth: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type HoleElementMap = {
        [key: string]: HoleElement;
    };
}
declare module "sk/data/scheme/database/floorplan/model/HoleNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { HoleComponentElement } from 'sk/data/family/database/architecture/element/HoleComponentElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { HoleElement } from "sk/data/scheme/database/floorplan/element/HoleElement";
    export class HoleNode extends OpeningNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_INNER_DEPTH: string;
        static FIELD_OUTER_DEPTH: string;
        innerDepth: number;
        outerDepth: number;
        element: HoleComponentElement | HoleElement;
        constructor();
        dispose(): void;
        static create(document: Document): HoleNode;
    }
    export type HoleNodeMap = {
        [key: string]: HoleNode;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleBeamElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { CutHoleStructure } from 'foundation/data/common/structure/CutHoleStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { LevelingWallElement } from "sk/data/scheme/database/pattern/element/LevelingWallElement";
    export enum AssembleBeamLevelingWallEnum {
        Left = 1,
        Right = 2,
        Bottom = 3
    }
    export class AssembleBeamElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_FINISH_LEFT_DISTANCE: string;
        static FIELD_FINISH_BOTTOM_DISTANCE: string;
        static FIELD_FINISH_RIGHT_DISTANCE: string;
        static FIELD_START_CONTRACTION: string;
        static FIELD_END_CONTRACTION: string;
        static FIELD_HAS_LEFT_PANK: string;
        static FIELD_HAS_RIGHT_PLANK: string;
        static FIELD_ORIGIN_HIGH: string;
        static FIELD_ORIGIN_BOTTOM_Z: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_LOWER: string;
        static FIELD_IS_CROSS: string;
        static FIELD_IS_FRONT_CROSS_KEEL: string;
        static FIELD_IS_BACK_CROSS_KEEL: string;
        static FIELD_LEFT_CUT_HOLES: string;
        static FIELD_RIGHT_CUT_HOLES: string;
        finishLeftDistance: number;
        finishBottomDistance: number;
        finishRightDistance: number;
        startContraction: number;
        endContraction: number;
        hasLeftPank: boolean;
        hasRightPlank: boolean;
        originHigh: number;
        originBottomZ: number;
        outline: PolygonSurfaceStructure;
        isLower: boolean;
        isCross: boolean;
        isFrontCrossKeel: boolean;
        isBackCrossKeel: boolean;
        leftCutHoles: Types<CutHoleStructure>;
        rightCutHoles: Types<CutHoleStructure>;
        crossAssembleBeams: AssembleBeamElement[];
        private _leftWall;
        private _rightWall;
        private _bottomWall;
        holes: any[];
        startContractionByBeam: boolean;
        endContractionByBeam: boolean;
        needCrossKeel: boolean;
        constructor();
        addCrossAssembleBeam(crossBeam: AssembleBeamElement): void;
        addIsLower(isLower: boolean): void;
        sortHoles(): void;
        sortNumber(a: any, b: any): number;
        setClipBoundary(outline: Vector2[]): void;
        getLeftWall(): LevelingWallElement;
        getRightWall(): LevelingWallElement;
        getBottomWall(): LevelingWallElement;
        private getLevelingWall;
        reset(): void;
        dispose(): void;
    }
    export type AssembleBeamElementMap = {
        [key: string]: AssembleBeamElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_XMIRROR: string;
        static FIELD_IS_YMIRROR: string;
        thickness: number;
        baseThickness: number;
        baseSurfaceDecorateId: string;
        outline: PolygonSurfaceStructure;
        isXmirror: boolean;
        isYmirror: boolean;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingElementMap = {
        [key: string]: AssembleCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleLevelingCeilingElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleLevelingCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_CLIP_KEEL_DISTANCE: string;
        static FIELD_CLIP_KEEL_GAP: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_YMIRROR: string;
        static FIELD_IS_XMIRROR: string;
        thickness: number;
        baseThickness: number;
        baseSurfaceDecorateId: string;
        clipKeelDistance: number;
        clipKeelGap: number;
        surfaceThickness: number;
        decorateThickness: number;
        outline: PolygonSurfaceStructure;
        isYmirror: boolean;
        isXmirror: boolean;
        isIntegration: boolean;
        polygon: AreaPolygonElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleLevelingCeilingElementMap = {
        [key: string]: AssembleLevelingCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LevelingCeilingElement" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { DecorateLayerMaterialTypeEnum } from "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum";
    import { AssembleLevelingCeilingElement } from "sk/data/scheme/database/pattern/element/AssembleLevelingCeilingElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class LevelingCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        baseSurfaceDecorateId: string;
        outline: PolygonSurfaceStructure;
        assembleCeiling: AssembleLevelingCeilingElement;
        decorateLayer: DecorateLayerElement;
        polygon: AreaPolygonElement;
        isMirrorX: boolean;
        isMirrorY: boolean;
        decorateLayerMaterialType: DecorateLayerMaterialTypeEnum;
        decorateLayerMaterialInfoId: string;
        decorateLayerLayoutInfo: string;
        holes: Array<Array<Vector2>>;
        constructor();
        addChild(element: BrepElement, dispatch?: boolean): void;
        reset(): void;
        dispose(): void;
    }
    export type LevelingCeilingElementMap = {
        [key: string]: LevelingCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleLevelingFloorElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleLevelingFloorElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HORIZONTAL_ITERATOR_STEP: string;
        static FIELD_THICKNESS: string;
        static FIELD_VERTICAL_ITERATOR_STEP: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_HORIZONTAL_SEAM: string;
        static FIELD_LEVELLER_GAP: string;
        static FIELD_PLANK_HORIZONTAL_GAP: string;
        static FIELD_PLANK_STANDARD_HEIGHT: string;
        static FIELD_PLANK_STANDARD_WIDTH: string;
        static FIELD_PLANK_VERTICAL_GAP: string;
        static FIELD_VERTICAL_SEAM: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_SURFACE_DECORATE_ID: string;
        static FIELD_PLANK_TILE_FLIP: string;
        static FIELD_PLANK_TILE_ROTATION: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_XMIRROR: string;
        static FIELD_IS_YMIRROR: string;
        horizontalIteratorStep: string;
        thickness: number;
        verticalIteratorStep: string;
        baseThickness: number;
        horizontalSeam: number;
        levellerGap: number;
        plankHorizontalGap: number;
        plankStandardHeight: number;
        plankStandardWidth: number;
        plankVerticalGap: number;
        verticalSeam: number;
        baseSurfaceDecorateId: string;
        decorateThickness: number;
        decorateSurfaceDecorateId: string;
        plankTileFlip: boolean;
        plankTileRotation: number;
        outline: PolygonSurfaceStructure;
        isXmirror: boolean;
        isYmirror: boolean;
        polygon: AreaPolygonElement;
        constructor();
        get totalThickness(): number;
        reset(): void;
        dispose(): void;
    }
    export type AssembleLevelingFloorElementMap = {
        [key: string]: AssembleLevelingFloorElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LevelingFloorElement" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { DecorateLayerMaterialTypeEnum } from "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum";
    import { AssembleLevelingFloorElement } from "sk/data/scheme/database/pattern/element/AssembleLevelingFloorElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class LevelingFloorElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        static FIELD_DECORATE_SURFACE_DECORATE_ID: string;
        outline: PolygonSurfaceStructure;
        assembleFloor: AssembleLevelingFloorElement;
        decorateLayer: DecorateLayerElement;
        polygon: AreaPolygonElement;
        holes: Array<Array<Vector2>>;
        decorateLayerMaterialType: DecorateLayerMaterialTypeEnum;
        decorateLayerMaterialInfoId: string;
        decorateLayerLayoutInfo: string;
        constructor();
        get thickness(): string;
        set thickness(value: string);
        get baseThickness(): string;
        set baseThickness(value: string);
        get baseSurfaceDecorateId(): string;
        set baseSurfaceDecorateId(value: string);
        get decorateThickness(): string;
        set decorateThickness(value: string);
        get decorateSurfaceDecorateId(): string;
        set decorateSurfaceDecorateId(value: string);
        addChild(element: BrepElement, dispatch?: boolean): void;
        reset(): void;
        dispose(): void;
    }
    export type LevelingFloorElementMap = {
        [key: string]: LevelingFloorElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssemblePelmetElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssemblePelmetElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HEIGHT: string;
        static FIELD_SPACE_WIDTH: string;
        static FIELD_LEFT_MARGIN: string;
        static FIELD_RIGHT_MARGIN: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_LAPPED: string;
        height: number;
        spaceWidth: number;
        leftMargin: number;
        rightMargin: number;
        outline: PolygonSurfaceStructure;
        isLapped: boolean;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssemblePelmetElementMap = {
        [key: string]: AssemblePelmetElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/PelmetElement" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssemblePelmetElement } from "sk/data/scheme/database/pattern/element/AssemblePelmetElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class PelmetElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        assemblePelmet: AssemblePelmetElement;
        decorateLayer: DecorateLayerElement;
        constructor();
        addChild(element: BrepElement, dispatch?: boolean): void;
        reset(): void;
        dispose(): void;
    }
    export type PelmetElementMap = {
        [key: string]: PelmetElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/ProxyCeilingElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssembleCeilingElement } from "sk/data/scheme/database/pattern/element/AssembleCeilingElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class ProxyCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_ASSEMBLE: string;
        static FIELD_DECORATE_LAYER: string;
        assemble: AssembleCeilingElement;
        decorateLayer: DecorateLayerElement;
        style: DecorateLayerElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type ProxyCeilingElementMap = {
        [key: string]: ProxyCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleLevelingWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleLevelingWallNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleLevelingWallNode;
    }
    export type AssembleLevelingWallNodeMap = {
        [key: string]: AssembleLevelingWallNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LevelingWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Solid } from 'foundation/runtime/geometry/Solid';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    export class LevelingWallNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_PRESS_PRE: string;
        static FIELD_IS_PRESS_NEXT: string;
        static FIELD_IS_START_WALL: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        isPressPre: boolean;
        isPressNext: string;
        isStartWall: boolean;
        baseMaterialResourceId: string;
        surfaceMaterialResourceId: string;
        decorateMaterialResourceId: string;
        wallSurface: WallSurfaceNode;
        constructor();
        toMath(): Solid | Solid[];
        dispose(): void;
        static create(document: Document): LevelingWallNode;
    }
    export type LevelingWallNodeMap = {
        [key: string]: LevelingWallNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/util/AssembleRoomNodeUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { DecorateSurfaceLineInfo, WallSurfaceLineInfo } from "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil";
    import { CeilingSurfaceElement } from "sk/data/scheme/database/floorplan/element/CeilingSurfaceElement";
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { AssembleCeilingElement } from "sk/data/scheme/database/pattern/element/AssembleCeilingElement";
    import { LevelingCeilingElement } from "sk/data/scheme/database/pattern/element/LevelingCeilingElement";
    import { LevelingFloorElement } from "sk/data/scheme/database/pattern/element/LevelingFloorElement";
    import { LevelingWallElement } from "sk/data/scheme/database/pattern/element/LevelingWallElement";
    import { AssembleLevelingWallNode } from "sk/data/scheme/database/pattern/node/AssembleLevelingWallNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    export class AssembleRoomNodeUtil {
        protected static _schemeConfigService: SchemeConfigService;
        static getRelationLevelingWall(cowallNode: CowallNode): LevelingWallElement;
        static getRelationParalelLevelingWalls(cowallNode: CowallNode): Array<LevelingWallElement>;
        static getRoomPolygonWithFlatWallMerged(room: RoomNode): Array<Vector2>;
        static getRoomWorkPolygon(room: RoomNode, decorateLine?: boolean): Array<Vector2>;
        static getRoomDecoratePolygonInfo(room: RoomNode): Array<DecorateSurfaceLineInfo>;
        static getRoomWorkPolygonInfo(room: RoomNode, clipDoorHole?: boolean): Array<WallSurfaceLineInfo>;
        static getRoomCompleteLinePolygonWithFlatWallMerged(room: RoomNode): Array<WallSurfaceLineInfo>;
        private static getRoomWorkPolygonInfoByClipper;
        private static getCutHolesInfo;
        static getRoomWorkClipHolesPolygonInfo(roomNode: RoomNode): Array<Line2>;
        private static getDoorVariableValueStructure;
        private static getLevelingWallBox;
        private static checkSegmentCover;
        static mergeSmallFlatWallLine(lines: Array<WallSurfaceLineInfo>): Array<WallSurfaceLineInfo>;
        private static resetPerAndNexLinePoint;
        static getWallSufaceWorkPoints(wallSurface: WallSurfaceNode): Array<Vector2>;
        static getWallSufaceWorkCutLines(wallSurface: WallSurfaceNode, isTop?: boolean, decorateLine?: boolean): Array<Array<Line2>>;
        static getWallSufaceWorkCutLinesWithLevelingElement(wallSurface: WallSurfaceNode, isTop?: boolean, decorateLine?: boolean): any;
        static getLevelingWallCutLine(levelingWall: LevelingWallElement, isTop?: boolean, decorateLine?: boolean): Line2[];
        private static getCrossCutLines;
        static getWallSufaceWorkCutLinesWithWallSurface(wallSurface: WallSurfaceNode, isTop?: boolean, decorateLine?: boolean): any;
        private static getCutLines;
        private static getRoomAllWorkLines;
        private static getWallSurfaceWorkLinesWithPrevNext;
        private static getWallSufaceWorkLines;
        private static getCrossLinesToPoints;
        static getRoomAssembleCeiling(room: RoomNode): LevelingCeilingElement | AssembleCeilingElement;
        static getRoomAssembleFloor(room: RoomNode): LevelingFloorElement;
        static getRoomCeilingWorkThickness(room: RoomNode): number;
        static getRoomFloorWorkThickness(room: RoomNode): number;
        static getRoomCeilingWorkPolygons(room: RoomNode, decorateLine?: boolean): Array<{
            polygon: Array<Vector2>;
            surface: CeilingSurfaceElement;
        }>;
        static getRoomCeilingOriginalPolygons(room: RoomNode, decorateLine?: boolean): Array<{
            polygon: Array<Vector2>;
            surface: CeilingSurfaceElement;
        }>;
        static getRoomPelmetPolygons(levelingWallNode: LevelingWallNode, roomNode: RoomNode): Array<Array<Vector2>>;
        static getRoomPelmetLines(levelingWallNode: LevelingWallNode, roomNode: RoomNode): Array<Array<Vector2>>;
        static getBeamPolygon(beam: BeamNode): Array<Vector2>;
        static getAssembleBeamPolygon(beam: BeamNode): Array<Vector2>;
        static getAssembleLevelingWallPolygon(lWall: AssembleLevelingWallNode): Array<Vector2>;
        private static getPelmetLine;
        private static getPelmetPolygons;
        static getRoomWorkPolygonByClipper(room: RoomNode): Array<Vector2>;
        private static buildStructure;
        private static getRefLine;
        private static findPrevNext;
        private static getRoomWorkInfo;
        static getLevelingWallWorkLine2(levelingWall: LevelingWallElement): Line2;
        static updateLevelingWallCode(room: RoomNode, doWallSurface: boolean): void;
        static isFirstWallSurface(wallSurfaceNode: WallSurfaceNode, room: RoomNode): boolean;
    }
}
declare module "sk/data/scheme/database/floorplan/model/CeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { LayerNode } from 'sk/data/family/model/instance/LayerNode';
    import { CeilingElement } from "sk/data/scheme/database/floorplan/element/CeilingElement";
    import { CeilingSurfaceNode } from "sk/data/scheme/database/floorplan/model/CeilingSurfaceNode";
    export class CeilingNode extends LayerNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_DISTANCE: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        surfaceDistance: number;
        spaceDistance: number;
        workDistance: number;
        element: CeilingElement;
        constructor();
        get surface(): CeilingSurfaceNode;
        get firstSurface(): CeilingSurfaceNode;
        dispose(): void;
        static create(document: Document): CeilingNode;
    }
    export type CeilingNodeMap = {
        [key: string]: CeilingNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/FloorSurfaceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { FloorSurfaceElement } from "sk/data/scheme/database/floorplan/element/FloorSurfaceElement";
    export class FloorSurfaceNode extends SurfaceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        element: FloorSurfaceElement;
        thickness: number;
        constructor();
        dispose(): void;
        static create(document: Document): FloorSurfaceNode;
    }
    export type FloorSurfaceNodeMap = {
        [key: string]: FloorSurfaceNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/FloorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { LayerNode } from 'sk/data/family/model/instance/LayerNode';
    import { FloorElement } from "sk/data/scheme/database/floorplan/element/FloorElement";
    import { FloorSurfaceNode } from "sk/data/scheme/database/floorplan/model/FloorSurfaceNode";
    export class FloorNode extends LayerNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_DISTANCE: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_SURFACE: string;
        surfaceDistance: number;
        spaceDistance: number;
        workDistance: number;
        surface: FloorSurfaceNode;
        element: FloorElement;
        constructor();
        dispose(): void;
        static create(document: Document): FloorNode;
    }
    export type FloorNodeMap = {
        [key: string]: FloorNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/WindowNode" {
    import { Vector3 } from 'cross/runtime/math/Vector3';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { WindowComponentElement } from 'sk/data/family/database/architecture/element/WindowComponentElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WindowElement } from "sk/data/scheme/database/floorplan/element/WindowElement";
    export class WindowNode extends OpeningNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        element: WindowComponentElement | WindowElement;
        craftJoint: string;
        windowTypeCd: string;
        constructor();
        reset(): void;
        getCraftRemark(type?: string): string;
        getBuildShapePlaneCd(): number;
        getPolygonPoints(): Vector3[];
        dispose(): void;
        static create(document: Document): WindowNode;
    }
    export type WindowNodeMap = {
        [key: string]: WindowNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/RoomNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaNode } from 'foundation/data/common/model/brep/AreaNode';
    import { ContentHostInfo, ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { IContentHost } from 'foundation/data/common/model/brep/IContentHost';
    import { SpaceMatchStatusEnum } from 'foundation/data/common/define/SpaceMatchStatusEnum';
    import { SpaceTypeEnum } from 'foundation/data/common/define/SpaceTypeEnum';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { RoomGeometry } from "sk/data/scheme/database/floorplan/model/geometry/RoomGeometry";
    import { CeilingNode } from "sk/data/scheme/database/floorplan/model/CeilingNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorNode } from "sk/data/scheme/database/floorplan/model/FloorNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    export class RoomNode extends AreaNode implements IContentHost {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_REFERENCE_INFO_ID: string;
        static FIELD_HEIGHT3D: string;
        static FIELD_CEILING_HEIGHT3D: string;
        static FIELD_CEILING: string;
        static FIELD_FLOOR_HEIGHT3D: string;
        static FIELD_FLOOR: string;
        static FIELD_ROOT: string;
        static FIELD_CONTENTS: string;
        optionTechnologyValid: boolean;
        referenceInfoId: string;
        height3d: number;
        ceilingHeight3d: number;
        ceiling: CeilingNode;
        floorHeight3d: number;
        floor: FloorNode;
        root: CowallNode;
        protected _contents: Types<ContentNode>;
        element: RoomElement;
        typeCd: SpaceTypeEnum;
        typeName: string;
        matchStatusCd: SpaceMatchStatusEnum;
        rooms: Array<RoomNode>;
        area: number;
        centerX: number;
        centerY: number;
        customArea: string;
        protected _geometry: RoomGeometry;
        singleRoomMode: boolean;
        constructor();
        get contents(): Types<ContentNode>;
        get geometry(): RoomGeometry;
        getFloorplan(): FloorplanNode;
        getSpaceHeight(): number;
        getCowallCount(): number;
        fetchPoints(target?: Types<WallPointNode>): Types<WallPointNode>;
        fetchPolygonPoints(target?: Types<WallPointNode>): Array<WallPointNode>;
        fetchWallInnerSurfaces(): Array<WallSurfaceNode>;
        fetchWallOuterSurfaces(): Array<WallSurfaceNode>;
        fetchShowSurfaces(): Types<WallSurfaceNode>;
        private addSurfaceBetweenCowall;
        fetchAllPoints(target?: Types<WallPointNode>): Types<WallPointNode>;
        fetchJoinners(target?: Types<WallJoinnerNode>): Types<WallJoinnerNode>;
        fetchPolygon(target?: Types<WallPointNode>): Types<WallPointNode>;
        fetchJoinner(target?: Types<WallJoinnerNode>): Types<WallJoinnerNode>;
        fetchWallSurfaces(target?: Types<WallSurfaceNode>, hasOpenCowalls?: boolean): Types<WallSurfaceNode>;
        fetchCowalls(target?: Types<CowallNode>, hasOpenCowalls?: boolean): Types<CowallNode>;
        fetchConnectCowalls(target?: Types<CowallNode>): Types<CowallNode>;
        fetchWalls(target?: Types<WallNode>): Types<WallNode>;
        fetchConnectRooms(target?: Types<RoomNode>): Types<RoomNode>;
        fetchContents(targets?: Types<ContentNode>): Types<ContentNode>;
        fetchContentsByType(type: Function, targets?: Types<ContentNode>): Types<ContentNode>;
        fetchConnectContents(targets?: Types<ContentNode>): Types<ContentNode>;
        isContentIn(content: ContentNode): boolean;
        isOnRoomWall(opening: OpeningNode): boolean;
        isRoomIn(content: ContentNode): boolean;
        fetchHostInfos(targets?: Types<ContentHostInfo>): Types<ContentHostInfo>;
        fetchConnectHostInfos(targets?: Types<ContentHostInfo>): Types<ContentHostInfo>;
        getArea(): number;
        detachCowalls(): void;
        forEachContent(callback: Function, owner?: any): void;
        eliminateCommonWalls(): void;
        protected innerDump(info: StringBuffer, level: number): void;
        debugValid(context?: any): void;
        getWindowNumber(): number;
        getWindowList(): Array<OpeningNode>;
        getOpeningsByType(type: any): Array<OpeningNode>;
        getDoorList(): Array<OpeningNode>;
        getBasePolygon(includeColumns?: boolean): Array<Vector2>;
        getOuterPolygon(includeColumns?: boolean): Array<Vector2>;
        getBaseCeilingPolygon(exclude: ContentNode, includeColumnsBeams?: boolean): Array<Array<Vector2>>;
        get ceilingZ(): number;
        get floorZ(): number;
        get ceilingWorkZ(): number;
        get floorWorkZ(): number;
        dirtySelf(): void;
        toDisplay(): string;
        static identifierSorter(room1: RoomNode, room2: RoomNode): number;
        addContent(entity: ContentNode): void;
        removeContent(entity: ContentNode): void;
        wallsHasBaseboard(): boolean;
        wallsHasCornice(): boolean;
        dispose(): void;
        static create(document: Document): RoomNode;
    }
    export type RoomNodeMap = {
        [key: string]: RoomNode;
    };
}
declare module "sk/data/scheme/util/SchemeProcessContext" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    export class SchemeProcessContext extends InstanceObject {
        familyStructure: SchemeFamilyStructure;
        floorplan: FloorplanElement;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/WallPointElementUtil" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    export class WallPointElementUtil {
        static createPointByValue(structure: SchemeFamilyStructure, x?: number, y?: number): WallPointElement;
        static createPointByVector(structure: SchemeFamilyStructure, point: Value2): WallPointElement;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/WallElementUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { SchemeProcessContext } from "sk/data/scheme/util/SchemeProcessContext";
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    export class WallElementSplitInfo {
        wall: WallElement;
    }
    export class WallElementUtil {
        static createWallByVector(structure: SchemeFamilyStructure, begin: Value2, end: Value2, width?: number, height3d?: number): WallElement;
        static createWallByPoint(familyStructure: SchemeFamilyStructure, begin: WallPointElement, end: WallPointElement, width?: number, height3d?: number, referenceInfoId?: string): WallElement;
        static deleteWall(floorplan: FloorplanElement, wall: WallElement): void;
        static tryMerge(joinner: WallJoinnerElement): WallElement;
        static canMerge(wall1: WallElement, wall2: WallElement): boolean;
        static merge(wall1: WallElement, wall2: WallElement, joinner: WallJoinnerElement): WallElement;
        static autoFitToWall(host: CowallElement, content: FamilyInstanceElement): boolean;
        static findWallByToPoint(point1: WallPointElement, point2: WallPointElement): WallElement;
        static copyWallProperty(wall: WallElement, otherWall: WallElement): void;
        static checkConnectRelation(cowall1: CowallElement, cowall2: CowallElement): void;
        static sortByLerp(left: any, right: any): number;
        private static getValidSplitPoints;
        static splitByPoints(context: SchemeProcessContext, wall: WallElement, points: Array<Value2>): ResultObject<Types<WallElement>>;
        static splitByPoint(context: SchemeProcessContext, wall: WallElement, point: Value2): ResultObject<Types<WallElement>>;
        static splitByRate(context: SchemeProcessContext, wall: WallElement, rate: number): ResultObject<Types<WallElement>>;
        static findWallOverlap(currentWall: WallElement): Types<WallElement>;
        private static createWallsByPoints;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/DetachedFloorplanInfo" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    export class OldCowallInfo {
        cowall: CowallElement;
        from: Vector2;
        to: Vector2;
        isMain: Boolean;
        partner: CowallElement;
        constructor(cowall: CowallElement, isMain?: boolean);
    }
    export type OldWallInfo = {
        wall: WallElement;
        from: Vector2;
        to: Vector2;
    };
    export type OldRoomInfo = {};
    export type NewCowallInfo = {};
    export type NewWallInfo = {
        wall: WallElement;
    };
    export type NewRoomInfo = {
        room: RoomElement;
        polygon: Array<Vector2>;
    };
    export class DetachedFloorplanInfo {
        document: SchemeDocument;
        rooms: Array<RoomElement>;
        walls: Array<WallElement>;
        wallsInfo: Array<OldWallInfo>;
        cowallsInfo: Array<OldCowallInfo>;
        newRooms: Array<NewRoomInfo>;
        newWalls: Array<WallElement>;
        newCowalls: Array<CowallElement>;
        constructor(document: any);
        addRoom(room: RoomElement): void;
        addWall(...walls: WallElement[]): void;
        addWallInfo(...oldWallsInfo: OldWallInfo[]): void;
        addCowall(cowallInfo: OldCowallInfo): void;
        addNewRoom(room: RoomElement, polygon: Array<Vector2>): void;
        addNewWall(...walls: WallElement[]): void;
        addNewCowall(cowall: CowallElement): void;
        transformInfo(): void;
        copyRoomInfo(): void;
        copyWallInfo(): void;
        transformWallRelations(oldwall: WallElement, newWall: WallElement): void;
        transformPartnerCowallAttributes(oldCowall: CowallElement, newCowall: CowallElement): void;
        copyCowallInfo(): void;
        clearOldContents(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/CowallElementUtil" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    import { DetachedFloorplanInfo } from "sk/data/scheme/database/floorplan/element/util/DetachedFloorplanInfo";
    export class CowallElementUtil {
        private static attachWall;
        static createCowallByWall(structure: SchemeFamilyStructure, wall: WallElement, referCowall?: CowallElement): CowallElement;
        static copyCowallProperty(targetCowall: CowallElement, sourceCowall: CowallElement): void;
        static createCowallsByWall(structure: SchemeFamilyStructure, wall: WallElement, referCowall: CowallElement): CowallElement;
        static createCowallByVectors(structure: SchemeFamilyStructure, begin: Value2, end: Value2): CowallElement;
        static detachCowall(floorplan: FloorplanElement, cowall: CowallElement, detachInfo?: DetachedFloorplanInfo): void;
        static deleteCowall(floorplan: FloorplanElement, cowall: CowallElement, detachInfo?: DetachedFloorplanInfo): void;
        static insertWallAtPoint(cowall: CowallElement, point: WallPointElement): WallElement;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/RoomElementUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { DetachedFloorplanInfo } from "sk/data/scheme/database/floorplan/element/util/DetachedFloorplanInfo";
    export class RoomElementUtil {
        static isValidRoomPoints(points: Array<Value2>): boolean;
        static getRoomContentIn(floorplan: FloorplanElement, point: Value2): RoomElement;
        static createRoom(familyStructure: SchemeFamilyStructure): RoomElement;
        static createRoomFromPoints(floorplan: FloorplanElement, points: Array<Value2>, center?: Vector2, wallWidth?: number, height3d?: number): RoomElement;
        static snapRoomToRoom(room: RoomElement, refRoom: RoomElement): Vector2;
        static splitRoomByLoops(floorplan: FloorplanElement, loops: Array<Array<WallJoinnerElement>>, relatedRooms?: Types<RoomElement>): any[];
        static deleteRoom(floorplan: FloorplanElement, room: RoomElement): void;
        static detachRoom(floorplan: FloorplanElement, room: RoomElement, detachInfo?: DetachedFloorplanInfo): void;
        static fetchPublicWalls(room1: RoomElement, room2: RoomElement): Types<CowallElement>;
        static setRoomVisible(room: RoomElement, visible: boolean): void;
        static setSingleRoomMode(room: RoomElement, isSingleRoomMode: boolean): void;
        static mergeRooms(floorplan: FloorplanElement, room: RoomElement, roomMerged: RoomElement, delcowall: CowallElement): void;
        static setRoomHeight3d(room: RoomElement, value: number): void;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/WallJoinnerElementUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    type WallJoinnerInfo = {
        wall: WallElement;
        angle: number;
    };
    export class JoinnerLoopCache {
        joinnerInfos: {
            [key: string]: {
                wallInfos: Types<WallJoinnerInfo>;
                loops: {
                    [key: string]: Array<any>;
                };
            };
        };
        currentLoop?: WallJoinnerLoop;
        constructor();
    }
    class WallJoinnerLoop {
        joinners: Array<WallJoinnerElement>;
        preWalls: Array<WallElement>;
        isComplete: boolean;
        constructor();
        add(wall: WallElement, joinner: WallJoinnerElement): boolean;
        pop(): void;
        copyToCache(cache: JoinnerLoopCache): void;
        isValid(): boolean;
    }
    export class WallJoinnerElementUtil {
        static createJoinner(structure: SchemeFamilyStructure, ...points: Array<WallPointElement>): WallJoinnerElement;
        static joinPoint(floorplan: FloorplanElement, point: WallPointElement): WallJoinnerElement;
        static joinPoints(floorplan: FloorplanElement, point1: WallPointElement, point2: WallPointElement): WallJoinnerElement;
        private static getJoinnetSortedWalls;
        private static getJoinnerWallInfos;
        private static findNextWall;
        private static loopFindLoop;
        static findValidLoop(joinner: WallJoinnerElement, wall: WallElement, cache?: JoinnerLoopCache): Array<WallJoinnerElement>;
    }
}
declare module "sk/data/scheme/database/floorplan/element/WallPointElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { VertexElement } from 'sk/data/family/element/brep/VertexElement';
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    export class WallPointElement extends VertexElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_JOINNER: string;
        joinner: WallJoinnerElement;
        constructor();
        get floorplan(): FloorplanElement;
        get joinnerCount(): number;
        get cowallCount(): number;
        get roomCount(): number;
        fetchWalls(targets?: Types<WallElement>): Types<WallElement>;
        fetchCowalls(targets?: Types<CowallElement>, excludes?: Types<CowallElement>): Types<CowallElement>;
        fetchRooms(targets?: Types<RoomElement>): Types<RoomElement>;
        fetchPartialWalls(targets?: Types<WallElement>): Types<WallElement>;
        isConnect(point: WallPointElement): boolean;
        attachJoinner(joinner: WallJoinnerElement): void;
        detachJoinner(): void;
        dirtyFlag(recursive?: boolean): void;
        get joinnerInfo(): string;
        protected innerDump(info: StringBuffer, level: number): void;
        setPoint(point: WallPointElement): WallPointElement;
        reset(): void;
        dispose(): void;
    }
    export type WallPointElementMap = {
        [key: string]: WallPointElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/WallSurfaceSpatialElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { SurfaceStructure } from 'foundation/data/common/structure/geometric/SurfaceStructure';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { SurfaceElement } from 'sk/data/family/element/instance/SurfaceElement';
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    export class WallSurfaceSpatialElement extends SurfaceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_TYPE_CD: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_WALL: string;
        static FIELD_SURFACES: string;
        static FIELD_SURFACE_SOURCE: string;
        static FIELD_SURFACE_NAME: string;
        static FIELD_MOLDINGS: string;
        surfaceTypeCd: WallSurfaceTypeEnum;
        protected _spaceDistance: FormulaProperty;
        protected _workDistance: FormulaProperty;
        wall: WallElement;
        surfaces: Types<SurfaceStructure>;
        surfaceSource: ContentElement;
        surfaceName: string;
        protected _moldings: Types<ContentInstanceElement>;
        constructor();
        get spaceDistance(): FormulaProperty;
        get workDistance(): FormulaProperty;
        get moldings(): Types<ContentInstanceElement>;
        isInSpatialSurfaces(): boolean;
        reset(): void;
        dispose(): void;
    }
    export type WallSurfaceSpatialElementMap = {
        [key: string]: WallSurfaceSpatialElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/WallElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ElementNode } from 'foundation/data/common/element/ElementNode';
    import { CurveEdgeElement } from 'sk/data/family/element/brep/topology/CurveEdgeElement';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    import { WallSurfaceSpatialElement } from "sk/data/scheme/database/floorplan/element/WallSurfaceSpatialElement";
    export class WallMergeInfo {
        first: any;
        merge: any;
        last: any;
    }
    export class WallSplitResultInfo {
        point: Vector2;
        walls: Array<WallElement>;
    }
    export class WallElement extends CurveEdgeElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_OPTION_LOAD_BEARING: string;
        static FIELD_OPTION_INNER_LOCK: string;
        static FIELD_OPTION_OUTER_LOCK: string;
        static FIELD_OPTION_HALF: string;
        static FIELD_OPTION_CUSTOMIZED: string;
        static FIELD_REFERENCE_INFO_ID: string;
        static FIELD_WIDTH: string;
        static FIELD_HEIGHT3D: string;
        static FIELD_INNER_FROM_DISTANCE: string;
        static FIELD_INNER_TO_DISTANCE: string;
        static FIELD_OUTER_FROM_DISTANCE: string;
        static FIELD_OUTER_TO_DISTANCE: string;
        static FIELD_FROM_INNER_OFFSET: string;
        static FIELD_FROM_OFFSET: string;
        static FIELD_FROM_OUTER_OFFSET: string;
        static FIELD_TO_INNER_OFFSET: string;
        static FIELD_TO_OFFSET: string;
        static FIELD_TO_OUTER_OFFSET: string;
        static FIELD_RELATIONS: string;
        static FIELD_CONTENTS: string;
        static FIELD_OPENINGS: string;
        static FIELD_SPATIAL_SURFACES: string;
        optionTechnologyValid: boolean;
        optionLoadBearing: boolean;
        optionInnerLock: boolean;
        optionOuterLock: boolean;
        optionHalf: boolean;
        optionCustomized: boolean;
        referenceInfoId: string;
        width: number;
        height3d: number;
        innerFromDistance: number;
        innerToDistance: number;
        outerFromDistance: number;
        outerToDistance: number;
        fromInnerOffset: number;
        fromOffset: number;
        fromOuterOffset: number;
        toInnerOffset: number;
        toOffset: number;
        toOuterOffset: number;
        protected _relations: Types<RelationElement>;
        protected _contents: Types<ContentElement>;
        protected _openings: Types<OpeningElement>;
        protected _spatialSurfaces: Types<WallSurfaceSpatialElement>;
        TechnologyType: string;
        structure: SchemeFamilyStructure;
        coedge: CowallElement;
        offsetDistance: number;
        constructor();
        get relations(): Types<RelationElement>;
        get contents(): Types<ContentElement>;
        get openings(): Types<OpeningElement>;
        get spatialSurfaces(): Types<WallSurfaceSpatialElement>;
        from: WallPointElement;
        to: WallPointElement;
        addRelation(relation: RelationElement): void;
        removeRelation(relation: RelationElement): void;
        get floorplan(): FloorplanElement;
        isFromPoint(point: WallPointElement): boolean;
        isFlatWall(): boolean;
        isConnectFromPoint(point: WallPointElement): boolean;
        isConnectToPoint(point: WallPointElement): boolean;
        isToPoint(point: WallPointElement): boolean;
        fetchCowalls(targets?: Types<CowallElement>, excludes?: Types<CowallElement>): Types<CowallElement>;
        fetchRooms(targets?: Types<RoomElement>): Types<RoomElement>;
        hasContent(): boolean;
        hasOpening(): boolean;
        fetchContents(targets?: Types<ContentElement>): Types<ContentElement>;
        forEachContent(callback: Function, scope?: any): void;
        addContent(element: ElementNode): void;
        removeContent(element: ElementNode): void;
        moveContentOffset(x: number, y: number, z: number): void;
        moveOpeningOffset(x: number, y: number, z: number): void;
        contentsAssignTo(host: DataNode): void;
        addChild(entity: BrepElement, dispatch?: boolean): void;
        checkConnectRelation(cowall1: CowallElement, cowall2: CowallElement): void;
        dirtyFlag(recursive?: boolean): void;
        innerDump(info: StringBuffer, level: number): void;
        debugValid(context?: any): void;
        isSharedBySameRoom(wall: WallElement): boolean;
        findCommonWalls(): Types<WallElement>;
        canMerge(wall1: WallElement, wall2: WallElement): boolean;
        protected findMergedNext(cowall: CowallElement, flag: boolean, point: WallPointElement): CowallElement;
        protected getMergeLineEndPoint(wall1: WallElement, wall2: WallElement): WallPointElement;
        reset(): void;
        dispose(): void;
    }
    export type WallElementMap = {
        [key: string]: WallElement;
    };
}
declare module "sk/data/scheme/database/floorplan/model/WallLinePointNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    export class WallLinePointNode extends VertexNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): WallLinePointNode;
    }
    export type WallLinePointNodeMap = {
        [key: string]: WallLinePointNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/util/WallNodeUtil" {
    import { ByteStream } from 'cross/runtime/lang/stream/ByteStream';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { CowallGeometryInfo } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryInfo";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    export type WallPointNeighborData = {
        wall: WallNode;
        angle: number;
    };
    export type WallPointNeighborInfo = {
        left: WallNode;
        leftAngle: number;
        right: WallNode;
        rightAngle: number;
    };
    export class WallComputeOption {
        primitiveInnerLine: Line2;
        primitiveOuterLine: Line2;
        fromCrossInnerLine: Line2;
        fromCrossOuterLine: Line2;
        toCrossInnerLine: Line2;
        toCrossOuterLine: Line2;
    }
    export class WallNodeUvOption {
        innerWallSurfaceUVOption: UVOptions;
        outerWallSurfaceUVOption: UVOptions;
        fromWallSurfaceUVOption: UVOptions;
        toWallSurfaceUVOption: UVOptions;
        topWallSurfaceUVOption: UVOptions;
        bottomWallSurfaceUVOption: UVOptions;
        constructor();
        serialize(stream: ByteStream): void;
    }
    export class WallNodeUtil {
        static wallSurfaceUVSerialize(cowall: CowallNode, stream: ByteStream): void;
        static setWallVisible(wall: WallNode, visible: boolean): void;
        static isValidCowall(cowall: CowallNode, tolerance?: number): boolean;
        static autoFitToWall(host: DataNode, content: ContentNode): boolean;
        static computeWallPrimitiveGeometry(wall: WallNode | CowallNode, options?: any): Array<Vector2>;
        static findNearestCowall(position: Vector2, wall: WallNode): CowallNode;
        static isOrtho: (wall: WallNode) => boolean;
        static wallShowValidityCheck(wall: WallNode): boolean;
        static makeVisualOption(wall: WallNode): WallComputeOption;
        static makeWallOption(wall: WallNode): WallComputeOption;
        static makeCrossOption(wall: WallNode, options?: WallComputeOption, checkFunc?: (wall: WallNode, findWall: WallNode, wallJoinner: WallJoinnerNode, type: string) => boolean): WallComputeOption;
        private static isInRoom;
        static makeSingleRoomOption(wall: WallNode, selectedRoom: RoomNode): WallComputeOption;
        static makeSingleRoomOption1(wall: WallNode, selectedRoom: RoomNode): WallComputeOption;
        private static findVerticalLines;
        private static findHorizontalLines;
        private static findCloseLine;
        static findFlatWall(wall: WallNode): FlatWallNode;
        static computeGeometry(options: WallComputeOption, geometryInfo?: CowallGeometryInfo): CowallGeometryInfo;
        static updateWall2dShow(wall: WallNode, openings: Array<OpeningNode>): Vector2[][];
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/WallGeometry" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonEdgeGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonEdgeGeometry';
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { CowallGeometryLine } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryLine";
    import { GeometryObject } from "sk/data/scheme/database/floorplan/model/geometry/GeometryObject";
    export class WallGeometry extends GeometryObject {
        node: WallNode;
        width: number;
        begin: Vector2;
        end: Vector2;
        center: Vector2;
        rotation: number;
        protected _primitivePositions: Array<Vector2>;
        protected _positions: Array<Vector2>;
        protected _indices: Array<number>;
        protected _innerLine: Line2;
        protected _outerLine: Line2;
        protected _innerMiddle: Vector2;
        protected _outerMiddle: Vector2;
        protected _fromLine: CowallGeometryLine;
        protected _innerFromLine: CowallGeometryLine;
        protected _outerFromLine: CowallGeometryLine;
        protected _toLine: CowallGeometryLine;
        protected _innerToLine: CowallGeometryLine;
        protected _outerToLine: CowallGeometryLine;
        surfaceGeometries: Dictionary<PolygonEdgeGeometry>;
        openingGeometries: Types<any>;
        sideGeometries: Dictionary<any>;
        private _sidePaths;
        useEdgeMode: boolean;
        constructor();
        get primitivePositions(): Array<Vector2>;
        get positions(): Array<Vector2>;
        get indices(): Array<number>;
        get innerLine(): Line2;
        get innerFrom(): Vector2;
        get innerMiddle(): Vector2;
        get innerTo(): Vector2;
        get outerLine(): Line2;
        get outerFrom(): Vector2;
        get outerMiddle(): Vector2;
        get outerTo(): Vector2;
        get fromLine(): CowallGeometryLine;
        get innerFromLine(): CowallGeometryLine;
        get outerFromLine(): CowallGeometryLine;
        get toLine(): CowallGeometryLine;
        get innerToLine(): CowallGeometryLine;
        get outerToLine(): CowallGeometryLine;
        isValid(): boolean;
        updatePrimitive(): void;
        compute(): void;
        clear(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallTypeEnum" {
    export class WallTypeEnum {
        static Generic: string;
        static Gypsum120: string;
        static NonBrick120: string;
        static Brick120: string;
        static Brick240: string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepFace } from 'foundation/runtime/geometry/brep/Brep';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { SingleCurve2d } from 'foundation/runtime/geometry/Curve2d';
    import { CurveEdgeNode } from 'foundation/data/common/model/brep/topology/CurveEdgeNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ContentHostInfo, ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SpaceTypeEnum } from 'foundation/data/common/define/SpaceTypeEnum';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallGeometry } from "sk/data/scheme/database/floorplan/model/geometry/WallGeometry";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    import { WallSurfaceSpatialNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode";
    import { WallTypeEnum } from "sk/data/scheme/database/floorplan/model/WallTypeEnum";
    export class WallNode extends CurveEdgeNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_OPTION_LOAD_BEARING: string;
        static FIELD_OPTION_INNER_LOCK: string;
        static FIELD_OPTION_OUTER_LOCK: string;
        static FIELD_OPTION_HALF: string;
        static FIELD_REFERENCE_INFO_ID: string;
        static FIELD_WIDTH: string;
        static FIELD_HEIGHT3D: string;
        static FIELD_INNER_FROM_DISTANCE: string;
        static FIELD_INNER_TO_DISTANCE: string;
        static FIELD_OUTER_FROM_DISTANCE: string;
        static FIELD_OUTER_TO_DISTANCE: string;
        static FIELD_FROM_INNER_OFFSET: string;
        static FIELD_FROM_OFFSET: string;
        static FIELD_FROM_OUTER_OFFSET: string;
        static FIELD_TO_INNER_OFFSET: string;
        static FIELD_TO_OFFSET: string;
        static FIELD_TO_OUTER_OFFSET: string;
        static FIELD_CONTENTS: string;
        static FIELD_OPENINGS: string;
        static FIELD_SPATIAL_SURFACES: string;
        optionTechnologyValid: boolean;
        optionLoadBearing: boolean;
        optionInnerLock: boolean;
        optionOuterLock: boolean;
        optionHalf: boolean;
        referenceInfoId: string;
        width: number;
        height3d: number;
        innerFromDistance: number;
        innerToDistance: number;
        outerFromDistance: number;
        outerToDistance: number;
        fromInnerOffset: number;
        fromOffset: number;
        fromOuterOffset: number;
        toInnerOffset: number;
        toOffset: number;
        toOuterOffset: number;
        protected _contents: Types<ContentNode>;
        protected _openings: Types<OpeningNode>;
        protected _spatialSurfaces: Types<WallSurfaceSpatialNode>;
        element: WallElement;
        typeCd: WallTypeEnum;
        isLoadBearing: boolean;
        pattern: string;
        statusHalfwall: boolean;
        coedge: CowallNode;
        from: WallPointNode;
        to: WallPointNode;
        protected _geometry: WallGeometry;
        brep: BrepBody;
        private __wallShapeCache;
        constructor();
        get contents(): Types<ContentNode>;
        get openings(): Types<OpeningNode>;
        get spatialSurfaces(): Types<WallSurfaceSpatialNode>;
        get fromJoinner(): WallJoinnerNode;
        get toJoinner(): WallJoinnerNode;
        get geometry(): WallGeometry;
        isFromPoint(point: WallPointNode): boolean;
        isConnectFromPoint(point: WallPointNode): boolean;
        isConnectToPoint(point: WallPointNode): boolean;
        isToPoint(point: WallPointNode): boolean;
        isOrthogonal(): boolean;
        beforBuildShape(): boolean;
        buildShape(): void;
        fetchCowalls(targets?: Types<CowallNode>, excludes?: Types<CowallNode>): Types<CowallNode>;
        fetchRooms(targets?: Types<RoomNode>): Types<RoomNode>;
        fetchHostInfos(targets?: Types<ContentHostInfo>): Types<ContentHostInfo>;
        hasContent(): boolean;
        hasOpening(): boolean;
        fetchContents(targets?: Types<ContentNode>): Types<ContentNode>;
        forEachContent(callback: Function, scope?: any): void;
        addContent(entity: DataNode): void;
        removeContent(entity: any): void;
        contentsAssignTo(host: DataNode): void;
        addChild(entity: DataNode, dispatch?: boolean): void;
        updateBoundary(): void;
        getParentRoom(): RoomNode;
        dirty(recursive?: boolean): void;
        dirtyPoint(recursive?: boolean): void;
        getRadRate(): number;
        get center(): Vector2;
        onFieldChanged(sender: any, event: DataNodeFieldEvent): void;
        innerDump(info: StringBuffer, level: number): void;
        debugValid(context?: any): void;
        isBelongTo(spaceType: SpaceTypeEnum): boolean;
        toMath(): SingleCurve2d;
        getLoclalMatrix(): Matrix4;
        getOpenings(): Array<OpeningNode>;
        getFaceByDataAndName(face: BrepFace): WallSurfaceSpatialNode;
        dispose(): void;
        static create(document: Document): WallNode;
    }
    export type WallNodeMap = {
        [key: string]: WallNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { BrepFace } from 'foundation/runtime/geometry/brep/Brep';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SurfaceStructure } from 'foundation/data/common/structure/geometric/SurfaceStructure';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    export class WallSurfaceSpatialNode extends SurfaceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_SURFACE_TYPE_CD: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_WALL: string;
        static FIELD_SURFACES: string;
        static FIELD_SURFACE_SOURCE: string;
        static FIELD_SURFACE_NAME: string;
        static FIELD_IDENTIFIER: string;
        static FIELD_MOLDINGS: string;
        optionTechnologyValid: boolean;
        surfaceTypeCd: WallSurfaceTypeEnum;
        spaceDistance: number;
        workDistance: number;
        wall: WallNode;
        surfaces: Types<SurfaceStructure>;
        surfaceSource: ContentNode;
        surfaceName: string;
        identifier: number;
        protected _moldings: Types<ContentInstanceNode>;
        brepFaces: Array<BrepFace>;
        brepFaceInit: boolean;
        isOutside: boolean;
        constructor();
        get moldings(): Types<ContentInstanceNode>;
        canEdit(): boolean;
        dispose(): void;
        static create(document: Document): WallSurfaceSpatialNode;
    }
    export type WallSurfaceSpatialNodeMap = {
        [key: string]: WallSurfaceSpatialNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/BeamNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { BrepFace } from 'foundation/runtime/geometry/brep/Brep';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { BeamComponentElement } from 'sk/data/family/database/architecture/element/BeamComponentElement';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { BeamElement } from "sk/data/scheme/database/floorplan/element/BeamElement";
    import { BeamGeometry } from "sk/data/scheme/database/floorplan/model/geometry/BeamGeometry";
    import { WallSurfaceSpatialNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode";
    export class BeamNode extends FamilyInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_LEFT_WORK_DISTANCE: string;
        static FIELD_RIGHT_WORK_DISTANCE: string;
        static FIELD_BOTTOM_WORK_DISTANCE: string;
        leftWorkDistance: number;
        rightWorkDistance: number;
        bottomWorkDistance: number;
        element: BeamComponentElement | BeamElement;
        fromX: number;
        fromY: number;
        toX: number;
        toY: number;
        protected _geometry: BeamGeometry;
        height3d: number;
        brep: BrepBody;
        constructor();
        setup(): void;
        getHost(): any;
        onFieldChanged(sender: any, event: DataNodeFieldEvent): void;
        computeScaleX(): void;
        changePosition(dx: number, dy: number): void;
        get geometry(): BeamGeometry;
        beforBuildShape(): boolean;
        dirtySelf(): void;
        getFaceByDataAndName(face: BrepFace): WallSurfaceSpatialNode;
        dispose(): void;
        static create(document: Document): BeamNode;
    }
    export type BeamNodeMap = {
        [key: string]: BeamNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/util/GeometryNodeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    export class GeometryNodeUtil {
        static filterNerghborWalls(cowalls: Types<CowallNode>, filterCowalls: Types<CowallNode>, room: RoomNode): Types<CowallNode>;
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/CowallNodeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { CowallGeometryInfo } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryInfo";
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    export interface WallLineInfo {
        primitiveWall: any[];
        primitiveSpace: {
            primitiveSpaceOuterLineFrom: any;
            primitiveSpaceOuterLineTo: any;
            primitiveSpaceInnerLineTo: any;
            primitiveSpaceInnerLineFrom: any;
        };
        primitiveWork: {
            primitiveWorkOuterLineFrom: any;
            primitiveWorkOuterLineTo: any;
            primitiveWorkInnerLineTo: any;
            primitiveWorkInnerLineFrom: any;
        };
    }
    export class CowallNodeUtil {
        static getWallDimension(cowall: CowallNode): any;
        static getInnerDimension(walls: Array<CowallNode>): any;
        static getPrevCowalls(cowall: CowallNode): Types<CowallNode>;
        static getNextCowalls(cowall: CowallNode): Types<CowallNode>;
        static getInnerDimension_update(point: Value2, info: any, cowalls: Types<CowallNode>): any;
        static getWallGeometryInfo(cowall: CowallNode): any;
        static computeColumnCowallLine(cowallPoints: Array<Vector2>, cowall: CowallNode, withoutFlue?: boolean): {
            columnInnerLine: Array<Array<Vector2>>;
        };
        protected static sortColumns(start: Vector2, columns: Array<ColumnNode>): ColumnNode[];
        static isMainDockCowall(): any;
        static makeColumnsInnerLine(cowallPoints: Array<Vector2>, innerColumns: Array<ColumnNode>, withoutFlue?: boolean): Vector2[][];
        static makeColumnsOuterLine(cowall: CowallNode, outerColumns: Array<ColumnNode>): any[];
        private static buildOpeningPointInCowall;
        private static pointsSortByFrom;
        static projectionLine(line: Line2, contentPoints: Vector2[], out?: boolean): Line2;
        static cullCowall(cowall: CowallNode, openings: Array<OpeningNode>): {
            cullInnerLines: Line2[];
            cullOuterLines: Line2[];
        };
        static findCowallInLine(cowall: CowallNode, cowalls?: Array<CowallNode>): Array<CowallNode>;
        static findWallsInLine(cowall: CowallNode, sameWidth?: boolean): Array<CowallNode>;
        static testCowallInSameLine(cowall1: CowallNode, cowall2: CowallNode, sameWidth?: boolean): boolean;
        static computeWallLine(cowall: CowallNode, options?: any): WallLineInfo;
        static computeInnerLineNormal(cowall: CowallNode): Vector2;
        static computeOuterLineNormal(cowall: CowallNode): Vector2;
        static makeLineByDirection(start: Vector2, end: Vector2, offset: number, direction: Vector2): Line2;
        static getInnerNormal(cowall: CowallNode): Vector2;
        static getOuterNormal(cowall: CowallNode, matrix?: Matrix4): Vector2;
        static getCowallSurface(cowall: CowallNode): WallSurfaceNode;
        static computeSingleRoomCowallGeometry(cowall: CowallNode, geometryInfo?: CowallGeometryInfo, room?: RoomNode): CowallGeometryInfo;
        static computeSingleRoomCowallGeometry1(cowall: CowallNode, geometryInfo?: CowallGeometryInfo, room?: RoomNode): CowallGeometryInfo;
        static getCoWallTotalLine2(wallsurface: WallSurfaceNode): Line2;
        static getWallSurfaceBeamBounds(wallsurface: WallSurfaceNode): Array<BeamToWallPara>;
        private static getParallelBeamInnerRate;
        private static getParallelBeamPosXInWall;
    }
    export class BeamToWallPara {
        pos: Vector2;
        length: number;
        width: number;
        height: number;
        innerRate: number;
        beamAccordateLine: Line2;
        rotation: number;
        bVertical: boolean;
        bHeritional: boolean;
        constructor();
        setBeamData(beam: BeamNode): void;
        setBeamSize(beamLength: number, beamWidht: number, beamHeight: number): void;
        setBeamAccordateLineData(startPointX: number, startPointY: number, endPointX: number, endPointY: number): void;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/FloorplanUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { LengthUnitEnum } from 'cross/runtime/international/unit/LengthUnitEnum';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ConfigReferenceStructure } from 'foundation/data/common/structure/ConfigReferenceStructure';
    import { CeilingComponentElement } from 'sk/data/family/database/architecture/element/CeilingComponentElement';
    import { FloorComponentElement } from 'sk/data/family/database/architecture/element/FloorComponentElement';
    import { WallComponentElement } from 'sk/data/family/database/architecture/element/WallComponentElement';
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    type WallInfo = {
        from: Vector2;
        to: Vector2;
        width?: number;
        offset?: number;
    };
    export class FloorplanUtil {
        static defaultFloorplanComponent: any;
        static defaultRoom: ConfigReferenceStructure;
        static defaultRoomFillConfig: any;
        static defaultRoomFamilyInfoId: any;
        static defaultWallFamilyInfoId: any;
        static defaultWallSurfaceFamilyInfoId: any;
        static defaultCeilingFamilyInfoId: any;
        static defaultCeilingSurfaceFamilyInfoId: any;
        static defaultFloorFamilyInfoId: any;
        static defaultFloorSurfaceFamilyInfoId: any;
        static defaultWall: ConfigReferenceStructure;
        static defaultWallFillConfig: any;
        static defaultWallComponent: WallComponentElement;
        static defaultWallSurface: ConfigReferenceStructure;
        static defaultCeiling: ConfigReferenceStructure;
        static defaultCeilingComponent: CeilingComponentElement;
        static defaultCeilingSurface: ConfigReferenceStructure;
        static defaultCeilingSurfaceMaterialConfig: any;
        static defaultFloor: ConfigReferenceStructure;
        static defaultFloorComponent: FloorComponentElement;
        static defaultFloorSurface: ConfigReferenceStructure;
        static defaultFloorSurfaceMaterialConfig: any;
        static defaultBeam: ConfigReferenceStructure;
        static defaultColumn: ConfigReferenceStructure;
        static globalWallWidth: any;
        static defaultArea: ConfigReferenceStructure;
        static defaultAreaFamilyInfoId: any;
        static getDefaultLengthPrecisionDigits(unitCd: LengthUnitEnum): number;
        private static getDocumentComponentAsync;
        private static makeMaterialConfig;
        private static _init;
        static initDefaultFloorplanAsync(context: ContextObject): Promise<void>;
        static getDefaultFamilyInfoIdAsync(context: ContextObject, familyId: string): Promise<string>;
        static calculateBounds(node: BrepNode, observerMatrix?: Matrix4): any;
        static dimensionSuggestion(node: BrepNode, filterarray?: Array<Function>): Types<any>;
        private static isInRoom;
        private static contentFilter;
        private static checkContent;
        protected static reflectionContent(content: ContentNode, bounds: any, ojbks: Types<any>): void;
        protected static simplifyPoints(points: Types<Vector2>): Types<Vector2>;
        protected static findReflectionLines(position: Vector2, bounds: any): any;
        static moveVector2(position: Vector2, direction: Vector2, distance: number): Vector2;
        private static processDimension;
        private static sortPoints;
        private static processValue;
        private static processValue1;
        private static updateValue;
        private static computeLevelingWallCullArea;
        static columnWallSurfaceDistanceTest(node: ColumnNode, surface: WallSurfaceNode, tolerance?: number): boolean;
        private static computeColumnWallSurfaceArea;
        static computeWallSurfaceArea(floorplan: FloorplanNode): number;
        static computeOpeningArea(floorplan: FloorplanNode): number;
        static computeColumnWallArea(floorplan: FloorplanNode): number;
        private static computeRoomColumnArea;
        static computeOriginWallArea(floorplan: FloorplanNode): number;
        static computeFloorArea(floorplan: FloorplanNode): number;
        static computeCeilingArea(floorplan: FloorplanNode): number;
        private static computeFlatXYArea;
        static generateFloorplanOutline(floorplan: FloorplanNode): Array<{
            polygon: Vector2[];
            holes: Vector2[][];
        }>;
        static parsePolygonsToWallsInfo(polygons: Value2[][]): {
            points: Vector2[];
            wallInfos: WallInfo[];
        };
        private static computeWallCenterLine;
        private static setCenterOffset;
        private static sortOffsetInfo;
        private static appendSameCenterLinesLoop;
        private static getWallsInfoByMatchLinesMap;
        private static pushPoint;
        private static getWallPointByLines;
        private static getMatchLinesMap;
        private static getLineGapsOverlapDistance;
        private static getWallPolygonLinesByPolygons;
        private static removeInvalidLines;
        private static getMatchLineInfosByLine;
        private static isPointOnLineGap;
    }
}
declare module "sk/data/scheme/database/floorplan/model/FloorplanNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode, ContentNodeMap } from 'foundation/data/common/model/brep/ContentNode';
    import { GroupNodeMap } from 'foundation/data/common/model/brep/GroupNode';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { SpaceShapeNode } from "sk/data/scheme/database/furniture/model/SpaceShapeNode";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { ColorThemeEnum } from "sk/data/scheme/database/floorplan/model/ColorThemeEnum";
    import { CowallNode, CowallNodeMap } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode, RoomNodeMap } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallNode, WallNodeMap } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    import { WallSurfaceNode, WallSurfaceNodeMap } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    export class FloorplanNode extends BrepNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        optionTechnologyValid: boolean;
        structureOpacity: number;
        element: FloorplanElement;
        protected spaceShapeNodes: Types<SpaceShapeNode>;
        constructor();
        static FIELD_COLOR_THEME_CD: string;
        static FIELD_BACKGROUND_COLOR: string;
        static FIELD_ENVIRONMENT_COLOR: string;
        colorThemeCd: ColorThemeEnum;
        backgroundColor: number;
        environmentColor: number;
        globalWallWidth: number;
        globalWallHeight3d: number;
        activeCamera: ObserverNode;
        activeRenderCameraCd: String;
        walls: WallNodeMap;
        cowalls: CowallNodeMap;
        rooms: RoomNodeMap;
        contents: ContentNodeMap;
        surfaces: WallSurfaceNodeMap;
        groups: GroupNodeMap;
        loops: any;
        _boundDirty: boolean;
        isEmpty(): boolean;
        fetchPoints(targets?: Types<WallPointNode>): Types<WallPointNode>;
        private addPoint;
        fetchAllPoints(targets?: Types<WallPointNode>): Types<WallPointNode>;
        fetchJoinners(targets?: Types<WallJoinnerNode>): Types<WallJoinnerNode>;
        fetchWallSurfaces(targets?: Types<WallSurfaceNode>): Types<WallSurfaceNode>;
        fetchOpenCowalls(targets?: Types<CowallNode>): Types<CowallNode>;
        fetchCowalls(targets?: Types<CowallNode>): Types<CowallNode>;
        fetchWalls(targets?: Types<WallNode>): Types<WallNode>;
        fetchRoomWalls(targets?: Types<WallNode>): Types<WallNode>;
        fetchRooms(targets?: Types<RoomNode>): Types<RoomNode>;
        fetchContents(targets?: Types<ContentNode>): Types<ContentNode>;
        fetchContentsByType(type: Function, targets?: Types<ContentNode>): Types<ContentNode>;
        forEachRoom(callback: Function, owner?: any): void;
        forEachContent(callback: any, owner?: any): void;
        forEachGroup(callback: any, owner?: any): void;
        getArea(): number;
        buildShape(): void;
        addChild(entity: DataNode, dispatch?: boolean): void;
        removeChild(entity: DataNode, dispatch?: boolean, dispose?: boolean): void;
        protected handleLogicNode(entity: DataNode, addOrRemove: boolean): void;
        refreshRoomIdentifier(): void;
        refreshRoomIdentifier1(): void;
        updateBoundary(): void;
        getSpaceShapeNodeByIds(addIds: string[], cutIds: string[]): SpaceShapeNode;
        reset(): void;
        protected innerDump(info: StringBuffer, level: number): void;
        clear(): void;
        debugValid(): void;
        dispose(): void;
        static create(document: Document): FloorplanNode;
    }
    export type FloorplanNodeMap = {
        [key: string]: FloorplanNode;
    };
}
declare module "sk/data/scheme/model/SchemeConstants" {
    export class SchemeConstants {
        static SCENE_SIZE: number;
        static GRID_SPACING: number;
        static GRID_MAJOR_LINE_SPACE: number;
        static FIRSTPERSON_CAMERA_HEIGHT: number;
        static FIRSTPERSON_CAMERA_TARGET_X: number;
        static FIRSTPERSON_CAMERA_TARGET_Y: number;
        static FIRSTPERSON_CAMERA_TARGET_Z: number;
        static FIRSTPERSON_CAMERA_FOV: number;
        static FIRSTPERSON_CAMERA_PITCH: number;
        static FIRSTPERSON_CAMERA_HORIZONTAL_FOV_MIN: number;
        static FIRSTPERSON_CAMERA_HORIZONTAL_FOV_MAX: number;
        static AERIALVIEW_CAMERA_ALPHA: number;
        static AERIALVIEW_CAMERA_BELTA: number;
        static AERIALVIEW_CAMERA_RADIUS: number;
        static AERIALVIEW_CAMERA_X: number;
        static AERIALVIEW_CAMERA_Y: number;
        static AERIALVIEW_CAMERA_Z: number;
        static AERIALVIEW_CAMERA_TARGET_X: number;
        static AERIALVIEW_CAMERA_TARGET_Y: number;
        static AERIALVIEW_CAMERA_TARGET_Z: number;
        static AERIALVIEW_CAMERA_LENGTH: number;
        static AERIALVIEW_CAMERA_FOV: number;
        static AERIALVIEW_CAMERA_PITCH: number;
        static AERIALVIEW_CAMERA_HORIZONTAL_FOV_MIN: number;
        static AERIALVIEW_CAMERA_HORIZONTAL_FOV_MAX: number;
        static AERIALVIEW_CAMERA_DISTANCE: number;
        static AERIALVIEW_CAMERA_MAX_DISTANCE: number;
        static AERIALVIEW_CAMERA_MIN_DISTANCE: number;
        static ORTHOGANOL_CAMERA_HEIGHT: number;
        static ORTHOGANOL_CAMERA_TARGET_X: number;
        static ORTHOGANOL_CAMERA_TARGET_Y: number;
        static ORTHOGANOL_CAMERA_TARGET_Z: number;
        static RENDER_CAMERA_HEIGHT: number;
        static RENDER_CAMERA_TARGET_X: number;
        static RENDER_CAMERA_TARGET_Y: number;
        static RENDER_CAMERA_TARGET_Z: number;
        static RENDER_CAMERA_FOV: number;
        static RENDER_CAMERA_PITCH: number;
        static RENDER_CAMERA_HORIZONTAL_FOV_MIN: number;
        static RENDER_CAMERA_HORIZONTAL_FOV_MAX: number;
    }
}
declare module "sk/data/scheme/model/SchemeBlueprintNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Octree } from 'foundation/runtime/geometry/Octree';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { BackgroundNode } from 'sk/data/family/model/assistant/BackgroundNode';
    import { CompassNode } from 'sk/data/family/model/assistant/CompassNode';
    import { GridNode } from 'sk/data/family/model/assistant/GridNode';
    import { UnderlayNode } from 'sk/data/family/model/assistant/UnderlayNode';
    import { FamilyBaseBlueprintNode } from 'sk/data/family/model/FamilyBaseBlueprintNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    export class SchemeBlueprintNode extends FamilyBaseBlueprintNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_COMPASS: string;
        static FIELD_GRID: string;
        static FIELD_UNDERLAY: string;
        static FIELD_BACKGROUND: string;
        compass: CompassNode;
        grid: GridNode;
        underlay: UnderlayNode;
        background: BackgroundNode;
        static FIELD_ACTIVE_FLOORPLAN: string;
        activeFloorplan: FloorplanNode;
        protected _octree: Octree<ContentNode>;
        protected _firstPersonCamera: ObserverViewNode;
        constructor();
        get octree(): Octree<ContentNode>;
        reset(): void;
        saveFirstPersonCamera(): void;
        clear(): void;
        dispose(): void;
        static create(document: Document): SchemeBlueprintNode;
    }
    export type SchemeBlueprintNodeMap = {
        [key: string]: SchemeBlueprintNode;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleBathroomElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleBathroomElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_CAVITY: string;
        static FIELD_FINISH: string;
        static FIELD_OUTLINE: string;
        cavity: number;
        finish: number;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleBathroomElementMap = {
        [key: string]: AssembleBathroomElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomAreaElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomAreaElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        static FIELD_WORK_HEIGHT: string;
        outline: PolygonSurfaceStructure;
        workHeight: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomAreaElementMap = {
        [key: string]: BathroomAreaElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { AssembleBathroomElement } from "sk/data/scheme/database/pattern/element/AssembleBathroomElement";
    export class BathroomElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_CLOCKWISE: string;
        static FIELD_OUTLINE: string;
        clockwise: boolean;
        outline: PolygonSurfaceStructure;
        static CONTENT_DECORATE_CODE: string;
        static FINISH: string;
        finish: number;
        static FIELD_CAVITY: string;
        cavity: number;
        constructor();
        get assembleBathroomElement(): AssembleBathroomElement;
        protected checkInRoom(room: RoomElement): boolean;
        getRoomElements(): InstanceElement[];
        reset(): void;
        dispose(): void;
    }
    export type BathroomElementMap = {
        [key: string]: BathroomElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomFloorDryElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomFloorDryElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_FINISH: string;
        static FIELD_FLOORDRY_PLANK_INFO_ID: string;
        static FIELD_FLOORDRY_SEAM_INFO_ID: string;
        static FIELD_FLOORDRY_SURFACE_INFO_ID: string;
        static FIELD_GAP: string;
        static FIELD_OUTLINE_GAP: string;
        static FIELD_OFFSET_X: string;
        static FIELD_OFFSET_Y: string;
        static FIELD_SEAM_THICKNESS: string;
        static FIELD_START_X: string;
        static FIELD_START_Y: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_TECHNOLOGY_TYPE: string;
        static FIELD_TILE_LENGTH_X: string;
        static FIELD_TILE_LENGTH_Y: string;
        static FIELD_THICKNESS: string;
        static FIELD_POLYGON: string;
        static FIELD_POLYGONS: string;
        static FIELD_OUTLINE: string;
        baseThickness: number;
        finish: number;
        floordryPlankInfoId: string;
        floordrySeamInfoId: string;
        floordrySurfaceInfoId: string;
        gap: number;
        outlineGap: number;
        offsetX: number;
        offsetY: number;
        seamThickness: number;
        startX: number;
        startY: number;
        surfaceThickness: number;
        technologyType: string;
        tileLengthX: number;
        tileLengthY: number;
        thickness: number;
        polygon: SectionSurfaceStructure;
        polygons: Types<SectionSurfaceStructure>;
        outline: PolygonSurfaceStructure;
        constructor();
        static PLANK_DECORATE_CODE: string;
        static FLOOR_TILE_CODE: string;
        static DEFAULT_EDGE_FINISH: number;
        reset(): void;
        dispose(): void;
    }
    export type BathroomFloorDryElementMap = {
        [key: string]: BathroomFloorDryElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomFloorElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomFloorElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_FINISH_HEIGHT: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        finishHeight: number;
        outline: PolygonSurfaceStructure;
        constructor();
        get thickness(): string;
        set thickness(value: string);
        reset(): void;
        dispose(): void;
    }
    export type BathroomFloorElementMap = {
        [key: string]: BathroomFloorElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomFloorWetElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomFloorWetElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SEAM_THICKNESS: string;
        static FIELD_FINISH: string;
        static FIELD_FLOOR_WET_PLANK_INFO_ID: string;
        static FIELD_FLOOR_WET_SURFACE_INFO_ID: string;
        static FIELD_FLOOR_WET_SEAM_INFO_ID: string;
        static FIELD_OUTLINE: string;
        static FIELD_OUTLINE_GAP: string;
        static FIELD_POLYGON: string;
        static FIELD_TECHNOLOGY_TYPE: string;
        static FIELD_GAP: string;
        static FIELD_START_X: string;
        static FIELD_START_Y: string;
        static FIELD_TILE_LENGTH_X: string;
        static FIELD_TILE_LENGTH_Y: string;
        static FIELD_OFFSET_X: string;
        static FIELD_OFFSET_Y: string;
        baseThickness: number;
        surfaceThickness: number;
        seamThickness: number;
        finish: number;
        floorWetPlankInfoId: string;
        floorWetSurfaceInfoId: string;
        floorWetSeamInfoId: string;
        outline: PolygonSurfaceStructure;
        outlineGap: number;
        polygon: SectionSurfaceStructure;
        technologyType: string;
        gap: number;
        startX: number;
        startY: number;
        tileLengthX: number;
        tileLengthY: number;
        offsetX: number;
        offsetY: number;
        static DEFAULT_EDGE_FINISH: number;
        constructor();
        get thickness(): string;
        set thickness(value: string);
        reset(): void;
        dispose(): void;
    }
    export type BathroomFloorWetElementMap = {
        [key: string]: BathroomFloorWetElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomShowerElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomShowerElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomShowerElementMap = {
        [key: string]: BathroomShowerElement;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        private _workPolygon;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomNode;
    }
    export type BathroomNodeMap = {
        [key: string]: BathroomNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/util/BathroomNodeUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { WallSurfaceLineInfo } from "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomElement } from "sk/data/scheme/database/pattern/element/BathroomElement";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    export class BathroomNodeUtil {
        static findBathoomElement(room: RoomNode): BathroomElement;
        static findRoomElement(bathroom: BathroomNode): RoomElement;
        static getBathroomWorkPolygon(room: RoomNode): Vector2[][];
        static getWorkPolygonInfosFromAreaPolygon(room: RoomNode): Array<Array<WallSurfaceLineInfo>>;
        static getBathroomWorkPolygonInfos(room: RoomNode): Array<Array<WallSurfaceLineInfo>>;
        private static getWallsInnerPolygonByAreaElement;
    }
}
declare module "sk/data/scheme/database/pattern/node/AssembleRoomNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleRoomNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleRoomNode;
    }
    export type AssembleRoomNodeMap = {
        [key: string]: AssembleRoomNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/util/RoomNodeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ByteStream } from 'cross/runtime/lang/stream/ByteStream';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    import { AssembleRoomElement } from "sk/data/scheme/database/pattern/element/AssembleRoomElement";
    import { AssembleRoomNode } from "sk/data/scheme/database/pattern/node/AssembleRoomNode";
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { WallSurfaceLineInfo } from "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil";
    type BeamColumnInfo = {
        beams: Types<BeamNode>;
        columns: Types<ColumnNode>;
    };
    export class RoomNodeUtil {
        static isValidRoomPoints(points: Array<Value2>): boolean;
        static getRoomWorkPolygonInfos(room: RoomNode): Array<Array<WallSurfaceLineInfo>>;
        static findRoomByPoint(floorplan: FloorplanNode, point: Value2 | Value3): RoomNode;
        static findRoomByAssembleRoom(assemble: AssembleRoomNode): RoomNode;
        static findRoomByAssembleRoomElement(assemble: AssembleRoomElement): RoomNode;
        static findRoomContentsByFamilyType(roomNode: RoomNode, familyTypeCode: string): Array<FamilyInstanceNode>;
        static findRoomOfContent(content: ContentNode): RoomNode;
        static findAllContentsInRoom(room: RoomNode): Array<ContentNode>;
        static findColumnBeamOfRoom(room: RoomNode): BeamColumnInfo;
        static generateDocumentByRoom(room: RoomNode, document?: SchemeDocument, documentBinary?: ByteStream): any;
        static generateDocumentOnlyFloorplan(document: SchemeDocument, documentBinary?: ByteStream): SchemeDocument;
        static getRoomOutline(room: RoomNode, typeCd?: string): Vector2[];
        private static validWall;
        static getRoomValidSurface(room: RoomNode): Types<WallSurfaceNode>;
        static isBelongsRoom(cowall: CowallNode, room: RoomNode): boolean;
        private static setCoWallsCode;
        static setRoomCowallCode(room: RoomNode, northDir?: Vector2): void;
        static updateRelationsNodePolygonDirty(element: ContentInstanceElement): void;
        static isRoomIncludeAssembleRoom(room: RoomNode): AssembleRoomElement;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/RoomGeometry" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { GeometryObject } from "sk/data/scheme/database/floorplan/model/geometry/GeometryObject";
    export type PolygonLineElementInfo = Array<{
        line: Line2;
        element: ContentInstanceElement;
    }>;
    export class RoomGeometry extends GeometryObject {
        node: RoomNode;
        protected _positions: Types<Vector2>;
        private _centerPositions;
        protected _center: Vector2;
        innerPolygonDirty: boolean;
        protected _innerPolygons: Array<Array<Vector2>>;
        protected _innerPolygonInfos: Array<PolygonLineElementInfo>;
        ceilingPolygonDirty: boolean;
        constructor();
        get center(): Vector2;
        get positions(): Types<Vector2>;
        get centerPositions(): Types<Vector2>;
        get innerPolygon(): Array<Vector2>;
        get innerPolygons(): Array<Array<Vector2>>;
        get innerPolygonInfos(): Array<PolygonLineElementInfo>;
        updateInnerPolygons(): void;
        isValid(): boolean;
        compute(): void;
        clear(): void;
        dispose(flag?: boolean): void;
    }
}
declare module "sk/data/scheme/database/floorplan/element/RoomElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SpaceTypeEnum } from 'foundation/data/common/define/SpaceTypeEnum';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { AreaElement } from 'sk/data/family/element/brep/AreaElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { RoomGeometry } from "sk/data/scheme/database/floorplan/model/geometry/RoomGeometry";
    import { CeilingElement } from "sk/data/scheme/database/floorplan/element/CeilingElement";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { DoorElement } from "sk/data/scheme/database/floorplan/element/DoorElement";
    import { FloorElement } from "sk/data/scheme/database/floorplan/element/FloorElement";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    import { WindowElement } from "sk/data/scheme/database/floorplan/element/WindowElement";
    export class RoomElement extends AreaElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_REFERENCE_INFO_ID: string;
        static FIELD_HEIGHT3D: string;
        static FIELD_CEILING: string;
        static FIELD_CEILING_HEIGHT3D: string;
        static FIELD_FLOOR: string;
        static FIELD_FLOOR_HEIGHT3D: string;
        static FIELD_ROOT: string;
        static FIELD_RELATIONS: string;
        static FIELD_CUSTOM_AREA: string;
        static FIELD_CONTENTS: string;
        static FIELD_TYPE_NAME: string;
        static FIELD_ROOM_NAME: string;
        optionTechnologyValid: boolean;
        referenceInfoId: string;
        height3d: number;
        ceiling: CeilingElement;
        ceilingHeight3d: number;
        floor: FloorElement;
        floorHeight3d: number;
        root: CowallElement;
        protected _relations: Types<RelationElement>;
        customArea: string;
        protected _contents: Types<ContentElement>;
        typeName: string;
        roomName: string;
        structure: SchemeFamilyStructure;
        singleRoomMode: boolean;
        dimensionOffsetX: number;
        dimensionOffsetY: number;
        constructor();
        get relations(): Types<RelationElement>;
        get contents(): Types<ContentElement>;
        typeCd: SpaceTypeEnum;
        protected _geometry: RoomGeometry;
        addRelation(relation: RelationElement): void;
        removeRelation(relation: RelationElement): void;
        get floorplan(): FloorplanElement;
        get cowalls(): Types<CowallElement>;
        getCowallCount(): number;
        fetchPoints(target?: Types<WallPointElement>): Types<WallPointElement>;
        fetchPolygonPoints(target?: Types<WallPointElement>): Array<WallPointElement>;
        fetchAllPoints(target?: Types<WallPointElement>): Types<WallPointElement>;
        fetchJoinners(target?: Types<WallJoinnerElement>): Types<WallJoinnerElement>;
        fetchPolygon(target?: Types<WallPointElement>): Types<WallPointElement>;
        fetchJoinner(target?: Types<WallJoinnerElement>): Types<WallJoinnerElement>;
        fetchWalls(target?: Types<WallElement>): Types<WallElement>;
        fetchCowalls(target?: Types<CowallElement>): Types<CowallElement>;
        fetchConnectCowalls(target?: Types<CowallElement>): Types<CowallElement>;
        fetchConnectRooms(target?: Types<RoomElement>): Types<RoomElement>;
        detachCowalls(): void;
        isAutoLayoutEnable(): boolean;
        forEachContent(callback: Function, owner?: any): void;
        protected innerDump(info: StringBuffer, level: number): void;
        debugValid(context?: any): void;
        getWindowNumber(): number;
        getWindowList(): Array<WindowElement>;
        getDoorList(): Array<DoorElement>;
        getOpeningsByType(clazz?: any): any[];
        toDisplay(): string;
        static identifierSorter(room1: RoomElement, room2: RoomElement): number;
        addContent(content: ContentElement): void;
        removeContent(content: ContentElement): void;
        setHeight3d(value: number): void;
        setCowallFlag(code: number, value: boolean): void;
        getBaseboard(surfaceCd: WallSurfaceTypeEnum): any;
        getCornice(surfaceCd: WallSurfaceTypeEnum): any;
        collisionDetect(room: RoomElement, margin?: number): boolean;
        moveContentOffset(x: number, y: number, z: number): void;
        moveOffset(x: number, y: number, z?: number): void;
        findCowallWithPointOn(cowalls: any, point1: WallPointElement, point2: WallPointElement): CowallElement;
        validate(): void;
        snapTo(room: RoomElement): Vector2;
        reset(): void;
        dispose(): void;
    }
    export type RoomElementMap = {
        [key: string]: RoomElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/FloorplanElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentElement, ContentElementMap } from 'sk/data/family/element/brep/ContentElement';
    import { GroupElement } from 'sk/data/family/element/brep/GroupElement';
    import { ColorThemeEnum } from "sk/data/scheme/database/floorplan/model/ColorThemeEnum";
    import { CowallElement, CowallElementMap } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { RoomElement, RoomElementMap } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallElement, WallElementMap } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    export class FloorplanElement extends BrepElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_JOINNERS: string;
        static FIELD_GROUPS: string;
        optionTechnologyValid: boolean;
        protected _joinners: Types<WallJoinnerElement>;
        protected _groups: Types<GroupElement>;
        static FIELD_COLOR_THEME_CD: string;
        static FIELD_BACKGROUND_COLOR: string;
        static FIELD_ENVIRONMENT_COLOR: string;
        colorThemeCd: ColorThemeEnum;
        backgroundColor: number;
        environmentColor: number;
        globalWallWidth: number;
        globalWallHeight3d: number;
        activeCamera: ObserverNode;
        activeRenderCameraCd: String;
        walls: WallElementMap;
        cowalls: CowallElementMap;
        rooms: RoomElementMap;
        contents: ContentElementMap;
        loops: any;
        protected _boundDirty: boolean;
        constructor();
        get joinners(): Types<WallJoinnerElement>;
        get groups(): Types<GroupElement>;
        isEmpty(): boolean;
        fetchPoints(targets?: Types<WallPointElement>): Types<WallPointElement>;
        private addPoint;
        fetchAllPoints(targets?: Types<WallPointElement>): Types<WallPointElement>;
        fetchJoinners(targets?: Types<WallJoinnerElement>): Types<WallJoinnerElement>;
        fetchOpenCowalls(targets?: Types<CowallElement>): Types<CowallElement>;
        fetchCowalls(targets?: Types<CowallElement>): Types<CowallElement>;
        fetchWalls(targets?: Types<WallElement>): Types<WallElement>;
        fetchRoomWalls(targets?: Types<WallElement>): Types<WallElement>;
        fetchRooms(targets?: Types<RoomElement>): Types<RoomElement>;
        fetchGroups(targets?: Types<GroupElement>): Types<GroupElement>;
        fetchContents(targets?: Types<ContentElement>): Types<ContentElement>;
        forEachRoom(callback: Function, owner?: any): void;
        forEachContent(callback: any, owner?: any): void;
        forEachGroup(callback: any, owner?: any): void;
        addChild(element: BrepElement): void;
        removeChild(element: BrepElement): void;
        refreshRoomIdentifier(): void;
        testStatusFloorplan(): boolean;
        dirtyFloorplan(): void;
        protected innerDump(info: StringBuffer, level: number): void;
        clear(): void;
        debugValid(): void;
        reset(): void;
        dispose(): void;
    }
    export type FloorplanElementMap = {
        [key: string]: FloorplanElement;
    };
}
declare module "sk/data/scheme/database/scheme/element/SchemeStructureElement" {
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    export class SchemeStructureElement extends StructureElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_ACTIVE_FLOORPLAN: string;
        static FIELD_CAMERAS: string;
        static FIELD_PRESET_CAMERAS: string;
        activeFloorplan: FloorplanElement;
        cameras: ContainerElement;
        presetCameras: ContainerElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type SchemeStructureElementMap = {
        [key: string]: SchemeStructureElement;
    };
}
declare module "sk/data/scheme/external/SchemeExternalUtil" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SpecificationFamilyService } from 'sk/data/specification/family/SpecificationFamilyService';
    import { SpecificationFamilyInfoService } from 'sk/data/specification/familyinfo/SpecificationFamilyInfoService';
    import { SpecificationPatternService } from 'sk/data/specification/pattern/SpecificationPatternService';
    import { SpecificationPatternInfoService } from 'sk/data/specification/patterninfo/SpecificationPatternInfoService';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { SchemeLibraryFamilyDocumentService } from "sk/data/scheme/config/SchemeLibraryFamilyDocumentService";
    export type DocumentExternalsOptions = {
        familyInfo?: boolean;
        family?: boolean;
        patternInfo?: boolean;
        pattern?: boolean;
        model?: boolean;
    };
    export class SchemeExternalUtil {
        protected static _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        protected static _specificationFamilyInfoService: SpecificationFamilyInfoService;
        protected static _specificationFamilyService: SpecificationFamilyService;
        protected static _specificationPatternInfoService: SpecificationPatternInfoService;
        protected static _specificationPatternService: SpecificationPatternService;
        protected static _schemeConfigService: SchemeConfigService;
        protected static _modelDocumentService: ModelDocumentService;
        static saveDocumentExternals(context: IContext, document: FamilyDocument, saveFamilyDocument?: boolean): void;
        static saveDocumentExternalsAsync(context: IContext, document: FamilyDocument, options?: DocumentExternalsOptions): Promise<ResultObject>;
        static loadDocumentExternalsAsync(context: IContext, document: FamilyDocument): Promise<ResultObject>;
        static markDocumentExternalsCache(context: IContext): void;
    }
}
declare module "sk/data/scheme/util/SchemeContentUtil" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { AssembleBathroomElement } from "sk/data/scheme/database/pattern/element/AssembleBathroomElement";
    import { AssembleFlatWallElement } from "sk/data/scheme/database/pattern/element/AssembleFlatWallElement";
    import { AssembleLevelingCeilingElement } from "sk/data/scheme/database/pattern/element/AssembleLevelingCeilingElement";
    import { AssembleLevelingFloorElement } from "sk/data/scheme/database/pattern/element/AssembleLevelingFloorElement";
    import { AssembleLevelingWallElement } from "sk/data/scheme/database/pattern/element/AssembleLevelingWallElement";
    export class SchemeContentUtil {
        static assembleTypes: (typeof AssembleLevelingWallElement | typeof AssembleFlatWallElement | typeof AssembleLevelingCeilingElement | typeof AssembleLevelingFloorElement | typeof AssembleBathroomElement)[];
        static setContentComposite(entity: ContentInstanceNode, composite: boolean): boolean;
        static setSchemeSerialNumber(scheme: FamilyDocument): void;
        static copyElementSerialNumber(node: DataNode): void;
        static setNodeSerialNumber(node: DataNode, index: number): number;
        static isAssembleType(element: Element): boolean;
        static getElementSerialNumberMap(element: NestElement, indexMap: any): void;
        static getIndexByIndexMap(index: number, indexMap: any): number;
        static setElementSerialNumber(element: NestElement, indexs: number[], indexMap: any, isAssemble: boolean): void;
    }
}
declare module "sk/data/scheme/model/SchemeDocumentOptions" {
    import { FamilyDocumentOptions } from 'sk/data/family/library/FamilyDocumentOptions';
    export class SchemeDocumentOptions extends FamilyDocumentOptions {
        floorplanRoomHeight3d: number;
        floorplanWallHeight3d: number;
        constructor();
        reset(): void;
    }
}
declare module "sk/data/scheme/model/SchemeFamilyInfoController" {
    import { ConfigController } from 'sk/data/family/element/config/ConfigController';
    export class SchemeFamilyInfoController extends ConfigController {
    }
}
declare module "sk/data/scheme/model/SchemeRelationController" {
    import { DockRelationElement } from 'sk/data/family/element/config/relation/DockRelationElement';
    import { HostRelationElement } from 'sk/data/family/element/config/relation/HostRelationElement';
    import { LinkRelationElement } from 'sk/data/family/element/config/relation/LinkRelationElement';
    import { RelationController } from 'sk/data/family/element/config/relation/RelationController';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { SizeRelationElement } from 'sk/data/family/element/config/relation/SizeRelationElement';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { ContentRelationTypeEnum } from 'sk/data/family/enumeration/ContentRelationTypeEnum';
    export class SchemeRelationController extends RelationController {
        isBrepElement(element: any): boolean;
        addHostRelation(master: any, slave: ContentInstanceElement): HostRelationElement;
        addDockRelation(master: any, slave: ContentInstanceElement): DockRelationElement;
        addLinkRelation(master: any, slave: any, code?: string): LinkRelationElement;
        addAdjustXYZWDHRelation(relation: SizeRelationElement): void;
        removeElementAllRelations(element: any, relationCd?: ContentRelationTypeEnum, recursive?: boolean): void;
        addRelation(relation: RelationElement): void;
        removeRelation(relation: RelationElement): void;
        syncElementRelationsArray(element: any, relations: Array<RelationElement>): void;
        findElementRelationByCode(element: any, code: string): any;
        findLinkedElement(element: any, code?: string): InstanceElement;
        findDockedElement(element: any, code?: string): any;
        findDockRelations(element: BrepElement): Array<any>;
        findLinkRelations(element: BrepElement): Array<any>;
        findDockedElements(element: BrepElement, clazz?: Function): Array<any>;
        findAllLinkedElements(element: any, code?: string): Array<any>;
        removeAllLinekedElements(element: any, code?: string): void;
    }
}
declare module "sk/data/scheme/model/SchemeDocument" {
    import { ByteStream } from 'cross/runtime/lang/stream/ByteStream';
    import { DataStream } from 'cross/runtime/lang/stream/DataStream';
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ObserverViewElement } from 'sk/data/family/element/brep/observer/ObserverViewElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ObserverElement } from 'sk/data/family/element/brep/ObserverElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyPsistentOptions } from 'sk/data/family/library/FamilyPsistentOptions';
    import { SchemeStructureElement } from "sk/data/scheme/database/scheme/element/SchemeStructureElement";
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { SchemeBlueprintNode } from "sk/data/scheme/model/SchemeBlueprintNode";
    import { SchemeDocumentOptions } from "sk/data/scheme/model/SchemeDocumentOptions";
    import { SchemeFamilyInfoController } from "sk/data/scheme/model/SchemeFamilyInfoController";
    import { SchemeRelationController } from "sk/data/scheme/model/SchemeRelationController";
    export class SchemeDocument extends FamilyDocument {
        blueprint: SchemeBlueprintNode;
        reloadBinaryPosition: number;
        protected _relationController: SchemeRelationController;
        protected _familyInfoController: SchemeFamilyInfoController;
        protected constructor();
        get options(): SchemeDocumentOptions;
        get relationController(): SchemeRelationController;
        findElementById(id: string): Element;
        get rootFamilyStructure(): SchemeFamilyStructure;
        get rootStructure(): SchemeStructureElement;
        setup(): void;
        findObserverByType(type: any): ObserverElement;
        findPresetCamera(name: string): ObserverViewElement;
        getObserverByType(type: any): ObserverElement;
        loadPresetCameras(): void;
        protected clearCameraInfo(): void;
        protected createCameraInfo(observerNode: ObserverViewNode): void;
        saveCameras(): void;
        protected loadControllerJson(context: PersistentContext, jconfig: any): void;
        protected loadControllerBinary(context: PersistentContext): void;
        protected loadJsonComplete(context: PersistentContext, jconfig: any): void;
        protected loadBinaryComplete(context: PersistentContext): void;
        private connectTimelineToBrep;
        private connectTimeLineToBrepForBinary;
        protected afterLoad(context: PersistentContext, options?: any): void;
        protected saveControllerJson(context: PersistentContext, jconfig: any): void;
        protected saveControllerBinary(context: PersistentContext): void;
        protected beforeSave(context: PersistentContext, options?: FamilyPsistentOptions): void;
        loadBinary(data: Uint8Array | DataStream, options?: FamilyPsistentOptions): void;
        saveBinary(context?: PersistentContext, options?: FamilyPsistentOptions): ByteStream;
        protected saveJsonMeta(jconfig: any): any;
        clear(): void;
        dumpCount(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/OpeningNodeUtil" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LoopElement } from 'sk/data/family/element/brep/LoopElement';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { DrawingGraphDataDocument } from 'sk/data/family/drawing/DrawingGraphDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { DoorNode } from "sk/data/scheme/database/floorplan/model/DoorNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    export enum HoleTypeEnum {
        Door = "door",
        Window = "window",
        NormalHole = "hole"
    }
    export class OpeningNodeUtil {
        static findOppositeWallSurface(node: DoorNode, wallSurfaceNode: WallSurfaceNode): CowallNode;
        static dirtyRelation(node: OpeningNode): void;
        static getConnectLoop(opening: OpeningNode): LoopElement;
        static getHoleType(opening: ContentInstanceNode): HoleTypeEnum;
        static getOpenningHoles(opening: OpeningNode): Array<OpeningNode>;
        static isEntranceDoor(opening: OpeningNode): boolean;
        static getOpeningNodeGraphDocumentAsync(opening: ContentNode): Promise<DrawingGraphDataDocument>;
        static filterOpening(openings: Array<OpeningNode>, filterFunc: (opeing: OpeningNode) => boolean): Array<OpeningNode>;
        static getWallOfOpening(entity: OpeningNode): WallNode;
        static findRoomsOfOpening(entity: OpeningNode): RoomNode[];
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallLineNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { WallLinePointNode } from "sk/data/scheme/database/floorplan/model/WallLinePointNode";
    export class WallLineNode extends BrepNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BEGIN: string;
        static FIELD_END: string;
        begin: WallLinePointNode;
        end: WallLinePointNode;
        constructor();
        canSelect(): boolean;
        dispose(): void;
        static create(document: Document): WallLineNode;
    }
    export type WallLineNodeMap = {
        [key: string]: WallLineNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/geometry/GeometryConstants" {
    export class GeometryConstants {
        static OUTLINE_COLOR: number;
        static OUTLINE_LINE_WIDTH: number;
        static MATERIAL_DEFAULT_NORMAL: string;
        static CEILING_COLOR: number;
        static CEILING_EDGE_SIZE1: number;
        static CEILING_EDGE_SIZE2: number;
        static CEILING_EDGE_DARK_COLOR: number;
        static CEILING_EDGE_MIDDLE_COLOR: number;
        static CEILING_EDGE_LIGHT_COLOR: number;
        static CEILING_DEFAULT_TEXTURE: string;
        static FLOOR_OFFSET_TOLERANCE: number;
        static FLOOR_COLOR: number;
        static FLOOR_EDGE_SIZE1: number;
        static FLOOR_EDGE_SIZE2: number;
        static FLOOR_EDGE_DARK_COLOR: number;
        static FLOOR_EDGE_MIDDLE_COLOR: number;
        static FLOOR_EDGE_LIGHT_COLOR: number;
        static FLOOR_DEFAULT_TEXTURE: string;
        static WALL_OFFSET_TOLERANCE: number;
        static WALL_COLOR: number;
        static WALL_EDGE_SIZE1: number;
        static WALL_EDGE_SIZE2: number;
        static WALL_EDGE_DARK_COLOR: number;
        static WALL_EDGE_MIDDLE_COLOR: number;
        static WALL_EDGE_LIGHT_COLOR: number;
        static WALL_HALF_HEIGHT: number;
        static WALL_AMBIENT_COLOR: number;
        static WALL_DIFFUSE_COLOR: number;
        static WALL_SPECULAR_COLOR: number;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/CowallGeometry" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WallLineInfo } from "sk/data/scheme/database/floorplan/model/util/CowallNodeUtil";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { CowallGeometryInfo } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryInfo";
    import { CowallGeometryLine } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometryLine";
    import { GeometryObject } from "sk/data/scheme/database/floorplan/model/geometry/GeometryObject";
    type SideInfo = {
        fromSide: Line2;
        toSide: Line2;
        fromCrossPoints: Types<Vector2>;
        toCrossPoints: Types<Vector2>;
    };
    type SideRange = {
        bottom: number;
        top: number;
    };
    type WallSurfaceSideData = {
        fromSideData: Array<SideRange>;
        toSideData: Array<SideRange>;
    };
    export class CowallGeometry extends GeometryObject {
        node: CowallNode;
        width: number;
        offsetDistance: number;
        innerFromDistance: number;
        innerToDistance: number;
        begin: Vector2;
        end: Vector2;
        center: Vector2;
        rotation: number;
        protected _primitivePositions: Array<Vector2>;
        protected _primitiveInnerLine: Line2;
        protected _primitiveOuterLine: Line2;
        protected _primitiveFromLine: Line2;
        protected _primitiveToLine: Line2;
        openingDatas: any;
        wallSurfaceSideData: WallSurfaceSideData;
        useEdgeMode: boolean;
        moldingDirty: boolean;
        halfMode: boolean;
        fromLinkPositions: Array<Vector2>;
        toLinkPositions: Array<Vector2>;
        sideData: WallSurfaceSideData;
        protected _primitiveInfo: WallLineInfo;
        protected _columnInnerLine: Array<Vector2>;
        protected _columnOuterLine: Array<Vector2>;
        protected _cullInnerLines: Array<Line2>;
        protected _cullOuterLines: Array<Line2>;
        protected _outlines: Array<Array<Vector2>>;
        protected _highLightOutlines: Array<Array<Vector2>>;
        protected _positions: Array<Vector2>;
        protected _showPositions: Array<Vector2>;
        protected _showPositions3d: Array<Vector2>;
        protected _showPositions2d: Array<Vector2>;
        protected _wallBorderLines: Array<Line2>;
        protected _fromPriorWall: WallNode;
        protected _fromNextWall: WallNode;
        protected _toPriorWall: WallNode;
        protected _toNextWall: WallNode;
        protected _geometryInfo: CowallGeometryInfo;
        protected _visualGeometryInfo: CowallGeometryInfo;
        protected _roomModeGeometryInfo: CowallGeometryInfo;
        constructor();
        get primitivePositions(): Array<Vector2>;
        get positions(): Array<Vector2>;
        get showPositions(): Array<Vector2>;
        set showPositions(showPositions: Array<Vector2>);
        get primitiveOuterLine(): Line2;
        get primitiveInnerLine(): Line2;
        get showInnerLine(): Line2;
        get showOuterLine(): Line2;
        get showOuterFrom(): Vector2;
        get showOuterTo(): Vector2;
        get showInnerFrom(): Vector2;
        get showInnerTo(): Vector2;
        get showInnerToLine(): CowallGeometryLine;
        get showOuterToLine(): CowallGeometryLine;
        get showInnerFromLine(): CowallGeometryLine;
        get showOuterFromLine(): CowallGeometryLine;
        get innerLine(): Line2;
        get innerMiddle(): Vector2;
        get innerFrom(): Vector2;
        get innerTo(): Vector2;
        get outerLine(): Line2;
        get outerFrom(): Vector2;
        get outerTo(): Vector2;
        get outerMiddle(): Vector2;
        get fromLine(): CowallGeometryLine;
        get innerFromLine(): CowallGeometryLine;
        get outerFromLine(): CowallGeometryLine;
        get toLine(): CowallGeometryLine;
        get innerToLine(): CowallGeometryLine;
        get outerToLine(): CowallGeometryLine;
        get columnInnerLine(): Array<Vector2>;
        get columnOuterLine(): Array<Vector2>;
        get outlinePositions(): Vector2[];
        get outlinePositionsWithoutFlue(): Vector2[];
        get outlinePositionsSpec1(): Array<Vector2>;
        get outlinePositionsSpec2(): Array<Vector2>;
        isValid(): boolean;
        protected updateCheck(): boolean;
        updatePrimitive(): void;
        get showInnerLine3d(): Line2;
        get showOuterLine3d(): Line2;
        get showInnerFrom3d(): Vector2;
        get showInnerTo3d(): Vector2;
        get showOuterFrom3d(): Vector2;
        get showOuterTo3d(): Vector2;
        get showPositions3d(): Array<Vector2>;
        set showPositions3d(showPositions: Vector2[]);
        get showPositions2d(): Array<Vector2>;
        set showPositions2d(showPositions: Vector2[]);
        get showInnerFromLine3d(): CowallGeometryLine;
        get showInnerToLine3d(): CowallGeometryLine;
        get showOuterFromLine3d(): CowallGeometryLine;
        get showOuterToLine3d(): CowallGeometryLine;
        get showFromLine3d(): CowallGeometryLine;
        get showToLine3d(): CowallGeometryLine;
        get wallBorderLines(): Line2[];
        private checkRoomMode;
        computeShape(): void;
        computeSingleRoomWall(): void;
        computeCullOpeningLine(): void;
        get cullInnerLines(): Line2[];
        get cullOuterLines(): Line2[];
        get outlines(): Array<Array<Vector2>>;
        get highLightOutlines(): Array<Array<Vector2>>;
        protected isWallPointsDrawing(wall: WallNode): boolean;
        protected makeWallShowLine(): Array<Line2>;
        protected makeOutlines(openings: Array<OpeningNode>): void;
        computeVisualWall(): void;
        protected computeWall(): void;
        private getIntersectionPoint;
        clear(): void;
        modelSpaceToMeshSpace(value: any): Vector3;
        protected computeSideData(openingPoints: Vector2[], sideInfo: SideInfo, equalsInvoker: Function): void;
        protected computeOpeningDatas(): any;
        dispose(flag?: boolean): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/MoldingNode" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { IMolding } from 'foundation/data/common/model/molding/IMolding';
    import { DataMoldingTypeEnum } from 'foundation/data/common/model/DataMoldingTypeEnum';
    export class MoldingNode extends ContentNode implements IMolding {
        moldingCd: DataMoldingTypeEnum;
        host: BrepNode;
        height: number;
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallMoldingNode" {
    import { MoldingNode } from "sk/data/scheme/database/floorplan/model/MoldingNode";
    export class WallMoldingNode extends MoldingNode {
    }
}
declare module "sk/data/scheme/database/floorplan/element/CowallElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { DataMoldingTypeEnum } from 'foundation/data/common/model/DataMoldingTypeEnum';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { CocurveEdgeElement } from 'sk/data/family/element/brep/topology/CocurveEdgeElement';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { CowallGeometry } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometry";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { MoldingNode } from "sk/data/scheme/database/floorplan/model/MoldingNode";
    import { WallMoldingNode } from "sk/data/scheme/database/floorplan/model/WallMoldingNode";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    import { WallSurfaceElement } from "sk/data/scheme/database/floorplan/element/WallSurfaceElement";
    export class CowallElement extends CocurveEdgeElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OPTION_TECHNOLOGY_VALID: string;
        static FIELD_OFFSET_DISTANCE: string;
        static FIELD_INNER_FROM_DISTANCE: string;
        static FIELD_INNER_TO_DISTANCE: string;
        static FIELD_OUTER_FROM_DISTANCE: string;
        static FIELD_OUTER_TO_DISTANCE: string;
        static FIELD_SURFACE_DISTANCE: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_SURFACES: string;
        static FIELD_MOLDINGS: string;
        static FIELD_RELATIONS: string;
        optionTechnologyValid: boolean;
        protected _offsetDistance: FormulaProperty;
        protected _innerFromDistance: FormulaProperty;
        protected _innerToDistance: FormulaProperty;
        protected _outerFromDistance: FormulaProperty;
        protected _outerToDistance: FormulaProperty;
        protected _surfaceDistance: FormulaProperty;
        protected _spaceDistance: FormulaProperty;
        protected _workDistance: FormulaProperty;
        protected _surfaces: Types<WallSurfaceElement>;
        protected _moldings: Types<ContentInstanceElement>;
        protected _relations: Types<RelationElement>;
        document: SchemeDocument;
        structure: SchemeFamilyStructure;
        columns: Types<ColumnNode>;
        singleRoomMode: boolean;
        constructor();
        get offsetDistance(): FormulaProperty;
        get innerFromDistance(): FormulaProperty;
        get innerToDistance(): FormulaProperty;
        get outerFromDistance(): FormulaProperty;
        get outerToDistance(): FormulaProperty;
        get surfaceDistance(): FormulaProperty;
        get spaceDistance(): FormulaProperty;
        get workDistance(): FormulaProperty;
        get surfaces(): Types<WallSurfaceElement>;
        get moldings(): Types<ContentInstanceElement>;
        get relations(): Types<RelationElement>;
        static FIELD_WIDTH: string;
        static FIELD_HEIGHT3D: string;
        static FIELD_STATUS_HALF: string;
        edge: WallElement;
        partner: CowallElement;
        statusHalf: boolean;
        protected _prev: CowallElement;
        protected _next: CowallElement;
        protected _geometry: CowallGeometry;
        get from(): WallPointElement;
        get to(): WallPointElement;
        addRelation(relation: RelationElement): void;
        removeRelation(relation: RelationElement): void;
        get fromOffset(): number;
        set fromOffset(offset: number);
        get toOffset(): number;
        set toOffset(offset: number);
        get prev(): CowallElement;
        set prev(value: CowallElement);
        get next(): CowallElement;
        set next(value: CowallElement);
        get isLoadBearing(): boolean;
        set isLoadBearing(value: boolean);
        get width(): number;
        set width(value: number);
        get height3d(): number;
        set height3d(value: number);
        addChild(element: BrepElement): void;
        removeChild(element: BrepElement): void;
        isFromPoint(point: WallPointElement): boolean;
        isToPoint(point: WallPointElement): boolean;
        isPartialWall(): boolean;
        get openings(): Types<OpeningElement>;
        testLoadBearing(): boolean;
        get floorplan(): FloorplanElement;
        hasParentRoom(): boolean;
        getParentRoom(): RoomElement;
        findSurfaceByTypeCd(surfaceTypeCd: WallSurfaceTypeEnum): WallSurfaceElement;
        getMolding(surfaceCd: WallSurfaceTypeEnum, moldingCd: DataMoldingTypeEnum): WallMoldingNode;
        getMoldingByProductIdentity(infoGuid: string): MoldingNode;
        forEachMolding(callback: Function, scope?: any): void;
        addMolding(surfaceTypeCd: WallSurfaceTypeEnum, molding: ContentInstanceElement): void;
        removeMolding(surfaceTypeCd: WallSurfaceTypeEnum, molding: ContentInstanceElement): void;
        fetchCowalls(targets?: Types<CowallElement>): Types<CowallElement>;
        fetchConnectCowalls(targets?: Types<CowallElement>): Types<CowallElement>;
        fetchRooms(targets?: Types<RoomElement>): Types<RoomElement>;
        fetchConnectRooms(targets?: Types<RoomElement>): Types<RoomElement>;
        computeLength(moldingTypeCd: DataMoldingTypeEnum): number;
        computeArea(): number;
        removeSurfaces(): void;
        protected innerDump(info: StringBuffer, level: number): void;
        debugValid(context?: any): void;
        toDisplay(): string;
        getValidCowall(): CowallElement;
        getBaseboard(surfaceCd: WallSurfaceTypeEnum): MoldingNode;
        getCornice(surfaceCd: WallSurfaceTypeEnum): MoldingNode;
        copyProperty(cowall: CowallElement): void;
        isAlignsWithOpening(a: any): any;
        static height3dsorter(cowall1: CowallElement, cowall2: CowallElement): number;
        reset(): void;
        dispose(): void;
    }
    export type CowallElementMap = {
        [key: string]: CowallElement;
    };
}
declare module "sk/data/scheme/database/floorplan/model/CowallNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SingleCurve2d } from 'foundation/runtime/geometry/Curve2d';
    import { CocurveEdgeNode } from 'foundation/data/common/model/brep/topology/CocurveEdgeNode';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataMoldingTypeEnum } from 'foundation/data/common/model/DataMoldingTypeEnum';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { CowallGeometry } from "sk/data/scheme/database/floorplan/model/geometry/CowallGeometry";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { MoldingNode } from "sk/data/scheme/database/floorplan/model/MoldingNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallMoldingNode } from "sk/data/scheme/database/floorplan/model/WallMoldingNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    export class CowallNode extends CocurveEdgeNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OFFSET_DISTANCE: string;
        static FIELD_INNER_FROM_DISTANCE: string;
        static FIELD_INNER_TO_DISTANCE: string;
        static FIELD_OUTER_FROM_DISTANCE: string;
        static FIELD_OUTER_TO_DISTANCE: string;
        static FIELD_SURFACE_DISTANCE: string;
        static FIELD_SPACE_DISTANCE: string;
        static FIELD_WORK_DISTANCE: string;
        static FIELD_SURFACES: string;
        static FIELD_COLUMNS: string;
        static FIELD_MOLDINGS: string;
        offsetDistance: number;
        innerFromDistance: number;
        innerToDistance: number;
        outerFromDistance: number;
        outerToDistance: number;
        surfaceDistance: number;
        spaceDistance: number;
        workDistance: number;
        protected _surfaces: Types<WallSurfaceNode>;
        protected _columns: Types<ColumnNode>;
        protected _moldings: Types<ContentInstanceNode>;
        static FIELD_WIDTH: string;
        static FIELD_HEIGHT3D: string;
        static FIELD_STATUS_HALF: string;
        element: CowallElement;
        edge: WallNode;
        statusHalf: boolean;
        protected _geometry: CowallGeometry;
        optionDelete: boolean;
        isUninstall: boolean;
        singleRoomMode: boolean;
        constructor();
        get surfaces(): Types<WallSurfaceNode>;
        get columns(): Types<ColumnNode>;
        get moldings(): Types<ContentInstanceNode>;
        get from(): WallPointNode;
        set from(value: WallPointNode);
        get to(): WallPointNode;
        set to(value: WallPointNode);
        get partner(): CowallNode;
        set partner(value: CowallNode);
        get prev(): CowallNode;
        set prev(value: CowallNode);
        get next(): CowallNode;
        set next(value: CowallNode);
        get fromOffset(): number;
        set fromOffset(offset: number);
        get toOffset(): number;
        set toOffset(offset: number);
        get isLoadBearing(): boolean;
        set isLoadBearing(value: boolean);
        get width(): number;
        set width(value: number);
        get height3d(): number;
        set height3d(value: number);
        get length(): number;
        get middle(): Vector2;
        get rotation(): number;
        get angle(): number;
        get outline(): Array<Vector2>;
        get fromJoinner(): WallJoinnerNode;
        get toJoinner(): WallJoinnerNode;
        get geometry(): CowallGeometry;
        isFromPoint(point: WallPointNode): boolean;
        isToPoint(point: WallPointNode): boolean;
        isPartialWall(): boolean;
        getSurfaceByType(typeCd: WallSurfaceTypeEnum): WallSurfaceNode;
        get openings(): Types<OpeningNode>;
        isVisible(): boolean;
        testLoadBearing(): boolean;
        hasParentRoom(): boolean;
        getFloorplan(): FloorplanNode;
        getParentRoom(): RoomNode;
        getMolding(surfaceCd: WallSurfaceTypeEnum, moldingCd: DataMoldingTypeEnum): WallMoldingNode;
        modelspaceToUvwspace2(value: Value2): any;
        modelspaceToUvwspace(value: Value3): any;
        uvwspaceToModelspace(value: any): Vector3;
        worldspaceToModelspace(value: Value3): Vector3;
        getMoldingByProductIdentity(infoGuid: string): MoldingNode;
        forEachMolding(callback: Function, scope?: any): void;
        onFieldChanged(sender: any, event: DataNodeFieldEvent): void;
        addMolding(molding: ContentInstanceNode): void;
        removeMolding(surfaceCd: WallSurfaceTypeEnum, moldingCd: DataMoldingTypeEnum): void;
        getValidCowall(): CowallNode;
        getValidSurface(): WallSurfaceNode;
        getValidSurfaces(): WallSurfaceNode[];
        getValidSurfaceByType(typeCd: WallSurfaceTypeEnum): WallSurfaceNode;
        fetchWallSurfaces(targets?: Types<WallSurfaceNode>): Types<WallSurfaceNode>;
        fetchCowalls(targets?: Types<CowallNode>): Types<CowallNode>;
        fetchConnectCowalls(targets?: Types<CowallNode>): Types<CowallNode>;
        fetchRooms(targets?: Types<RoomNode>): Types<RoomNode>;
        fetchConnectRooms(targets?: Types<RoomNode>): Types<RoomNode>;
        computeLength(moldingTypeCd: DataMoldingTypeEnum): number;
        computeArea(): number;
        attachWall(wall: WallNode): void;
        detachWall(): void;
        updateBoundary(): void;
        dirtySelf(): void;
        dirtyCoedges(): void;
        protected innerDump(info: StringBuffer, level: number): void;
        debugValid(context?: any): void;
        toDisplay(): string;
        toMath(): SingleCurve2d;
        dispose(): void;
        static create(document: Document): CowallNode;
    }
    export type CowallNodeMap = {
        [key: string]: CowallNode;
    };
}
declare module "sk/data/scheme/database/floorplan/element/ColumnElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ColumnTypeEnum } from "sk/data/scheme/database/floorplan/model/ColumnTypeEnum";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    export class ColumnElement extends FamilyInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HEIGHT: string;
        static FIELD_LEFT_WORK_DISTANCE: string;
        static FIELD_RIGHT_WORK_DISTANCE: string;
        static FIELD_FRONT_WORK_DISTANCE: string;
        static FIELD_BACK_WORK_DISTANCE: string;
        height: number;
        protected _leftWorkDistance: FormulaProperty;
        protected _rightWorkDistance: FormulaProperty;
        protected _frontWorkDistance: FormulaProperty;
        protected _backWorkDistance: FormulaProperty;
        modelType: ColumnTypeEnum;
        surfaceCount: number;
        cowalls: Types<CowallNode>;
        height3d: number;
        constructor();
        get leftWorkDistance(): FormulaProperty;
        get rightWorkDistance(): FormulaProperty;
        get frontWorkDistance(): FormulaProperty;
        get backWorkDistance(): FormulaProperty;
        reset(): void;
        dispose(): void;
    }
    export type ColumnElementMap = {
        [key: string]: ColumnElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/DoorFrameElement" {
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    export class DoorFrameElement extends FamilyInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type DoorFrameElementMap = {
        [key: string]: DoorFrameElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/DoorLeafElement" {
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    export class DoorLeafElement extends FamilyInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type DoorLeafElementMap = {
        [key: string]: DoorLeafElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/FloorplanElementUtil" {
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    export class FloorplanElementUtil {
        static findStructure(document: FamilyDocument): FamilyStructure;
    }
}
declare module "sk/data/scheme/database/floorplan/element/FloorplanStructureElement" {
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    export class FloorplanStructureElement extends StructureElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_LENGTH_X: string;
        static FIELD_LENGTH_Y: string;
        static FIELD_LENGTH_Z: string;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type FloorplanStructureElementMap = {
        [key: string]: FloorplanStructureElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/HoleLinePointElement" {
    import { JoinnerElement } from 'sk/data/family/element/brep/JoinnerElement';
    export class HoleLinePointElement extends JoinnerElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type HoleLinePointElementMap = {
        [key: string]: HoleLinePointElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/HoleLineElement" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { HoleLinePointElement } from "sk/data/scheme/database/floorplan/element/HoleLinePointElement";
    export class HoleLineElement extends BrepElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_INNER_DEPTH: string;
        static FIELD_OUTER_DEPTH: string;
        static FIELD_BEGIN: string;
        static FIELD_END: string;
        thickness: number;
        innerDepth: number;
        outerDepth: number;
        begin: HoleLinePointElement;
        end: HoleLinePointElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type HoleLineElementMap = {
        [key: string]: HoleLineElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/PocketElement" {
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    export class PocketElement extends OpeningElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type PocketElementMap = {
        [key: string]: PocketElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/PolygonRoomElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    export class PolygonRoomElement extends ContentElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_REFERENCE_INFO_ID: string;
        static FIELD_ROOMS: string;
        referenceInfoId: string;
        protected _rooms: Types<PolygonRoomElement>;
        constructor();
        get rooms(): Types<PolygonRoomElement>;
        reset(): void;
        dispose(): void;
    }
    export type PolygonRoomElementMap = {
        [key: string]: PolygonRoomElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/PolygonWallElement" {
    import { AreaPointElement } from 'sk/data/family/element/brep/area/AreaPointElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    export class PolygonWallElement extends BrepElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BEGIN: string;
        static FIELD_END: string;
        begin: AreaPointElement;
        end: AreaPointElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type PolygonWallElementMap = {
        [key: string]: PolygonWallElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/PolygonWallPointElement" {
    import { VertexElement } from 'sk/data/family/element/brep/VertexElement';
    export class PolygonWallPointElement extends VertexElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type PolygonWallPointElementMap = {
        [key: string]: PolygonWallPointElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/util/CeilingElementUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CeilingNode } from "sk/data/scheme/database/floorplan/model/CeilingNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { CeilingElement } from "sk/data/scheme/database/floorplan/element/CeilingElement";
    export class CeilingElementUtil {
        static splitRoomsCeiling(rooms: RoomNode[]): void;
        static splitCeiling(ceiling: CeilingNode): Vector2[][];
        static createCeilingSurface(ceiling: CeilingElement, points: Vector2[], thickness: number, relationData?: any): void;
        static getOldRelations(ceiling: CeilingElement): any[];
        static computeSplit(ceiling: CeilingNode): void;
        static split(ceiling: CeilingNode): void;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/FloorplanPolygonUtil" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/LineCurve2dNode';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    export class FloorplanPolygonUtil {
        static getSideInfosBySectionSurfaceNode(outline: PolygonSurfaceStructure): {
            length: number;
            leftCornerCd: CornerTypeEnum;
            rightCornerCd: CornerTypeEnum;
            begin: Value2;
            end: Value2;
        }[];
        static getCornerType(leftLine: LineCurve2dNode, rightLine: LineCurve2dNode): CornerTypeEnum;
        static getCornerTypeByPoints(p1: Vector2, p2: Vector2, p3: Vector2): CornerTypeEnum;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/FloorplanResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class FloorplanResult extends ResultObject {
    }
}
declare module "sk/data/scheme/enumeration/SchemeDocumentTypeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeDocumentTypeEnum extends EnumerationObject {
        static Unknown: string;
        static Library: string;
        static FamilyInfo: string;
        static Family: string;
        static PatternInfo: string;
        static Pattern: string;
        static Floorplan: string;
        static Design: string;
        static Structure: string;
        static Technology: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/model/SchemeTechnologyDataDocument" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { SchemeDataDocument } from "sk/data/scheme/model/SchemeDataDocument";
    export class SchemeTechnologyDataDocument extends SchemeDataDocument {
        protected static _factory: PersistentFactory;
        static get Factory(): PersistentFactory;
        protected constructor();
        get factory(): PersistentFactory;
        static createEmptyDocument(json?: any): SchemeTechnologyDataDocument;
        static createDefaultDocument(): SchemeTechnologyDataDocument;
        loadSchemeDocumentJson(jconfig: any, options?: any): void;
        loadSchemeDocumentBinary(documentSource: any, options?: any): void;
    }
}
declare module "sk/data/scheme/service/SchemeWorkflowEnum" {
    export class SchemeWorkflowEnum {
        static Build: string;
        static Prepare: string;
        static Shape: string;
        static Vision: string;
        static Structure: string;
        static Drawing: string;
        static Quote: string;
        static Bom: string;
        static Technique: string;
        static VisionModel: string;
        static FamilyTechnique: string;
        static Arrangement: string;
        static Validation: string;
        static Material: string;
        static Valuation: string;
        static BuildPattern: string;
    }
}
declare module "sk/data/scheme/service/SchemeDocumentService" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LockService } from 'cross/runtime/module/lock/LockService';
    import { ProcessPipeService } from 'cross/runtime/module/pipe/ProcessPipeService';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { VersionUpgradeService } from 'foundation/data/common/version/upgrade/VersionUpgradeService';
    import { WorkflowProcesResult } from 'foundation/data/common/workflow/process/WorkflowProcesResult';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { WorkflowProcessService } from 'sk/data/family/workflow/WorkflowProcessService';
    import { SchemeDataDocument } from "sk/data/scheme/model/SchemeDataDocument";
    import { SchemeTechnologyDataDocument } from "sk/data/scheme/model/SchemeTechnologyDataDocument";
    export type SchemeWorkflowBuildOptions = {
        cacheName: string;
        sourceDocument: FamilyDocument;
        sourceElement?: Element;
        targetDocument: FamilyDocument;
        targetElement?: Element;
        calculatorTypeCd?: string;
        calculatorCd?: string;
        parameters?: any;
        processForce?: boolean;
    };
    export type SchemeWorkflowOptions = {
        document?: FamilyDocument;
        element?: Element;
        content?: any;
        calculatorTypeCd?: string;
        calculatorCd?: string;
        processSyncLock?: boolean;
        processSyncPipe?: boolean;
        processForce?: boolean;
        processComposite?: boolean;
        processPlaceCd?: boolean;
        processShape?: boolean;
        processRule?: boolean;
        processBoundary?: boolean;
        processStructure?: boolean;
        processTechnology?: boolean;
        processMolding?: boolean;
        processCollision?: boolean;
        processSkipFamily?: boolean;
        disableFieldChanged?: boolean;
        parameters?: any;
        force?: boolean;
        roomMode?: boolean;
        clearCache?: boolean;
        createAll?: boolean;
        computeAddition?: boolean;
    };
    export class SchemeDocumentService extends DataDocumentService<SchemeDataDocument> {
        protected _workflowProcessService: WorkflowProcessService;
        protected _processPipeService: ProcessPipeService;
        protected _versionUpgradeService: VersionUpgradeService;
        protected _lockService: LockService;
        constructor();
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makePreviewUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeDataDocument;
        makeDocumentAsync(context: IContext, parameters: DataDocumentParameters, content: any): Promise<ResultObject<SchemeDataDocument>>;
        loadMetaAsync(context: IContext, id: string): Promise<ResultObject>;
        loadDataAsync(context: IContext, id: string, version?: AssetVersionType, parameters?: DataDocumentParameters): Promise<DataDocumentResult>;
        loadPreviewDocumentAsync(context: IContext, id: string, version?: AssetVersionType, parameters?: DataDocumentParameters): Promise<DataDocumentResult>;
        markPreviewDocumentCache(context: IContext): void;
        loadDocumentAsync(context: IContext, id: string, version?: AssetVersionType, parameters?: DataDocumentParameters): Promise<DataDocumentResult>;
        loadSchemeDocumentByStorageIdAsync(storageId: string): Promise<ResultObject<SchemeTechnologyDataDocument>>;
        protected makeOptions(options?: SchemeWorkflowOptions): SchemeWorkflowOptions;
        computeWorkflow(context: IContext, name: string, options: SchemeWorkflowOptions): WorkflowProcesResult;
        computeWorkflowAsync(context: IContext, name: string, options: SchemeWorkflowOptions): Promise<WorkflowProcesResult>;
        buildWorkflowAsync(context: IContext, name: string, options: SchemeWorkflowBuildOptions): Promise<WorkflowProcesResult>;
    }
}
declare module "sk/data/scheme/service/SchemeFamilyDocumentService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { WorkflowProcesResult } from 'foundation/data/common/workflow/process/WorkflowProcesResult';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { WorkflowProcessService } from 'sk/data/family/workflow/WorkflowProcessService';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    export type FamilyWorkflowOptions = {
        document: FamilyDocument;
        element?: Element;
        force?: boolean;
        parameters?: any;
    };
    export class SchemeFamilyDocumentService extends DataDocumentService<FamilyDocument> {
        protected _workflowProcessService: WorkflowProcessService;
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): FamilyDataDocument;
        computeWorkflow(context: ContextObject, name: string, options: FamilyWorkflowOptions): any;
        computeWorkflowAsync(context: ContextObject, name: string, options: FamilyWorkflowOptions): Promise<WorkflowProcesResult>;
        getFamilyDocumentByfamilyInfoIdAsync(context: ContextObject, familyInfoId: string): Promise<DataDocumentResult<FamilyDocument>>;
    }
}
declare module "sk/data/scheme/performer/element/SchemeElementPerformerContext" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformer } from 'sk/data/family/performer/element/ElementPerformer';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { PatternDataDocument } from 'sk/data/family/pattern/PatternDataDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { SchemeLibraryFamilyDocumentService } from "sk/data/scheme/config/SchemeLibraryFamilyDocumentService";
    import { SchemeLibraryPatternDocumentService } from "sk/data/scheme/config/SchemeLibraryPatternDocumentService";
    import { SchemeFamilyDocumentService } from "sk/data/scheme/service/SchemeFamilyDocumentService";
    export class SchemeElementPerformerContext extends ElementPerformerContext {
        protected _decorateItemAndLinker: Dictionary<any>;
        protected _familyTypePerformers: Dictionary<ElementPerformer>;
        protected _familyInfoIds: Dictionary<any>;
        protected _familyInfos: Dictionary<ISpecificationFamilyInfo>;
        protected _familyDocuments: Dictionary<FamilyDataDocument>;
        protected _patternDocument: Dictionary<PatternDataDocument>;
        protected _schemeConfigService: SchemeConfigService;
        protected _SchemeFamilyDocumentService: SchemeFamilyDocumentService;
        protected _patternDocumentService: PatternDocumentService;
        protected _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        protected _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        createElementByFamilyIdAsync(parentElement: NestElement, familyId: string): Promise<ResultObject<FamilyInstanceElement>>;
        createElementBySymbolIdAsync(parentElement: NestElement, familyId: string, familySymbolId: string): Promise<ResultObject<FamilyInstanceElement>>;
        createElementByInfoIdAsync(parentElement: NestElement, infoId: string): Promise<ResultObject<FamilyInstanceElement>>;
        getDefaultDecorateItemAndLinkerAsync(configId: string): Promise<ResultObject<any>>;
        getTypePerformerByFamilyIdAsync(familyId: string): Promise<ResultObject<ElementPerformer>>;
        getFamilyInfoIdByFamilyIdAsync(familyId: string): Promise<ResultObject<string>>;
        getFamilyInfoIdByFamilySymbolIdAsync(familyId: string, familySymbolId: string): Promise<ResultObject<string>>;
        getSpecificationFamilyInfoAsync(familyInfoId: string): Promise<ResultObject<ISpecificationFamilyInfo>>;
        getFamilyDocumentByInfoIdAsync(familyInfoId: string): Promise<ResultObject<FamilyDataDocument>>;
        getPatternDocumentByInfoIdAsync(patternInfoId: string): Promise<ResultObject<PatternDataDocument>>;
        getPatternDocumentByIdAsync(id: string, version?: number | string): Promise<ResultObject<PatternDataDocument>>;
        getFamilyDocumentByInfoId(familyInfoId: string): FamilyDataDocument;
        setFamilyDocumentByFamilyInfoId(familyInfoId: string, familyDocument: FamilyDataDocument): void;
        free(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/CoordTransformUtil" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class CoordTransformUtil {
        static objectCoordToUserCoord(objectMatrix: Matrix4, userMatrix: Matrix4, point: Vector3 | Vector2): Vector3;
        static objectCoordToUserCoord2d(objectMatrix: Matrix4, userMatrix: Matrix4, point: Vector3 | Vector2): Vector2;
        static objectCoordToWorldCoord(objectMatrix: Matrix4, point: Vector3 | Vector2): Vector3;
        static objectCoordToWorldCoord2d(objectMatrix: Matrix4, point: Vector3 | Vector2): Vector2;
        static worldCoordToUserCoord2d(userMatrix: Matrix4, point: Vector3): Vector2;
        static worldCoordToUserCoord(userMatrix: Matrix4, point: Vector3): Vector3;
    }
}
declare module "sk/data/scheme/util/SchemeElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    export class SchemeElementUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _calculatorService: CalculatorService;
        static createAndBuildElementByFamilyIdAsync(context: ElementPerformerContext, parent: ContentElement, familyId: string): Promise<ResultObject>;
        static createAndBuildElementByInfoIdAsync(context: ElementPerformerContext, parent: ContentElement, infoId: string): Promise<ResultObject>;
        static createAndBuildElementByInfoAsync(context: ElementPerformerContext, parent: ContentElement, info: ISpecificationFamilyInfo): Promise<ResultObject>;
        private static getPerformerContext;
        static getFamilySymbolsAsync(referenceInfoId: any): Promise<ResultObject>;
        static getFamilySizesAsync(referenceInfoId: any): Promise<ResultObject>;
    }
}
declare module "sk/data/scheme/database/pattern/element/BathroomCeilingElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_FINISH: string;
        static FIELD_CAVITY: string;
        static FIELD_ARRANGE_DIRECTION: string;
        static FIELD_CEILING_PLANK_INFO_ID: string;
        static FIELD_CEILING_SURFACE_INFO_ID: string;
        static FIELD_TECHNOLOGY_TYPE: string;
        static FIELD_THICKNESS: string;
        static FIELD_POLYGON: string;
        static FIELD_OUTLINE: string;
        finish: number;
        cavity: number;
        arrangeDirection: string;
        ceilingPlankInfoId: string;
        ceilingSurfaceInfoId: string;
        technologyType: string;
        polygon: SectionSurfaceStructure;
        outline: PolygonSurfaceStructure;
        static FIELD_TILE_LENGTH_X: string;
        static FIELD_TILE_LENGTH_Y: string;
        static FIELD_GAP: string;
        static FIELD_OFFSET_X: string;
        static FIELD_OFFSET_Y: string;
        static FIELD_START_X: string;
        static FIELD_START_Y: string;
        baseThickness: number;
        surfaceThickness: number;
        ceilingLayout: string;
        surfaceOutlines: Types<PolygonSurfaceStructure>;
        tileLengthX: number;
        tileLengthY: number;
        gap: number;
        offsetX: number;
        offsetY: number;
        startX: number;
        startY: number;
        constructor();
        get thickness(): string;
        set thickness(value: string);
        reset(): void;
        dispose(): void;
    }
    export type BathroomCeilingElementMap = {
        [key: string]: BathroomCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomWallElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { LineCurve2dStructure } from 'foundation/data/common/structure/geometric/curve2d/LineCurve2dStructure';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
    import { WallPlankHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/bathroom/WallPlankHoldTypeEnum';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    export class BathroomWallElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BOTTOM_OFFSET: string;
        static FIELD_LEFT_OFFSET: string;
        static FIELD_RIGHT_OFFSET: string;
        static FIELD_GAP: string;
        static FIELD_START_X: string;
        static FIELD_START_Y: string;
        static FIELD_TOP_OFFSET: string;
        static FIELD_PLANK_FAMILY_INFO_ID: string;
        static FIELD_TECHNOLOGY_TYPE: string;
        static FIELD_FINISH: string;
        static FIELD_CONTENT_HOLES: string;
        static FIELD_CUT_HOLES: string;
        static FIELD_HOLES: string;
        static FIELD_LEFT_HOLD_TYPE: string;
        static FIELD_RIGHT_HOLD_TYPE: string;
        static FIELD_LEFT_CORNER_TYPE: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_DIVIDE_TYPE: string;
        static FIELD_OFFSET_X: string;
        static FIELD_OFFSET_Y: string;
        static FIELD_RIGHT_CORNER_TYPE: string;
        static FIELD_SEAM_THICKNESS: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_TILE_LAYOUT_DIRECT: string;
        static FIELD_TILE_LENGTH_X: string;
        static FIELD_TILE_LENGTH_Y: string;
        static FIELD_WALL_PLANK_INFO_ID: string;
        static FIELD_WALL_SEAM_INFO_ID: string;
        static FIELD_WALL_SURFACE_INFO_ID: string;
        static FIELD_CLOCKWISE: string;
        static FIELD_LINE: string;
        static FIELD_OUTLINE: string;
        static FIELD_WALL_OUTLINE: string;
        thickness: number;
        bottomOffset: number;
        leftOffset: number;
        rightOffset: number;
        gap: number;
        startX: number;
        startY: number;
        topOffset: number;
        plankFamilyInfoId: string;
        technologyType: string;
        finish: number;
        contentHoles: Types<HoleStructure>;
        cutHoles: Types<HoleStructure>;
        holes: Types<SectionSurfaceStructure>;
        leftHoldType: WallPlankHoldTypeEnum;
        rightHoldType: WallPlankHoldTypeEnum;
        leftCornerType: CornerTypeEnum;
        baseThickness: number;
        divideType: string;
        offsetX: number;
        offsetY: number;
        rightCornerType: CornerTypeEnum;
        seamThickness: number;
        surfaceThickness: number;
        tileLayoutDirect: string;
        tileLengthX: number;
        tileLengthY: number;
        wallPlankInfoId: string;
        wallSeamInfoId: string;
        wallSurfaceInfoId: string;
        clockwise: boolean;
        line: LineCurve2dStructure;
        outline: PolygonSurfaceStructure;
        wallOutline: LineCurve2dStructure;
        idx: number;
        bindElement: ContentInstanceElement;
        prev: BathroomWallElement;
        next: BathroomWallElement;
        constructor();
        static PLANK_DECORATE_CODE: string;
        static HOLE_UP_DECORATE_CODE: string;
        static HOLE_DOWN_DECORATE_CODE: string;
        static CONNER_OUTER_BEGIN_DECORATE_CODE: string;
        static CONNER_OUTER_END_DECORATE_CODE: string;
        static WALL_TILE_CODE: string;
        isWallPlank(): boolean;
        isWindowPlank(): boolean;
        isBeamPlank(): boolean;
        private isIndependentColumn;
        addRelation(relation: RelationElement): void;
        removeRelation(relation: RelationElement): void;
        getRoom(): RoomElement;
        reset(): void;
        dispose(): void;
    }
    export type BathroomWallElementMap = {
        [key: string]: BathroomWallElement;
    };
}
declare module "sk/data/scheme/database/technology/element/TechnologyMillingTrackElement" {
    import { ElementStructure } from 'foundation/data/common/element/ElementStructure';
    import { Curve2dElement } from 'sk/data/family/element/brep/geometric/Curve2dElement';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    import { TechnologyMillingTypeEnum } from 'sk/data/family/enumeration/technology/TechnologyMillingTypeEnum';
    export class TechnologyMillingTrackElement extends TechnologyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_MILLING_CD: string;
        static FIELD_PATH: string;
        static FIELD_WIDTH: string;
        static FIELD_DEPTH_BEGIN: string;
        static FIELD_DEPTH_END: string;
        static FIELD_SURFACE_LOCATION: string;
        static FIELD_TOOL_POS_FLAG: string;
        static FIELD_MILLING_VALID: string;
        millingCd: TechnologyMillingTypeEnum;
        path: Curve2dElement;
        width: number;
        depthBegin: number;
        depthEnd: number;
        surfaceLocation: string;
        toolPosFlag: string;
        millingValid: boolean;
        constructor();
        static create(familyStructure: ElementStructure): TechnologyMillingTrackElement;
        reset(): void;
        dispose(): void;
    }
    export type TechnologyMillingTrackElementMap = {
        [key: string]: TechnologyMillingTrackElement;
    };
}
declare module "sk/data/scheme/database/furniture/FurnitureMathUtil" {
    export class FurnitureMathUtil {
        static PRECISION: number;
        static TOLERANCE: number;
        static isZero(value: number): boolean;
        static isNotZero(value: number): boolean;
        static nearlyEquals(value1: number, value2: number): boolean;
        static nearlyLess(value1: number, value2: number): boolean;
        static nearlyLessEquals(value1: number, value2: number): boolean;
        static nearlyGreater(value1: number, value2: number): boolean;
        static nearlyGreaterEquals(value1: number, value2: number): boolean;
    }
}
declare module "sk/data/scheme/database/furniture/model/PlankNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PlankComponentElement } from 'sk/data/family/database/furniture/element/PlankComponentElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlankElement } from "sk/data/scheme/database/furniture/element/PlankElement";
    export class PlankNode extends PlaneNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        element: PlankElement | PlankComponentElement;
        constructor();
        isValidSize(): boolean;
        beforBuildShape(): boolean;
        dispose(): void;
        static create(document: Document): PlankNode;
    }
    export type PlankNodeMap = {
        [key: string]: PlankNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/PlankNodeUtil" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    export class PlankNodeUtil {
        static getPlankDefaultMaterial(context: any): any;
        static getPlankSlimRatio(plank: PlankNode): number;
        static isPlankNode(plank: ContentNode): boolean;
        static isPlankSlim(plank: PlankNode, widthThresh: number, heightThresh: number): boolean;
        static calculatePolygon(plank: PlankNode): Array<any>;
        static isPlankShapeValid(plank: PlankNode): boolean;
        static getPlankSurfacePoints(plank: PlankNode): Vector3[];
        static getPlankSurfacePointsParent(plank: PlankNode): Vector3[];
        static getPlankSurfacePointsWorld(plank: PlankNode): Vector3[];
        static getPlankPolygonWorld(plank: PlankNode): Vector3[];
        static getPlankPolygon(plank: PlankNode): Vector3[];
    }
}
declare module "sk/data/scheme/database/furniture/element/PlankElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SingleSurface } from 'foundation/runtime/geometry/Surface';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    import { TechnologyMillingTrackElement } from "sk/data/scheme/database/technology/element/TechnologyMillingTrackElement";
    import { PlankElement } from "sk/data/scheme/database/furniture/element/PlankElement";
    export class PlankElementUtil {
        static createSingleInstance(structure: FamilyStructure, edgeCount?: number): PlankElement;
        static buildPlankAsync(context: ElementPerformerContext, parent: ContentElement, polygon: Array<Vector2>, infoId: string): Promise<ResultObject>;
        static boundCollision(bound1: Array<number>, bound2: Array<number>): boolean;
        static cutPlank(points: Array<Vector2>): Array<Curve2>;
        static convertHolePointsToHoleCutLines(outline: Vector2[], holePoints: Vector2[]): Line2[];
        static pointIsOnboundary(p1: Vector2, p2: Vector2, region: any): boolean;
        static isPointInPlank(point: Vector2, region: any): boolean;
        static addPlankCutLinesMilling(plankElement: PlankElement, cutLines: Curve2[]): void;
        static createMillingLine(familyStructure: FamilyStructure, beginX: number, beginY: number, endX: number, endY: number, depth: number): TechnologyMillingTrackElement;
        static createComplexHolesSurfaceEdge(plane: PlankElement, holes: Array<SingleSurface>): void;
        static getPlankPolygon(decorateLayerElement: DecorateLayerElement): Array<Vector2>;
        static getSurfaceWorldPolygon(node: any, roomNode: any): Array<Vector2>;
        static setRandomTexture(plank: PlankElement): void;
    }
}
declare module "sk/data/scheme/database/furniture/element/PlankBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { ComplexHoleSurface } from 'foundation/runtime/geometry/surface/ComplexHoleSurface';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { PlankElement } from "sk/data/scheme/database/furniture/element/PlankElement";
    type PlankBuilderHoleSurface = ComplexHoleSurface | {
        surface: SectionSurface;
        holes: SectionSurface[];
    };
    type PlankBuilderOption = {
        holeSurface: PlankBuilderHoleSurface;
        familyInfoId: string;
        cutSideToMilling: boolean;
    };
    export class PlankBuilder {
        protected static DEFAULT_ARC_EDGE_LENGTH: number;
        option: PlankBuilderOption;
        protected static _schemeConfigService: SchemeConfigService;
        constructor(option?: PlankBuilderOption);
        createAsync(context: ElementPerformerContext, parentElement: Element): Promise<ResultObject<Element>>;
        static createPlankElementByHoleSurfaceAsync(context: ElementPerformerContext, parentElement: Element, holeSurface: PlankBuilderHoleSurface, familyInfoId?: string, cutSideToMilling?: boolean): Promise<ResultObject<Element>>;
        static mergePlanks(planks: Array<PlankNode>, bathroomNode: PatternInstanceElement): Array<Vector2>;
        private static polygonMerger;
        static canPlanksMerge(planks: Array<PlankNode>, tolerance?: number): boolean;
        private static isMergeablePlank;
        static mergePlankAsync(context: ElementPerformerContext, plankElement1: PlankElement, plankElement2: PlankElement, parentElement: Element, cutSideToMilling?: boolean): Promise<ResultObject<PlankElement>>;
        static mergePlankNodeAsync(context: ElementPerformerContext, plank1: PlankNode, plank2: PlankNode, parentElement: Element, cutSideToMilling?: boolean): Promise<ResultObject<PlankElement>>;
        static createComplexHoleSurface(outline: Vector2[], holes: Vector2[][]): ComplexHoleSurface;
        static offsetSurface(orgSurface: SectionSurface): {
            surface: SectionSurface;
            offsetPt: Vector2;
        };
        static createSubPlankFromSectionAsync(context: ElementPerformerContext, surface: SectionSurface, plankElement: PlankElement, parentElement: ContentElement, cutSideToMilling?: boolean): Promise<ResultObject<any>>;
        static createPlankFromSectionAsync(context: ElementPerformerContext, surface: SectionSurface, plankElement: PlankElement, parentElement: ContentElement, cutSideToMilling?: boolean): Promise<ResultObject<any>>;
        static partitionPlankAsync(context: ElementPerformerContext, plankElement: PlankElement, path: Vector2[], parentElement: ContentElement, cutSideToMilling?: boolean): Promise<ResultObject<any>>;
        private static computeNewId;
        static getPlankOutline(plank: PlankNode): Array<Vector3>;
        static cutPlankAsync(context: ElementPerformerContext, plankNode: PlankNode, plankElement: PlankElement, path: Vector2[], parentElement: ContentElement, gap?: number): Promise<ResultObject<any>>;
        static getSectionPoints(sectionSurface: SectionSurface): Array<Vector2>;
        static createPlankBySectionSurfaceAsync(context: ElementPerformerContext, sectionSurface: SectionSurface, plankElement: PlankElement, parentElement: ContentElement, path: Array<Vector2>, gap?: number): Promise<ResultObject>;
        static buildTilesByPartsAsync(context: ElementPerformerContext, polygon: Array<Vector2>, parent: ContentElement, plankElement: PlankElement): Promise<ResultObject>;
        static offsetLinePoints(polygon: Array<Vector2>, path: Array<Vector2>, gap?: number): Array<Vector2>;
        static cutPlank(plankElement: PlankElement, holeSurface: PlankBuilderHoleSurface, cutSideToMilling: boolean, resetSymbol?: boolean): void;
        static getHoleSurfaceByOffset(holeSurface: PlankBuilderHoleSurface, origin: Value2): PlankBuilderHoleSurface;
        static getSectionSurfaceByOffset(surface: SectionSurface, origin: Value2): SectionSurface;
        static cutHoleToMillingByHoles(plankElement: PlankElement, holes: SectionSurface[]): void;
        static cutPlankElementToMillingBySurface(plankElement: PlankElement, surface: SectionSurface): void;
        static isSideCurve(plankElement: PlankElement, curve: LineCurve2d): boolean;
        static cutPlankElementToEdgeBySurface(plankElement: PlankElement, surface: SectionSurface): void;
        static getEdgeSurfaceDecorateValueStructure(plankElement: PlankElement): DecorateValueStructure;
        static getPlankSymbolBySurface(surface: SectionSurface): {
            lengthX: number;
            lengthY: number;
            x: number;
            y: number;
        };
    }
}
declare module "sk/data/scheme/model/spliter/surrounder/SurrounderBase" {
    import { PolygonCurve3d } from 'foundation/runtime/geometry/curve3d/PolygonCurve3d';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { SpliterBase } from "sk/data/scheme/model/spliter/spliter/SpliterBase";
    export class SurrounderBase {
        host: SpliterBase;
        polygon: PolygonCurve3d;
        directCd: RelativeDirectionEnum;
        constructor();
    }
}
declare module "sk/data/scheme/model/spliter/surrounder/SubSurrounder" {
    import { Surrounder } from "sk/data/scheme/model/spliter/surrounder/Surrounder";
    import { SurrounderBase } from "sk/data/scheme/model/spliter/surrounder/SurrounderBase";
    export class SubSurrounder extends SurrounderBase {
        surface: Surrounder;
        coplane: SubSurrounder;
    }
}
declare module "sk/data/scheme/model/spliter/surrounder/Surrounder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { SubSurrounder } from "sk/data/scheme/model/spliter/surrounder/SubSurrounder";
    import { SurrounderBase } from "sk/data/scheme/model/spliter/surrounder/SurrounderBase";
    export class Surrounder extends SurrounderBase {
        subSurrounders: Types<SubSurrounder>;
        constructor();
    }
}
declare module "sk/data/scheme/model/spliter/spliter/SpliterTypeEnum" {
    export class SpliterTypeEnum {
        static SpaceSpliter: string;
        static ContentSpliter: string;
    }
}
declare module "sk/data/scheme/model/spliter/spliter/SpliterBase" {
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { Surrounder } from "sk/data/scheme/model/spliter/surrounder/Surrounder";
    import { SpliterTypeEnum } from "sk/data/scheme/model/spliter/spliter/SpliterTypeEnum";
    export class SpliterBase {
        name: string;
        type: SpliterTypeEnum;
        box: BoundaryBox;
        surrounders: Array<Surrounder>;
        constructor();
    }
}
declare module "sk/data/scheme/model/spliter/spliter/ContentSpliter" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SpliterBase } from "sk/data/scheme/model/spliter/spliter/SpliterBase";
    export class ContentSpliter extends SpliterBase {
        content: ContentNode;
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/ChestViewController" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ChestNodeData } from "sk/data/scheme/database/floorplan/model/util/ChestNodeData";
    export abstract class ChestViewController {
        static getController(viewType: ObserverModeEnum): ChestViewControllerFront;
        abstract setupData(data: ChestNodeData): void;
        protected setPolygon(polygon: Array<Vector2>, lengthX: number, lengthY: number): void;
    }
    class ChestViewControllerFront extends ChestViewController {
        setupData(data: ChestNodeData): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/ChestNodeData" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    import { ChestViewController } from "sk/data/scheme/database/floorplan/model/util/ChestViewController";
    export type PropertyChestViewString = "left" | "bottom" | "back" | "width" | "height" | "depth";
    export type ChestPlankViewData = {
        polygon: Array<Vector2>;
        bound: Array<number>;
        startDepth: number;
        endDepth: number;
        viewPlaceCd: ContentPlaceTypeEnum;
    };
    export type AroundPlankInfo = {
        startDepth: number;
        startThickness: number;
        plank: PlaneNode;
    };
    export class ChestNodeData {
        chest: WareNode;
        viewType: ObserverModeEnum;
        viewController: ChestViewController;
        matrix: Matrix3d;
        zDirection: Vector3;
        polygon: Array<Vector2>;
        depth: number;
        depthList: Array<number>;
        worldMatrix: Matrix3d;
        invertMatrix: Matrix4;
        parallelPlanks: PlaneNode[];
        verticalPlanks: PlaneNode[];
        plankInfos: Map<string, ChestPlankViewData>;
        private _dirty;
        computeSpaceDepth: number;
        plankSpaceMap: Map<string, Map<string, Array<SpaceNode>>>;
        private computorFunMap;
        children: Array<ChestNodeData>;
        constructor(chest: WareNode, viewType: ObserverModeEnum, vector?: Vector3);
        reset(): void;
        dirty(): void;
        undirty(): void;
        isDirty(): boolean;
        getPlankInfo(plank: PlaneNode): ChestPlankViewData;
        setupByViewType(): void;
        plankDepthSort: (plankA: PlaneNode, plankB: PlaneNode) => number;
        private isPlankParallel;
        private isPlankVertical;
        getTabNext(currentSpaceNode: SpaceNode, loopInGroup?: boolean): SpaceNode;
        getTabPre(currentSpaceNode: SpaceNode, loopInGroup?: boolean): SpaceNode;
        private getPlankInfoDirValue;
        private getPlankInfoDirThickness;
        private isPlanksDepthCover;
        private isPlanksDirCover;
        getAroundFrontBackPlankInfo(info: ChestPlankViewData, dir: string, getClose?: boolean, closeDistance?: number): AroundPlankInfo;
        getInfoFrontBackPlank(info: ChestPlankViewData, dir: string, getClose?: boolean, closeDistance?: number): PlaneNode;
        getInfoFrontBackPlanks(info: ChestPlankViewData, dir: string, getClose?: boolean, closeDistance?: number): PlaneNode[];
        getAroundPlankInfo(info: ChestPlankViewData, placeCd: ContentPlaceTypeEnum, dir: string, getClose?: boolean, closeDistance?: number, depthAdjacent?: boolean, getInside?: boolean): AroundPlankInfo;
        getInfoDirPlank(info: ChestPlankViewData, placeCd: ContentPlaceTypeEnum, dir: string, getClose?: boolean, closeDistance?: number, depthAdjacent?: boolean, getInside?: boolean): PlaneNode;
        getInfoDirPlanks(info: ChestPlankViewData, placeCd: ContentPlaceTypeEnum, dir: string, getClose?: boolean, closeDistance?: number, depthAdjacent?: boolean, getInside?: boolean): PlaneNode[];
        static getReverseDir(dir: string): string;
        getPlankDirPlank(plank: PlaneNode, dir: string): PlaneNode;
        getYZPlankVerticalPlanks(plank: PlaneNode, dir: string): Array<PlaneNode>;
        getXYPlankVerticalPlanks(plank: PlaneNode, dir: string): Array<PlaneNode>;
        getPlanksByPlaceCd(placeCd: ContentPlaceTypeEnum): Array<PlaneNode>;
        resetSpaceInfo(): void;
        getPlankDirSpaces(plank: PlaneNode, dir: string): Array<SpaceNode>;
        setPlankSpaceDir(planks: Array<PlaneNode>, dir: string, space: SpaceNode): void;
        getPlankDirPlank2(plank: PlaneNode, dir: string): PlaneNode;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/INodeSpatialable" {
    import { CoplaneNodes } from 'foundation/data/common/model/spatial/CoplaneNode';
    import { Spatialable } from 'foundation/data/common/model/spatial/Spatialable';
    export interface INodeSpatialable extends Spatialable {
        coplanes: CoplaneNodes;
    }
}
declare module "sk/data/scheme/database/furniture/model/SpaceNode" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PolygonSurface } from 'foundation/runtime/geometry/surface/PolygonSurface';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { CoplaneNodes } from 'foundation/data/common/model/spatial/CoplaneNode';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { ChestNodeData } from "sk/data/scheme/database/floorplan/model/util/ChestNodeData";
    import { INodeSpatialable } from "sk/data/scheme/database/furniture/model/spatial/INodeSpatialable";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SpaceShapeNode } from "sk/data/scheme/database/furniture/model/SpaceShapeNode";
    export type PolygonSideInfo = {
        begin: Vector3;
        end: Vector3;
        planks: PlankNode[];
    };
    export type SidePlankInfo = {
        begin: Vector2;
        end: Vector2;
        startDepth: number;
        startThickness: number;
        planks: PlankNode[];
    };
    export class SpaceNode extends ContentNode implements INodeSpatialable {
        static CLASS_NAME: string;
        chestData: ChestNodeData;
        backPlank: PlankNode;
        startDepth: number;
        endDepth: number;
        points2d: Array<Vector2>;
        matrix: Matrix3d;
        spaceMatrix: Matrix3d;
        localX: number;
        localY: number;
        box: Box3;
        protected _sidePlankInfos: Array<SidePlankInfo>;
        protected _sidePlankMap: Map<string, {
            begin: Vector2;
            end: Vector2;
        }>;
        protected _dirSidePlankInfo: Map<string, SidePlankInfo>;
        tabIndex: {
            groupId: number;
            indexInGroup: number;
        };
        protected _coplanes: CoplaneNodes;
        viewVector: Vector3;
        polygon: PolygonSurface;
        sideInfos: PolygonSideInfo[];
        planeMatrix: Matrix3d;
        reverseMatrix: Matrix3d;
        isNewType: boolean;
        depthList: number[];
        spaceShapeNode: SpaceShapeNode;
        constructor();
        get depth(): number;
        getLeftPlanks(): Array<PlankNode>;
        getRightPlanks(): Array<PlankNode>;
        getTopPlanks(): Array<PlankNode>;
        getBottomPlanks(): Array<PlankNode>;
        getLeftSidePlankInfo(): SidePlankInfo;
        getRightSidePlankInfo(): SidePlankInfo;
        getTopSidePlankInfo(): SidePlankInfo;
        getBottomSidePlankInfo(): SidePlankInfo;
        setProperty(): void;
        private setMatrix;
        private setBoxInChest;
        private setSidePlankInfos;
        private setDirSidePlankInfo;
        getDirValue(dir: string): number;
        getDirPlanks(dir: string): Array<PlankNode>;
        getPlankSideLine(plank: PlankNode): {
            begin: Vector2;
            end: Vector2;
        };
        private isLineOnPolygon;
        private isPointInSegmengt;
        getBoxMatrix(): Matrix3d;
        getLocal2dMatrix(): Matrix3d;
        getLocalPolygon2d(): Vector2[];
        getLocalSide2dInfos(): PolygonSideInfo[];
        getSidePlanks(sideType: "left" | "right" | "top" | "bottom"): PlankNode[];
        get coplanes(): CoplaneNodes;
        getPositionX(): number;
        getPositionY(): number;
        getPositionZ(): number;
        getWidth(): number;
        getDepth(): number;
        getHeight(): number;
        getRotateX(): number;
        getRotateY(): number;
        getRotateZ(): number;
        canEdit(): boolean;
        findDirectionTargets(directionCd: RelativeDirectionEnum): Array<INodeSpatialable>;
        assignBox(box: Box3): void;
        updateCoplanes(): void;
        computeBoundary(recursive?: boolean): Box3;
        computeCoplaneTargets(spatialables: Array<INodeSpatialable>): any;
        computeJoiner(): void;
    }
}
declare module "sk/data/scheme/model/spliter/spliter/SpaceSpliter" {
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    import { SpliterBase } from "sk/data/scheme/model/spliter/spliter/SpliterBase";
    export class SpaceSpliter extends SpliterBase {
        space: SpaceNode;
    }
}
declare module "sk/data/scheme/model/spliter/EntireSpace" {
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    import { ContentSpliter } from "sk/data/scheme/model/spliter/spliter/ContentSpliter";
    import { SpaceSpliter } from "sk/data/scheme/model/spliter/spliter/SpaceSpliter";
    export class EntireSpace {
        spaceSpiters: Array<SpaceSpliter>;
        contentSpiters: Array<ContentSpliter>;
        boundaryBox: BoundaryBox;
        planes: Array<PlaneNode>;
        content: ChestNode;
        constructor();
    }
}
declare module "sk/data/scheme/database/furniture/model/ChestNode" {
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { AssemblyNode } from 'sk/data/family/model/instance/AssemblyNode';
    import { EntireSpace } from "sk/data/scheme/model/spliter/EntireSpace";
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    export class ChestNode extends AssemblyNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        entireSpace: EntireSpace;
        static FIELD_DIMENSION_IDENTIFY: string;
        dimensionIdentify: StringBuffer;
        constructor();
        createSpaceNode(): SpaceNode;
        dispose(): void;
        static create(document: Document): ChestNode;
    }
    export type ChestNodeMap = {
        [key: string]: ChestNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/util/PlankUtil" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d, SingleCurve2d } from 'foundation/runtime/geometry/Curve2d';
    import { EdgeOverrideEnum } from 'foundation/data/common/define/EdgeOverrideEnum';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { OpeningEdgeElement } from 'sk/data/family/element/instance/OpeningEdgeElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    export class PlankUtil {
        static ROTATION_TOLERANCE: number;
        static _matrix: Matrix4;
        static useSimplifyShapeMode(plankNode: PlankNode): boolean;
        static cutPlankInChestAsync(context: IContext, plank: PlankNode, option?: {
            checkThickness: boolean;
            cutSideToMilling: boolean;
            spaceNode: SpaceNode;
        }): Promise<ResultObject>;
        private static setPlankRotationFromPlaceCd;
        private static setPlankPlaceCdFromRotation;
        private static cutPlankAsync;
        static createSectionSurfaceEdgeNode(plane: PlankNode, section: SectionSurface): void;
        static createSectionSurfaceEdgeAsync(context: IContext, plane: PlaneElement, plank: PlankNode, section: SectionSurface, edgeSections?: Array<Curve2d>, edgeCurves?: Array<SingleCurve2d>, tolerance?: number): Promise<void>;
        static createPlankSectionAndEdge(rawCurve: Curve2d, extCurve: Curve2d, distance: number, tolerance?: number, lerpTolerance?: number): {
            section: SectionSurface;
            edgeSections: Array<Curve2d>;
            edgeCurves: Array<SingleCurve2d>;
            m: Matrix4;
        };
        static isRightMargin(entity: PlankNode): any;
        static isTopMargin(entity: PlankNode): any;
        static computeMatrix(plank: PlankNode, matrix?: Matrix4): any;
        static computeLhMatrix(plank: PlankNode, matrix?: Matrix4): Matrix4;
        static computeRhMatrix(plank: PlankNode): Matrix4;
        static computeExtendLength(thickness: number, mode: EdgeOverrideEnum): number;
        static createOpeningEdgeElementFromPolygon(structure: FamilyStructure, polygon: Array<Value2>, height: number, placeCd?: ContentPlaceTypeEnum): OpeningEdgeElement;
        static createPlaneElementContentFromPolygon(plank: PlaneElement, polygon: Array<any>, height: number | string): void;
        static createPlankFromPolygon(document: DataDocument, polygon: Array<Value2>, height: number, placeCd?: ContentPlaceTypeEnum): PlaneNode;
        private static makeEdgeSurfaceCurve;
        private static makeEdgeSurfaceElement;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/OpeningGroupPlaneElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { OpeningEdgeElement } from 'sk/data/family/element/instance/OpeningEdgeElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { SchemeDocumentService, SchemeWorkflowOptions } from "sk/data/scheme/service/SchemeDocumentService";
    export class OpeningGroupPlaneElementUtil {
        protected static _calculatorService: CalculatorService;
        protected static _schemeDocumentService: SchemeDocumentService;
        protected static _schemeConfigService: SchemeConfigService;
        static createHolePlaneAsync(context: ElementPerformerContext, parent: BrepElement, node: GroupNode, height?: number, tolerance?: number, lerpTolerance?: number): Promise<ResultObject<Array<PlaneElement>>>;
        static createHolePlaneAsync2(context: ElementPerformerContext, parent: BrepElement, node: GroupNode, height?: number, tolerance?: number, lerpTolerance?: number): Promise<ResultObject<Array<PlaneElement>>>;
        static createHolePlaneAsync3(context: ElementPerformerContext, parent: BrepElement, node: GroupNode, height?: number, tolerance?: number, lerpTolerance?: number): Promise<ResultObject<Array<PlaneElement>>>;
        private static getSurfaces;
        private static getEdges;
        private static getCurveId;
        private static createBreps;
        static createTemplatePlank(parent: BrepElement, hight?: number): OpeningEdgeElement;
        static updateSurfaceElementDecorate(plankElement: OpeningEdgeElement, parent?: BrepElement): void;
        static computeWorkflowVisonAsync(element?: Element, options?: SchemeWorkflowOptions, technologyValid?: boolean): Promise<ResultObject>;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/RateVector2" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class RateVector2 extends Vector2 {
        rate: number;
        content: any;
        static sortRateAsc(left: RateVector2, right: RateVector2): number;
        static from(value: Value2, rate?: number, content?: any): RateVector2;
        static toContentArray<T>(array: RateVector2[]): Array<T>;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/RoomElementSplitterUtil" {
    import { SchemeProcessContext } from "sk/data/scheme/util/SchemeProcessContext";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    import { JoinnerLoopCache } from "sk/data/scheme/database/floorplan/element/util/WallJoinnerElementUtil";
    export class RoomElementSplitterUtil {
        static findAllLoops(points: Array<WallPointElement>): Array<Array<WallJoinnerElement>>;
        static findAllLoopsByLinePoints(points: Array<WallPointElement>, loops: Array<Array<WallJoinnerElement>>, cache: JoinnerLoopCache): Array<Array<WallJoinnerElement>>;
        private static splitByWall;
        private static addBrakInfo;
        private static findConnectRooms;
        private static checkPointInRoom;
        private static checkTwiceRoom;
        private static getRelatedRoomByPoints;
        static splitByWalls(context: SchemeProcessContext, walls: Array<WallElement>, move?: boolean): any;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/TransactionElementUtil" {
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { Element, ElementMap } from 'sk/data/family/element/base/Element';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { GroupElement } from 'sk/data/family/element/brep/GroupElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    import { CeilingElement } from "sk/data/scheme/database/floorplan/element/CeilingElement";
    import { CeilingSurfaceElement } from "sk/data/scheme/database/floorplan/element/CeilingSurfaceElement";
    import { CowallElement } from "sk/data/scheme/database/floorplan/element/CowallElement";
    import { FloorElement } from "sk/data/scheme/database/floorplan/element/FloorElement";
    import { FloorplanElement } from "sk/data/scheme/database/floorplan/element/FloorplanElement";
    import { FloorSurfaceElement } from "sk/data/scheme/database/floorplan/element/FloorSurfaceElement";
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    import { WallJoinnerElement } from "sk/data/scheme/database/floorplan/element/WallJoinnerElement";
    import { WallPointElement } from "sk/data/scheme/database/floorplan/element/WallPointElement";
    type TrackerChildInfo = {
        parent: Element;
        child: Element;
    };
    type TrackerChildInfoMap = {
        [key: string]: TrackerChildInfo;
    };
    export class TrackerInfo {
        document: SchemeDocument;
        created: TrackerChildInfoMap;
        changed: ElementMap;
        removed: TrackerChildInfoMap;
        constructor();
        pushCreated(parent: Element, child: Element): void;
        pushChanged(element: Element): void;
        pushRemoved(parent: Element, child: Element): void;
    }
    export type StorageContentData = {
        parent: any;
        element: ContentElement;
        host: any;
        x: any;
        y: any;
        z: any;
        rotationX: any;
        rotationY: any;
        rotationZ: any;
        scaleX: any;
        scaleY: any;
        scaleZ: any;
        flags: number;
    };
    export type StorageGroupData = {
        parent: BrepElement;
        element: FamilyInstanceElement;
        flags: number;
        host: any;
        x: number;
        y: number;
        z: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        scaleX: number;
        scaleY: number;
        scaleZ: number;
    };
    export type StorageJoinnerData = {
        element: WallJoinnerElement;
        flags: number;
        points: Array<WallPointElement>;
        x: number;
        y: number;
        z: number;
    };
    export type StoragePointData = {
        element: WallPointElement;
        flags: number;
        joinner: WallJoinnerElement;
        x: number;
        y: number;
        z: number;
    };
    export type StorageCowallData = {
        parent: BrepElement;
        element: CowallElement;
        edge: WallElement;
        prev: CowallElement;
        next: CowallElement;
        partner: CowallElement;
        offsetDistance: number;
        reversed: boolean;
    };
    export type StorageWallData = {
        parent: BrepElement;
        element: WallElement;
        flags: number;
        openings: Array<OpeningElement>;
        contents: Array<ContentElement>;
        coedge: CowallElement;
        from: WallPointElement;
        fromX: number;
        fromY: number;
        fromZ: number;
        to: WallPointElement;
        toX: number;
        toY: number;
        toZ: number;
        width: number;
        height3d: number;
        relations: Map<string, RelationElement>;
    };
    export type StorageRoomData = {
        parent: Element;
        element: RoomElement;
        root: CowallElement;
        floor: FloorElement;
        floorSurface: FloorSurfaceElement;
        ceiling: CeilingElement;
        ceilingSurfaces: Array<CeilingSurfaceElement>;
    };
    export type StorageData = {
        [key: string]: any;
    };
    export class TransactionElementUtil {
        static saveContentData(element: ContentElement, storage: StorageData): void;
        static saveGroupData(element: GroupElement, storage: StorageData): void;
        static saveContentsData(element: FloorplanElement, storage: StorageData): void;
        static saveJoinnerData(element: WallJoinnerElement, storage: StorageData): void;
        static savePointData(element: WallPointElement, storage: StorageData): void;
        static saveCowallData(element: CowallElement, storage: StorageData): void;
        static saveWallData(element: WallElement, storage: StorageData): void;
        static saveCowallsData(floorplan: FloorplanElement, storage: StorageData): void;
        static saveRoomsData(floorplan: FloorplanElement, storage: StorageData): void;
        static saveRelationsData(floorplan: FloorplanElement, storage: StorageData): void;
        static createSorter(info1: TrackerChildInfo, info2: TrackerChildInfo): number;
        static deleteSorter(info1: TrackerChildInfo, info2: TrackerChildInfo): number;
        static changedeSorter(element1: Element, element2: Element): number;
        static updateTracker(tracker: TrackerInfo): void;
        static loadWareData(element: FamilyInstanceElement, storage: StorageData, tracker: TrackerInfo, flag: boolean): void;
        static loadWaresData(floorplan: FloorplanElement, storage: StorageData, tracker: TrackerInfo, flag: boolean): void;
        static loadContentData(element: ContentElement, storage: StorageData, tracker: TrackerInfo, flag: boolean): void;
        static loadGroupData(group: GroupElement, storage: any, tracker: TrackerInfo, flag: boolean): void;
        static loadJoinnersData(floorplan: FloorplanElement, storage: StorageData, tracker: TrackerInfo): void;
        static loadJoinnerData(floorplan: FloorplanElement, element: WallJoinnerElement, storage: StorageData, tracker: TrackerInfo): void;
        static loadPointData(floorplan: FloorplanElement, element: WallPointElement, storage: StorageData, tracker: TrackerInfo): void;
        static loadCowall(cowall: CowallElement, storage: StorageData, tracker: TrackerInfo): void;
        static loadWallData(floorplan: FloorplanElement, element: WallElement, storage: StorageData, tracker: TrackerInfo, flag: boolean): void;
        private static loadWallRelation;
        static loadCowallData(floorplan: FloorplanElement, element: CowallElement, storage: StorageData, tracker: TrackerInfo): void;
        static loadCowallsData(floorplan: FloorplanElement, storage: StorageData, tracker: TrackerInfo, flag: boolean): void;
        static loadRoomData(floorplan: FloorplanElement, storage: StorageData, tracker: TrackerInfo, room: RoomElement): void;
        static loadRoomsData(floorplan: FloorplanElement, storage: StorageData, tracker: TrackerInfo, flag: boolean): void;
        static loadRelationsData(floorplan: FloorplanElement, storage: StorageData, tracker: TrackerInfo): void;
        static saveFloorplan(floorplan: FloorplanElement, data: any): void;
        static loadFloorplan(floorplan: FloorplanElement, storage: any): void;
        static floorplanInspector(floorplan: FloorplanElement, alias: string): void;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/WallHolePlaneElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { SingleCurve2d } from 'foundation/runtime/geometry/Curve2d';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { Element } from 'sk/data/family/element/base/Element';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { OpeningEdgeElement } from 'sk/data/family/element/instance/OpeningEdgeElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { SchemeDocumentService, SchemeWorkflowOptions } from "sk/data/scheme/service/SchemeDocumentService";
    export class WallHolePlaneElementUtil {
        protected static _calculatorService: CalculatorService;
        protected static _schemeDocumentService: SchemeDocumentService;
        protected static _schemeConfigService: SchemeConfigService;
        static createHolePlaneAsync(context: ElementPerformerContext, parent: BrepElement, path: Array<{
            curve: SingleCurve2d;
            in: number;
            out: number;
        }>, hole: Array<Vector2>, ops: Array<{
            in: number;
            out: number;
            planeInfoId: string;
        }>, tolerance?: number, lerpTolerance?: number): Promise<ResultObject<Array<PlaneElement>>>;
        static createTemplatePlank(parent: BrepElement): OpeningEdgeElement;
        static updateSurfaceElementDecorate(plankElement: OpeningEdgeElement, parent?: BrepElement): void;
        static computeWorkflowVisonAsync(element?: Element, options?: SchemeWorkflowOptions, technologyValid?: boolean): Promise<ResultObject>;
        static createHolePlaneEdges(path: Array<{
            curve: SingleCurve2d;
            in: number;
            out: number;
        }>, hole: Array<Vector2>, ops: Array<{
            in: number;
            out: number;
            planeInfoId: string;
        }>, tolerance?: number, lerpTolerance?: number): Array<{
            s: SectionSurface;
            m: Matrix3d;
        }>;
    }
}
declare module "sk/data/scheme/database/floorplan/element/WallLinePointElement" {
    import { JoinnerElement } from 'sk/data/family/element/brep/JoinnerElement';
    export class WallLinePointElement extends JoinnerElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type WallLinePointElementMap = {
        [key: string]: WallLinePointElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/WallLineElement" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { WallLinePointElement } from "sk/data/scheme/database/floorplan/element/WallLinePointElement";
    export class WallLineElement extends BrepElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BEGIN: string;
        static FIELD_END: string;
        begin: WallLinePointElement;
        end: WallLinePointElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type WallLineElementMap = {
        [key: string]: WallLineElement;
    };
}
declare module "sk/data/scheme/database/floorplan/element/util/WallLineElementUtil" {
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    export class WallLineElementUtil {
        static initWallLine(wall: WallElement): void;
        static clearWallLine(wall: WallElement): void;
    }
}
declare module "sk/data/scheme/database/floorplan/element/util/WindowElementUtil" {
    import { WindowNode } from "sk/data/scheme/database/floorplan/model/WindowNode";
    import { WindowElement } from "sk/data/scheme/database/floorplan/element/WindowElement";
    export class WindowElementUtil {
        static computeWindowProfilePoints(element: WindowElement, node: WindowNode): void;
        static computeWindowOriginProfilePoints(element: WindowElement, node: WindowNode): void;
        static computePolygonWindowOriginProfile(element: WindowElement, node: WindowNode): void;
        static computePolygonWindowProfile(element: WindowElement, node: WindowNode): void;
        static computeBayWindowProfile(element: WindowElement, node: WindowNode): void;
    }
}
declare module "sk/data/scheme/database/floorplan/FloorplanStructureElement" {
    import { ElementStructure } from 'foundation/data/common/element/ElementStructure';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    export class FloorplanStructureElement extends StructureElement {
        static CLASS_NAME: string;
        static FIELD_LENGTH_X: string;
        static FIELD_LENGTH_Y: string;
        static FIELD_LENGTH_Z: string;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        constructor();
        reset(): void;
        static create(familyStructure: ElementStructure): FloorplanStructureElement;
    }
    export type FloorplanStructureElementMap = {
        [key: string]: FloorplanStructureElement;
    };
}
declare module "sk/data/scheme/database/floorplan/FloorplanFamilyStructure" {
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { FloorplanStructureElement } from "sk/data/scheme/database/floorplan/FloorplanStructureElement";
    export class FloorplanFamilyStructure extends FamilyStructure {
        static CLASS_NAME: string;
        structure: FloorplanStructureElement;
        constructor();
        setup(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/AreaNode" {
    import { LoopNode } from 'foundation/data/common/model/brep/LoopNode';
    export class AreaNode extends LoopNode {
    }
}
declare module "sk/data/scheme/database/floorplan/model/BaseboardNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    export class BaseboardNode extends LinearNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BaseboardNode;
    }
    export type BaseboardNodeMap = {
        [key: string]: BaseboardNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/BeamSurfaceTypeEnum" {
    export class BeamSurfaceTypeEnum {
        static Top: string;
        static Bottom: string;
        static Inner: string;
        static Outer: string;
        static From: string;
        static To: string;
        static Items: Array<string>;
    }
}
declare module "sk/data/scheme/database/floorplan/model/CorniceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    export class CorniceNode extends LinearNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): CorniceNode;
    }
    export type CorniceNodeMap = {
        [key: string]: CorniceNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/CowallMoldingNode" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class CowallMoldingNode extends DataNode {
    }
}
declare module "sk/data/scheme/database/floorplan/model/CurtainComponentEnum" {
    export class CurtainComponentEnum {
        static Side: string;
        static Loop: string;
        static Screen: string;
        static Rail: string;
        static RailTips: string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/CurtainNode" {
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    export class CurtainNode extends ContentInstanceNode {
        _disabledComponents: any;
        _materialByComponent: any;
        signalComponentDisabled: any;
        signalComponentEnabled: any;
        signalMaterialChanged: any;
        constructor();
        getComponentEnumKeyByValue(a: any): any;
        isComponentAvailable(a: any): boolean;
        getMaterial(a: any): any;
        setMaterial(a: any, b: any): void;
        isComponentEnabled(a: any): boolean;
        disableComponentNumber(): number;
        disableComponent(a: any): void;
        enableComponent(a: any): void;
        getDisabledComponents(): any;
        getEnabledComponents(): any;
    }
}
declare module "sk/data/scheme/database/floorplan/model/spatial/GraphicBox" {
    import { BaseBox } from 'foundation/data/common/model/spatial/BaseBox';
    export class GraphicBox extends BaseBox {
        compute(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/spatial/CustomizedGraphicBox" {
    import { GraphicBox } from "sk/data/scheme/database/floorplan/model/spatial/GraphicBox";
    export class CustomizedGraphicBox extends GraphicBox {
    }
}
declare module "sk/data/scheme/database/floorplan/model/CustomizedNode" {
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class CustomizedNode extends FamilyInstanceNode {
        configUrl: string;
        referDocument: DataDocument;
        graphicBox: any;
        constructor();
        testReady(): boolean;
        load(): void;
        reloadDocument(document: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/CustomizedPlateNode" {
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    export class CustomizedPlateNode extends ContentInstanceNode {
        draggable: string;
        plateData: string;
        private dTrunc;
        private trunc;
        private obj2V2;
        private dObj2V2;
    }
}
declare module "sk/data/scheme/database/floorplan/model/DoorFrameNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class DoorFrameNode extends FamilyInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): DoorFrameNode;
    }
    export type DoorFrameNodeMap = {
        [key: string]: DoorFrameNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/DoorLeafNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class DoorLeafNode extends FamilyInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): DoorLeafNode;
    }
    export type DoorLeafNodeMap = {
        [key: string]: DoorLeafNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/geometry/WallGeometryUtil" {
    import { Graph, GraphCoedge, GraphEdge, GraphLoop, GraphVertice } from 'foundation/runtime/math/Graph';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { SingleCurve2d } from 'foundation/runtime/geometry/Curve2d';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { SchemeElementPerformerContext } from "sk/data/scheme/performer/element/SchemeElementPerformerContext";
    import { SchemeDocumentService } from "sk/data/scheme/service/SchemeDocumentService";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    export class WallEdgeData {
        isOffseted: boolean;
        node: WallNode;
        curve: SingleCurve2d;
        surface: SectionSurface;
        uSurface: SectionSurface;
        vSurface: SectionSurface;
        brep: BrepBody;
        openings: OpeningNode[];
        getBeginTangent(): Vector3;
        getEndTangent(): Vector3;
    }
    export class WallPoint {
        p: Vector3;
        verticeCurves: SingleCurve2d[];
        node: WallPointNode;
        isMyCurve(c: SingleCurve2d, tolerance?: number): boolean;
    }
    export class WallGraphVertice extends GraphVertice<WallPoint, WallEdgeData> {
        d: WallPoint;
        edges: Array<WallGraphEdge>;
        id: string;
        get graphId(): string;
        topologyEquals(value: WallGraphVertice, tolerance?: number): boolean;
        nearlyEquals(value: WallGraphVertice, tolerance?: number): boolean;
        isMyPoint(v: Vector3, tolerance?: number): boolean;
        get degree(): number;
        get indegree(): number;
        get outdegree(): number;
        get inEdges(): Array<WallGraphCoedge>;
        get outEdges(): Array<WallGraphCoedge>;
        getExtebdEdge(curve: LineCurve2d): WallGraphCoedge;
    }
    export class WallGraphEdge extends GraphEdge<WallPoint, WallEdgeData> {
        protected _u: WallGraphVertice;
        protected _v: WallGraphVertice;
        protected _d: WallEdgeData;
        coedge1: WallGraphCoedge;
        coedge2: WallGraphCoedge;
        id: string;
        get graphId(): string;
        get u(): WallGraphVertice;
        set u(u: WallGraphVertice);
        get v(): WallGraphVertice;
        set v(v: WallGraphVertice);
        get d(): WallEdgeData;
        set d(d: WallEdgeData);
        cut(v: WallGraphVertice, tolerance?: number): void;
        isMyCurve(c: SingleCurve2d, tolerance?: number): boolean;
        topologyEquals(value: WallGraphEdge, tolerance?: number): boolean;
        nearlyEquals(value: WallGraphEdge, tolerance?: number): boolean;
        nearlyHaveCoincide(value: WallGraphEdge, tolerance?: number): boolean;
        isMyPoint(v: Vector3, tolerance?: number): boolean;
        isPointInside(v: Vector3, tolerance?: number): boolean;
    }
    export class WallGraphCoedge extends GraphCoedge<WallPoint, WallEdgeData> {
        protected _u: WallGraphVertice;
        protected _v: WallGraphVertice;
        protected _edge: WallGraphEdge;
        curve: SingleCurve2d;
        loop: WallGraphLoop;
        id: string;
        get graphId(): string;
        get isForward(): boolean;
        get u(): WallGraphVertice;
        set u(u: WallGraphVertice);
        get v(): WallGraphVertice;
        set v(v: WallGraphVertice);
        set edge(edge: WallGraphEdge);
        get edge(): WallGraphEdge;
        get d(): WallEdgeData;
        get brother(): WallGraphCoedge;
        topologyEquals(value: WallGraphCoedge, tolerance?: number): boolean;
        nearlyEquals(value: WallGraphCoedge, tolerance?: number): boolean;
        isMyPoint(v: Vector3, tolerance?: number): boolean;
        isPointInside(v: Vector3, tolerance?: number): boolean;
        isMyCurve(c: SingleCurve2d, tolerance?: number): boolean;
    }
    export class WallGraphLoop extends GraphLoop<WallPoint, WallEdgeData> {
        edges: Array<WallGraphCoedge>;
        surface: SectionSurface;
        graph: WallGraph;
        id: string;
        get graphId(): string;
        get isConected(): boolean;
        get isClosed(): boolean;
        isNearlyClosed(tolerance?: number): boolean;
        removeEdge(edge: WallGraphCoedge): void;
        addEdge(edge: WallGraphCoedge): void;
        getCurves(): Array<SingleCurve2d>;
        topologyEquals(value: WallGraphLoop, tolerance?: number): boolean;
    }
    export class WallGraph extends Graph<WallPoint, WallEdgeData> {
        vertices: Array<WallGraphVertice>;
        edges: Array<WallGraphEdge>;
        loops: Array<WallGraphLoop>;
        brep: BrepBody;
        private static _graphId;
        id: string;
        private _verticeId;
        private _edgeId;
        private _coedgeId;
        private _loopId;
        constructor();
        getVerticeId(): string;
        getEdgeId(): string;
        getCoedgeId(): string;
        getLoopId(): string;
        static getGraphId(): string;
        addCutVertice(v: Vector3, tolerance?: number): WallGraphVertice;
        addGraphEdge(u: WallGraphVertice, v: WallGraphVertice, d: WallEdgeData): WallGraphEdge;
        removeGraphEdge(e: WallGraphEdge): void;
        removeGraphEdgeByNode(node: WallNode): void;
        removeAllZeroDegreeVertice(): void;
        removeAllZeroLengthEdge(): void;
        getVerticeByPoint(v: Vector3, tolerance?: number): WallGraphVertice;
        getEdgeByPoint(v: Vector3, tolerance?: number): WallGraphEdge;
        getEdgeByNode(node: WallNode): WallGraphEdge;
        getEdgeByCurve(c: SingleCurve2d, tolerance?: number): WallGraphEdge;
        getCoedges(): Array<WallGraphCoedge>;
        getCurves(): Array<SingleCurve2d>;
        getCurvesNotThis(edge: WallGraphEdge): Array<SingleCurve2d>;
        addCutEdge(u: WallGraphVertice, v: WallGraphVertice, c: SingleCurve2d, node: WallNode, tolerance?: number): WallGraphEdge;
        clipper(): Array<WallGraphLoop>;
        getMinLoop(currCoedge: WallGraphCoedge, coedges: Array<WallGraphCoedge>, dones: Array<WallGraphCoedge>): WallGraphLoop;
        topologyEquals(value: WallGraph, tolerance?: number): boolean;
    }
    export class WallGeometryUtil {
        static WALL_SURFACE_DRAW_MODE: string;
        static SURFACE_MODE: string;
        static BREP_MODE: string;
        static DEFAULT_MODE: string;
        static CURRENT_MODE: string;
        static isFast: boolean;
        private static _wallGraph;
        protected static _schemeDocumentService: SchemeDocumentService;
        static get wallGraph(): WallGraph;
        static reset(): void;
        static computeNode(node: WallNode, curve?: SingleCurve2d, isOffseted?: boolean, graph?: WallGraph, tolerance?: number, lerpTolerance?: number): void;
        static computeGraph(context: SchemeElementPerformerContext, graph?: WallGraph, tolerance?: number, lerpTolerance?: number): void;
        static computeBottomSurface(graph?: WallGraph, tolerance?: number): void;
        static computeEdgeBrep(context: SchemeElementPerformerContext, graph?: WallGraph, tolerance?: number): void;
        static computeMergeBrep(context: SchemeElementPerformerContext, graph?: WallGraph, tolerance?: number): void;
        static computeSurfaceNode(context: SchemeElementPerformerContext, graph?: WallGraph, tolerance?: number): void;
        static computeMergeSurfaceNode(context: SchemeElementPerformerContext, graph?: WallGraph, tolerance?: number): void;
        private static computeAreaFaceNode;
        private static computeFaceNodeMatrix;
        private static computeFaceNodeShape;
    }
}
declare module "sk/data/scheme/database/floorplan/model/geometry/WallMoldingGeometry" {
    export enum WallMoldingDirtyType {
        None = 0,
        Normal = 1,
        SelfOnly = 2
    }
    export class WallMoldingGeometry {
    }
}
declare module "sk/data/scheme/database/floorplan/model/HoleLinePointNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    export class HoleLinePointNode extends VertexNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): HoleLinePointNode;
    }
    export type HoleLinePointNodeMap = {
        [key: string]: HoleLinePointNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/HoleLineNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { HoleLinePointNode } from "sk/data/scheme/database/floorplan/model/HoleLinePointNode";
    export class HoleLineNode extends BrepNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BEGIN: string;
        static FIELD_INNER_DEPTH: string;
        static FIELD_OUTER_DEPTH: string;
        static FIELD_THICKNESS: string;
        static FIELD_END: string;
        begin: HoleLinePointNode;
        innerDepth: number;
        outerDepth: number;
        thickness: number;
        end: HoleLinePointNode;
        constructor();
        dispose(): void;
        static create(document: Document): HoleLineNode;
    }
    export type HoleLineNodeMap = {
        [key: string]: HoleLineNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/molding/CeilingGraphic3dStructure" {
    import { PolygonEdgeGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonEdgeGeometry';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    export class CeilingGraphic3dStructure extends MoldingGeometryStructure {
        node: RoomNode;
        ceilingPolygonGeometry: PolygonEdgeGeometry;
    }
}
declare module "sk/data/scheme/database/floorplan/model/molding/CowallGraphic3dOptions" {
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    export class CowallGraphic3dOptions extends MoldingGeometricOptions {
        isShowSide: boolean;
        constructor(isShowSide?: boolean);
        isOptionOkey(other: CowallGraphic3dOptions): boolean;
    }
}
declare module "sk/data/scheme/database/floorplan/model/molding/FloorGraphic3dStructure" {
    import { PolygonEdgeGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonEdgeGeometry';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    export class FloorGraphic3dStructure extends MoldingGeometryStructure {
        node: RoomNode;
        floorPolygonGeometry: PolygonEdgeGeometry;
    }
}
declare module "sk/data/scheme/database/floorplan/model/molding/WallGraphic3dOptions" {
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    export class WallGraphic3dOptions extends MoldingGeometricOptions {
        isShowSide: boolean;
        constructor(isShowSide?: boolean);
        isOptionOkey(other: WallGraphic3dOptions): boolean;
    }
}
declare module "sk/data/scheme/database/floorplan/model/molding/WallGraphic3dStructure" {
    import { BrepFace } from 'foundation/runtime/geometry/brep/Brep';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    export type SurfaceInfo = {
        buff: BufferGeometry;
        surface: Surface;
        face: BrepFace;
    };
    export class WallGraphic3dStructure extends MoldingGeometryStructure {
        node: WallNode;
        breps: Array<BrepBody>;
        buffers: Array<SurfaceInfo>;
        constructor();
        reset(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/molding/WallSurfaceSpatialGraphic3dOptions" {
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    export class WallSurfaceSpatialGraphic3dOptions extends MoldingGeometricOptions {
        isShowSide: boolean;
        constructor(isShowSide?: boolean);
        isOptionOkey(other: WallSurfaceSpatialGraphic3dOptions): boolean;
    }
}
declare module "sk/data/scheme/database/floorplan/model/molding/WallSurfaceSpatialGraphic3dStructure" {
    import { BrepFace } from 'foundation/runtime/geometry/brep/Brep';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { WallSurfaceSpatialNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode";
    export type SurfaceInfo = {
        buff: BufferGeometry;
        surface: Surface;
        face: BrepFace;
    };
    export class WallSurfaceSpatialGraphic3dStructure extends MoldingGeometryStructure {
        node: WallSurfaceSpatialNode;
        buffer: BufferGeometry;
        constructor();
        reset(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/molding/WallSurfaceSpatialOutline3dStructure" {
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { WallSurfaceSpatialNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode";
    export class WallSurfaceSpatialOutline3dStructure extends MoldingOutline3dStructure {
        node: WallSurfaceSpatialNode;
        reset(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/MoldingProfileNode" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export interface MoldingProfileNodeValueChangedEvent {
        (): void;
    }
    export class MoldingProfileNode extends DataNode {
    }
}
declare module "sk/data/scheme/database/floorplan/model/OperationEnum" {
    export class OperationEnum {
        static Auto: string;
        static Manual: string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/PocketEventEnum" {
    export class PocketEventEnum {
        static ProcketAdded: string;
        static ProcketRemoved: string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/PocketTypeEnum" {
    export class PocketTypeEnum {
        static InnerSide: string;
        static OuterSide: string;
        static BothSide: string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/PocketNode" {
    import { MoldingNode } from "sk/data/scheme/database/floorplan/model/MoldingNode";
    export class PocketNode extends MoldingNode {
        sizeX: number;
        sizeY: number;
        getPocketType(): string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/PolygonWallPointNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    export class PolygonWallPointNode extends VertexNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): PolygonWallPointNode;
    }
    export type PolygonWallPointNodeMap = {
        [key: string]: PolygonWallPointNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/PolygonRoomNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class PolygonRoomNode extends ContentNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_REFERENCE_INFO_ID: string;
        static FIELD_ROOMS: string;
        referenceInfoId: string;
        protected _rooms: Types<PolygonRoomNode>;
        constructor();
        get rooms(): Types<PolygonRoomNode>;
        toPolygon(): Array<Vector2>;
        dispose(): void;
        static create(document: Document): PolygonRoomNode;
    }
    export type PolygonRoomNodeMap = {
        [key: string]: PolygonRoomNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/PolygonWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { AreaPointNode } from 'sk/data/family/model/brep/area/AreaPointNode';
    export class PolygonWallNode extends BrepNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BEGIN: string;
        static FIELD_END: string;
        begin: AreaPointNode;
        end: AreaPointNode;
        constructor();
        dispose(): void;
        static create(document: Document): PolygonWallNode;
    }
    export type PolygonWallNodeMap = {
        [key: string]: PolygonWallNode;
    };
}
declare module "sk/data/scheme/database/floorplan/model/proxy/ProxyNode" {
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    export class ProxyNode extends ContentInstanceNode {
        testReady(): boolean;
        load(): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/proxy/ProductDocProxyNode" {
    import { ProxyNode } from "sk/data/scheme/database/floorplan/model/proxy/ProxyNode";
    export class ProductDocProxyNode extends ProxyNode {
    }
}
declare module "sk/data/scheme/database/floorplan/model/RenderTypeEnum" {
    export class RenderTypeEnum {
        static Vr: string;
        static Normal: string;
    }
    export class Observer {
        static Normal: string;
        static Aerial: string;
        static Bird: string;
        static Pano: string;
    }
    export class Ambient {
        static Day: string;
        static Dusk: string;
        static Night: string;
    }
    export class Resolution {
        static Low: string;
        static Penultimate: string;
        static High: string;
        static Superb: string;
    }
    export class Ratio {
        static R16_9: string;
        static R4_3: string;
        static R3_4: string;
        static R2_1: string;
        static getWHRate(ratioCd: string): number;
        static getHWRate(ratioCd: string): number;
    }
    export class TypeCode {
        static SAA: string;
        static SAB: string;
        static SAC: string;
        static SAD: string;
        static SBA: string;
        static SBB: string;
        static SBC: string;
        static SBD: string;
        static SCA: string;
        static SCB: string;
        static SCC: string;
        static SCD: string;
        static BAA: string;
        static BAB: string;
        static BAC: string;
        static BAD: string;
        static BBA: string;
        static BBB: string;
        static BBC: string;
        static BBD: string;
        static BCA: string;
        static BCB: string;
        static BCC: string;
        static BCD: string;
        static PDA: string;
        static PDB: string;
        static PDC: string;
        static PDD: string;
        static toDisplay(typeCd: string): string;
        static getBackEndTypeCd(typeCd: string): string;
        static getTypeCode(type: string, ratio: string, resolution: string): string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/RoomSurfaceTypeEnum" {
    export class RoomSurfaceTypeEnum {
        static Floor: string;
        static Ceiling: string;
    }
}
declare module "sk/data/scheme/database/floorplan/model/spatial/GroupGraphicBox" {
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { GraphicBox } from "sk/data/scheme/database/floorplan/model/spatial/GraphicBox";
    export class GroupGraphicBox extends GraphicBox {
        node: GroupNode;
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/MoldingUtil" {
    export enum LineEquationType {
        Normal = 0,
        XParallel = 1,
        YParallel = 2
    }
    export class MoldingUtil {
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/ProfileParserUtil" {
    export class ProfileAction {
        typeCd: any;
        parameters: any;
        constructor(typeCd: string, parameters: any);
    }
    export class ProfileParserUtil {
    }
}
declare module "sk/data/scheme/database/floorplan/model/util/WallJoinnerNodeUtil" {
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    export class WallJoinnerNodeUtil {
        static isSamePoint(point1: WallPointNode, point2: WallPointNode): boolean;
        static computeWallJoinner(wallJoinner: WallJoinnerNode): void;
        static makeJoinnerOutline(joinner: WallJoinnerNode): void;
        static fetchWallByCW(joinner: WallJoinnerNode, checkFunc?: () => boolean): Array<WallNode>;
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallComplexNode" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallPointNode } from "sk/data/scheme/database/floorplan/model/WallPointNode";
    export class WallComplexNode {
        from: WallPointNode;
        to: WallPointNode;
        start: Vector2;
        end: Vector2;
        room: RoomNode;
        id: string;
        constructor(room: RoomNode);
        get width(): number;
        get length(): number;
        get center(): Vector2;
        prev: WallComplexNode;
        next: WallComplexNode;
        children: {
            [key: string]: CowallNode;
        };
        isStraightLineGroup(): boolean;
        addChild(node: CowallNode, dispatch?: boolean): void;
        protected _walls: any[];
        getRealWalls(): Array<any>;
        getProxyWalls(startPoint?: Vector2, endPoint?: Vector2): void;
        hasDoor(): boolean;
        hasWindow(): boolean;
        hasOpening(type?: string): boolean;
        getWindowList(): Array<OpeningNode>;
        getWindowNumber(): number;
        getDoorList(): Array<OpeningNode>;
        getOpeningsByType(type: any): any[];
        getOpeningData(type?: string): any;
        getDistanceToTheDoor(door: OpeningNode): number;
        get distance(): number;
        getNullWallDist(): number;
        isNullWall(): boolean;
        isRealWall(): boolean;
        get angle(): number;
        protected getMaxObj(objects: any[], op: string): any;
        protected setAreaData(area: any, to: Vector2): void;
    }
}
declare module "sk/data/scheme/database/floorplan/model/WallFlagEnum" {
    export class WallFlagEnum {
        static HeightEdited: number;
    }
}
declare module "sk/data/scheme/database/floorplan/persistent/Catalog" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class Catalog extends InstanceObject {
        id: string;
        parentId: string;
        label: string;
        title: string;
        type: string;
        icon: string;
        children: Array<Catalog>;
        constructor();
        loadJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/persistent/CatalogList" {
    import { Catalog } from "sk/data/scheme/database/floorplan/persistent/Catalog";
    export class CatalogList {
        children: Array<Catalog>;
        loadJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/persistent/MaterialInfo" {
    export class MaterialInfo {
        type: string;
        color: number;
        textureUrl: string;
    }
}
declare module "sk/data/scheme/database/floorplan/persistent/MetaInfo" {
    export class MetaInfo {
        id: string;
        skuid: string;
        name: string;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        previewUrl: string;
        topviewUrl: string;
        modelUrl: string;
        modelTextureUrl: string;
        entityCount: number;
        loadFromJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/service/CityLogicUnit" {
    import { LogicUnit } from 'foundation/data/common/logic/LogicUnit';
    export class CityLogicUnit extends LogicUnit {
        value: any;
        label: any;
        loadJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/service/DesignLogicUnit" {
    import { LogicUnit } from 'foundation/data/common/logic/LogicUnit';
    export class DesignLogicUnit extends LogicUnit {
        guid: string;
        name: string;
        houseType: string;
        houseStyle: string;
        area: number;
        aHousingEstate: string;
        colourScheme: number;
        instruction: string;
        province: string;
        city: string;
        packageId: string;
        labels: Array<string>;
        labelName: string;
    }
}
declare module "sk/data/scheme/database/floorplan/service/DesignService" {
    import { LogicUnitService } from 'foundation/data/common/logic/LogicUnitService';
    import { DesignLogicUnit } from "sk/data/scheme/database/floorplan/service/DesignLogicUnit";
    export class DesignService extends LogicUnitService<DesignLogicUnit> {
        findByGuid(guid: string): DesignLogicUnit;
        createLogicUnit(): DesignLogicUnit;
    }
}
declare module "sk/data/scheme/database/floorplan/service/FloorplanRoomConfigInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class FloorplanRoomConfigInfo extends InstanceObject {
        name: string;
        familyInfoId: string;
    }
}
declare module "sk/data/scheme/database/floorplan/service/FloorplanRoomDeclareInfo" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { FloorplanRoomConfigInfo } from "sk/data/scheme/database/floorplan/service/FloorplanRoomConfigInfo";
    export class FloorplanRoomDeclareInfo extends InstanceObject {
        defaultInfoId: string;
        rooms: Types<FloorplanRoomConfigInfo>;
        constructor();
        makeMap(): any;
    }
}
declare module "sk/data/scheme/database/floorplan/service/FloorplanConfigInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { FloorplanRoomDeclareInfo } from "sk/data/scheme/database/floorplan/service/FloorplanRoomDeclareInfo";
    export class FloorplanConfigInfo extends InstanceObject {
        rooms: FloorplanRoomDeclareInfo;
    }
}
declare module "sk/data/scheme/database/floorplan/service/FloorplanConfigService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { FloorplanConfigInfo } from "sk/data/scheme/database/floorplan/service/FloorplanConfigInfo";
    import { FloorplanRoomDeclareInfo } from "sk/data/scheme/database/floorplan/service/FloorplanRoomDeclareInfo";
    export class FloorplanConfigService extends Service {
        protected _floorplanInfo: FloorplanConfigInfo;
        protected _schemeConfigService: SchemeConfigService;
        getRoomDeclareInfoAsync(context?: ContextObject): Promise<ResultObject<FloorplanRoomDeclareInfo>>;
    }
}
declare module "sk/data/scheme/database/floorplan/service/MetaInfo" {
    export class MetaInfo {
        id: string;
        skuid: string;
        name: string;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        previewUrl: string;
        topviewUrl: string;
        modelUrl: string;
        modelTextureUrl: string;
        entityCount: number;
        loadFromJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/service/ProvinceLogicUnit" {
    import { LogicUnit } from 'foundation/data/common/logic/LogicUnit';
    import { CityLogicUnit } from "sk/data/scheme/database/floorplan/service/CityLogicUnit";
    export class ProvinceLogicUnit extends LogicUnit {
        value: any;
        label: string;
        cities: Array<CityLogicUnit>;
        loadJson(obj: any): void;
    }
}
declare module "sk/data/scheme/database/floorplan/service/TechniqueLogicUnit" {
    import { LogicUnit } from 'foundation/data/common/logic/LogicUnit';
    export class TechniqueLogicUnit extends LogicUnit {
        contentType: string;
        skuId: string;
        name: string;
        catalogTypeCd: string;
        loadJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/database/furniture/element/ChestElementUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { WareElement } from 'sk/data/family/element/instance/WareElement';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyTypeEnum } from 'sk/data/family/enumeration/FamilyTypeEnum';
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { ChestElement } from "sk/data/scheme/database/furniture/element/ChestElement";
    export class EdgeSurfaceMatchPlank {
        edgeSurface: EdgeSurfaceNode;
        plank: PlaneNode;
        static getByPlank(matches: Types<EdgeSurfaceMatchPlank>, plank: PlankNode): EdgeSurfaceMatchPlank;
        static getByEdgeSurface(matches: Types<EdgeSurfaceMatchPlank>, edgeSurface: EdgeSurfaceNode): EdgeSurfaceMatchPlank;
    }
    export class ChestElementUtil {
        static createInstance(structure: FamilyStructure): ChestElement;
        static isFamilyType(info: ISpecificationFamilyInfo, typeCd: FamilyTypeEnum): boolean;
        static findFrontPlankElement(chestElement: ChestElement): PlaneElement;
        static findFrontPlank(chestNode: ChestNode): PlaneNode;
        static findMainPlankElement(context: ElementPerformerContext, wareElement: WareElement): PlaneElement;
        static findMainPlank(wareNode: WareNode): PlaneNode;
        static computePointWorldPosition(pointNode: PointNode): Vector3;
        static computeWorldPointsOfPlane(plankNode: PlaneNode): Types<Vector3>;
        static computeWorldCenterOfPlane(plankNode: PlaneNode): Vector3;
        static computeWorldNormalOfPlane(plankNode: PlaneNode, refPt: Vector3): Vector3;
        static computeWorldDirectionOfEdgeSurfaces(edgesSrc: PlaneNode, edgesurfaces: Array<EdgeSurfaceNode>, refPt: Vector3): Types<Vector3>;
        static matchEdgeSurfacePlank(edgesSrc: PlaneNode, planksSrc: Types<PlaneNode>, refCenter: Vector3): Types<EdgeSurfaceMatchPlank>;
        private static sliceSpatial_relationOfBoxAndBox;
        static sliceSpatial_CoverOfBoxAndBox(box1: BoxSolid, box2: BoxSolid, coverPlane: string): {
            isCover: boolean;
            isBox1Bigger?: boolean;
        };
        static computeNeighborPlanks(chestNode1: ChestNode, chestNode2: ChestNode): {
            planknode1: PlankNode;
            planknode2: PlankNode;
            dirOfPlankNode2: RelativeDirectionEnum;
        };
    }
}
declare module "sk/data/scheme/database/furniture/element/CompositeElement" {
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    export class CompositeElement extends FamilyInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CompositeElementMap = {
        [key: string]: CompositeElement;
    };
}
declare module "sk/data/scheme/database/furniture/element/CountertopElement" {
    import { CounterTopEdgeTypeEnum } from 'sk/data/family/database/furniture/enumeration/CounterTopEdgeTypeEnum';
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    export class CountertopElement extends AssemblyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_LEFT_PANEL_TYPE: string;
        static FIELD_RIGHT_PANEL_TYPE: string;
        leftPanelType: CounterTopEdgeTypeEnum;
        rightPanelType: CounterTopEdgeTypeEnum;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CountertopElementMap = {
        [key: string]: CountertopElement;
    };
}
declare module "sk/data/scheme/database/furniture/element/FramedDoorElement" {
    import { AssemblyPlaneElement } from 'sk/data/family/element/instance/AssemblyPlaneElement';
    export class FramedDoorElement extends AssemblyPlaneElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type FramedDoorElementMap = {
        [key: string]: FramedDoorElement;
    };
}
declare module "sk/data/scheme/database/furniture/structure/LinearCurveInfoStructure" {
    import { Curve3dStructure } from 'foundation/data/common/structure/geometric/Curve3dStructure';
    import { CurveStructure } from 'foundation/data/common/structure/geometric/CurveStructure';
    import { BusinessDirectTypeEnum } from 'sk/data/family/database/furniture/enumeration/BusinessDirectTypeEnum';
    export class LinearCurveInfoStructure extends CurveStructure {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        curve: Curve3dStructure;
        directCd: BusinessDirectTypeEnum;
        offset: number;
        expand: number;
        createSide: boolean;
        referenceInfoId: string;
        constructor();
        reset(): void;
    }
}
declare module "sk/data/scheme/database/furniture/structure/CounterTopSourcePolygonStructure" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { CurveStructure } from 'foundation/data/common/structure/geometric/CurveStructure';
    import { LinearCurveInfoStructure } from "sk/data/scheme/database/furniture/structure/LinearCurveInfoStructure";
    export class CounterTopSourcePolygonStructure extends CurveStructure {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        curveInfos: Types<LinearCurveInfoStructure>;
        createSideOptions: Array<boolean>;
        expandOptions: Array<number>;
        constructor();
        reset(): void;
    }
}
declare module "sk/data/scheme/database/furniture/structure/FurnitureCountertopItemStructure" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { StructureObject } from 'cross/runtime/framework/base/StructureObject';
    import { CounterTopSourcePolygonStructure } from "sk/data/scheme/database/furniture/structure/CounterTopSourcePolygonStructure";
    import { LinearCurveInfoStructure } from "sk/data/scheme/database/furniture/structure/LinearCurveInfoStructure";
    export class FurnitureCountertopItemStructure extends StructureObject {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        sourcePolygons: Types<CounterTopSourcePolygonStructure>;
        curveInfos: Types<LinearCurveInfoStructure>;
        expandOptions: Array<number>;
        constructor();
        loadJson(jconfig: any, context?: any): void;
        reset(): void;
    }
}
declare module "sk/data/scheme/database/furniture/element/FurnitureCountertopElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    import { FurnitureCountertopItemStructure } from "sk/data/scheme/database/furniture/structure/FurnitureCountertopItemStructure";
    export class FurnitureCountertopElement extends AssemblyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_ITEMS: string;
        items: Types<FurnitureCountertopItemStructure>;
        static sectionYCode: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type FurnitureCountertopElementMap = {
        [key: string]: FurnitureCountertopElement;
    };
}
declare module "sk/data/scheme/database/furniture/element/FurnitureProfileWareElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FurnitureCountertopItemStructure } from "sk/data/scheme/database/furniture/structure/FurnitureCountertopItemStructure";
    export class FurnitureProfileWareElement extends ContentInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_ITEMS: string;
        protected _items: Types<FurnitureCountertopItemStructure>;
        static FIELD_REFERENCE_UNIT_INFO_ID: string;
        referenceUnitInfoId: string;
        constructor();
        get items(): Types<FurnitureCountertopItemStructure>;
        reset(): void;
        dispose(): void;
    }
    export type FurnitureProfileWareElementMap = {
        [key: string]: FurnitureProfileWareElement;
    };
}
declare module "sk/data/scheme/model/spliter/SpaceUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Quaternion } from 'foundation/runtime/math/Quaternion';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    import { SpliterBase } from "sk/data/scheme/model/spliter/spliter/SpliterBase";
    import { SpliterTypeEnum } from "sk/data/scheme/model/spliter/spliter/SpliterTypeEnum";
    import { SubSurrounder } from "sk/data/scheme/model/spliter/surrounder/SubSurrounder";
    import { EntireSpace } from "sk/data/scheme/model/spliter/EntireSpace";
    export interface NeighborPlanks {
        left: PlankNode;
        right: PlankNode;
        back: PlankNode;
        front: PlankNode;
        bottom: PlankNode;
        top: PlankNode;
    }
    export interface NeighborSpaces {
        left: SpaceNode;
        right: SpaceNode;
        back: SpaceNode;
        front: SpaceNode;
        bottom: SpaceNode;
        top: SpaceNode;
    }
    export interface NeighborCombineSpace {
        space: SpaceNode;
        midplank: PlankNode;
    }
    export class Neighbor {
        _src: SpliterBase;
        _subsurface_src: SubSurrounder;
        _neighbor: SpliterBase;
        _subsurface_neighbor: SubSurrounder;
    }
    export class PlankContactType {
        static Contact_Any: number;
        static Contact_FromTop: number;
        static Contact_FromBottom: number;
        static Contact_FromFront: number;
        static Contact_FromBack: number;
        static Contact_FromRight: number;
        static Contact_FromLeft: number;
    }
    export class PlankRef {
        constructor(p: PlankNode, c: PlankContactType);
        plank: PlankNode;
        contactType: PlankContactType;
    }
    export class SpaceDefinedByPlanks {
        constructor();
        planks: Types<PlankRef>;
    }
    export class AxisTrans {
        constructor(xto?: RelativeDirectionEnum, yto?: RelativeDirectionEnum);
        xAxisTransTo: RelativeDirectionEnum;
        yAxisTransTo: RelativeDirectionEnum;
    }
    export class AxisMapItem {
        constructor(src: RelativeDirectionEnum, dest: RelativeDirectionEnum);
        srcAxis: RelativeDirectionEnum;
        destAxis: RelativeDirectionEnum;
    }
    export class SpaceUtil {
        static getAxisMapValue(map: Array<AxisMapItem>, srcdir: RelativeDirectionEnum): RelativeDirectionEnum;
        static getRevertDir(dir: RelativeDirectionEnum): RelativeDirectionEnum;
        static dir2Vec(dir: RelativeDirectionEnum): Vector3;
        static vec2Dir(vec: Vector3): RelativeDirectionEnum;
        static crossDir(dir1: RelativeDirectionEnum, dir2: RelativeDirectionEnum): RelativeDirectionEnum;
        static transAxisFromChestToSpace(axisTrans: AxisTrans, chestDir: RelativeDirectionEnum): RelativeDirectionEnum;
        static transAxisFromSpaceToChest(axisTrans: AxisTrans, spaceDir: RelativeDirectionEnum): RelativeDirectionEnum;
        static getAxisTransformMatrix(axisTrans: AxisTrans): Matrix4;
        static quaternion2YawPitchRoll(q: Quaternion): {
            rotX: number;
            rotY: number;
            rotZ: number;
        };
        static getAxisTransformRotation(axisTrans: AxisTrans): {
            rotX: number;
            rotY: number;
            rotZ: number;
        };
        static isAxisMapLegal(axisMap: Array<AxisMapItem>): {
            legal: boolean;
            full?: boolean;
            legalMap?: Array<AxisMapItem>;
        };
        static getAxisTransFromAxisMap(axisMap: Array<AxisMapItem>): AxisTrans;
        static getAxisMapFromAxisTrans(axisTrans: AxisTrans): Array<AxisMapItem>;
        static generateNewAxisMap(old: Array<AxisMapItem>, changedItem: AxisMapItem): Array<AxisMapItem>;
        static getDirectionInChestCoord(entireSpace: EntireSpace, plane: PlaneNode, space: SpaceNode): RelativeDirectionEnum;
        static getDirectionInSpaceNodeCoord(entireSpace: EntireSpace, plane: PlaneNode, space: SpaceNode, spaceAxisTrans: AxisTrans): RelativeDirectionEnum;
        static computeIdOfSpaceNode(entireSpace: EntireSpace, space: SpaceNode): string;
        static findSpaceDefinedByPlanks(entireSpace: EntireSpace, spaceDefinedByPlanks: SpaceDefinedByPlanks): SpaceNode;
        static findSpaceBySpaceId(entireSpace: EntireSpace, spaceId: string): SpaceNode;
        static isNeighbor(spliter: SpliterBase, srcnode: ContentNode, directCd?: RelativeDirectionEnum): boolean;
        static findNeighborPlanks(entireSpace: EntireSpace, srcnode: ContentNode): NeighborPlanks;
        static findNeighborSpaces(entireSpace: EntireSpace, srcnode: ContentNode): NeighborSpaces;
        static findNeighbors(entireSpace: EntireSpace, node: ContentNode, directionCd: RelativeDirectionEnum, type: SpliterTypeEnum): Array<Neighbor>;
        private static linkSubSurface_isSamePolygon;
        static findNeighborSpaceThatCanCombine(entireSpace: EntireSpace, spacenode: SpaceNode, directionCd: RelativeDirectionEnum): NeighborCombineSpace;
        static findNeighborSpaceThatMatchSubsurface(entireSpace: EntireSpace, srcnode: ContentNode, srcsubsurrounder: SubSurrounder, directionCd: RelativeDirectionEnum): Neighbor;
        protected static findSpliter(entireSpace: EntireSpace, node: ContentNode): SpliterBase;
        static contactType2RelativeDirectionEnum(contact: PlankContactType): RelativeDirectionEnum;
        static relativeDirectionEnum2ContactType(directCd: RelativeDirectionEnum): PlankContactType;
    }
}
declare module "sk/data/scheme/database/furniture/element/PlankDrawerRelation" {
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { RelationResultEnum, SizeRelationElement } from 'sk/data/family/element/config/relation/SizeRelationElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AxisTrans } from "sk/data/scheme/model/spliter/SpaceUtil";
    export class PlankDrawerRelationElement extends SizeRelationElement {
        distanceNX: number;
        distancePX: number;
        distanceNY: number;
        distancePY: number;
        distanceNZ: number;
        distancePZ: number;
        drawer: ContentInstanceElement;
        spaceId: string;
        spaceAxisTrans: AxisTrans;
        constructor();
        setDistance(directCd: RelativeDirectionEnum, distance: number): void;
        getDistance(directCd: RelativeDirectionEnum): number;
        checkRelation(context: ElementPerformerContext): RelationResultEnum;
        computeRelation(context: ElementPerformerContext): void;
        reset(): void;
    }
}
declare module "sk/data/scheme/database/furniture/element/PlankDrawerRelationUtil" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { ChestElement } from "sk/data/scheme/database/furniture/element/ChestElement";
    export class PlankDrawerRelationUtil {
        static computeDrawerParameters(boxSolid: BoxSolid, margins: {
            left: number;
            right: number;
            bottom: number;
            top: number;
        }, coversizes: {
            left: number;
            right: number;
            bottom: number;
            top: number;
        }): {
            drawerPosInBoxCoord: Vector3;
            drawerSizeInBoxCoord: Vector3;
            frontPosInBoxCoord: Vector3;
            frontSizeInBoxCoord: {
                sizeX: number;
                sizeZ: number;
            };
        };
        static setDrawerParameters(drawerElement: ChestElement, params: {
            drawerPosInBoxCoord: Vector3;
            drawerSizeInBoxCoord: Vector3;
            frontPosInBoxCoord: Vector3;
            frontSizeInBoxCoord: {
                sizeX: number;
                sizeZ: number;
            };
        }): void;
    }
}
declare module "sk/data/scheme/database/furniture/element/PlankSlideDoorRelation" {
    import { SizeRelationElement, RelationResultEnum } from 'sk/data/family/element/config/relation/SizeRelationElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SpaceDefinedByPlanks } from "sk/data/scheme/model/spliter/SpaceUtil";
    export class PlankSlideDoorRelationElement extends SizeRelationElement {
        slidedoor: ContentInstanceElement;
        spaceDefinedByPlanks: SpaceDefinedByPlanks;
        constructor();
        checkRelation(context: ElementPerformerContext): RelationResultEnum;
        computeRelation(context: ElementPerformerContext): void;
        reset(): void;
    }
}
declare module "sk/data/scheme/database/furniture/element/SlidingDoorElement" {
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    export class SlidingDoorElement extends AssemblyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type SlidingDoorElementMap = {
        [key: string]: SlidingDoorElement;
    };
}
declare module "sk/data/scheme/database/furniture/element/SlidingDoorLeafElement" {
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    export class SlidingDoorLeafElement extends AssemblyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type SlidingDoorLeafElementMap = {
        [key: string]: SlidingDoorLeafElement;
    };
}
declare module "sk/data/scheme/database/furniture/model/ComponentMoldingNode" {
    import { IMolding } from 'foundation/data/common/model/molding/IMolding';
    import { DataMoldingTypeEnum } from 'foundation/data/common/model/DataMoldingTypeEnum';
    import { ComponentNode } from 'sk/data/family/model/component/ComponentNode';
    export class ComponentMoldingNode extends ComponentNode implements IMolding {
        moldingCd: DataMoldingTypeEnum;
    }
}
declare module "sk/data/scheme/database/furniture/model/CompositeNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class CompositeNode extends FamilyInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): CompositeNode;
    }
    export type CompositeNodeMap = {
        [key: string]: CompositeNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/ComputeEnum" {
    export class ComputeEnum {
        static Boundary: string;
        static Space: string;
        static Coplane: string;
        static Condition: string;
    }
}
declare module "sk/data/scheme/database/furniture/model/ComputeContext" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ComputeEnum } from "sk/data/scheme/database/furniture/model/ComputeEnum";
    export class ComputeContext extends ContextObject {
        typeCd: ComputeEnum;
        free(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/Constants" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class ConstantsInstance {
    }
    export class Constants {
        static DATA: any;
        static TOLERANCE: number;
        static SPACE_TOLERANCE: number;
        static PRECISION: number;
        static BOX_LIMIT_MIN_X: number;
        static BOX_LIMIT_MIN_Y: number;
        static BOX_LIMIT_MIN_Z: number;
        static BOX_LIMIT_MIN_VOLUMN: number;
        static BOX_LIMIT_SIZE: Vector3;
        static PLANK_WIDTH_MIN: number;
        static PLANK_WIDTH_MAX: number;
        static PLANK_HEIGHT_MIN: number;
        static PLANK_HEIGHT_MAX: number;
        static CHEST_WIDTH_MIN: number;
        static CHEST_WIDTH_MAX: number;
        static CHEST_HEIGHT_MIN: number;
        static CHEST_HEIGHT_MAX: number;
        static get TOLERANCE_SHRINK_VECTOR3(): Vector3;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/NormalCoplaneNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Polygon3 } from 'foundation/runtime/math/Polygon3';
    import { CoplaneNode } from 'foundation/data/common/model/spatial/CoplaneNode';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { INodeSpatialable } from "sk/data/scheme/database/furniture/model/spatial/INodeSpatialable";
    export class NormalCoplaneNode extends CoplaneNode {
        directionCd: RelativeDirectionEnum;
        directionValue: number;
        directionHeight: number;
        connects: Types<NormalCoplaneNode>;
        targets: Types<INodeSpatialable>;
        polygon: Polygon3;
        constructor(spatialable: INodeSpatialable, directionCd: RelativeDirectionEnum);
        intersectsCoplane(coplane: NormalCoplaneNode): boolean;
        computePlane(): void;
        computeJoinerValue(): number;
        clear(): void;
    }
    export type NormalCoplaneNodeMap = {
        [key: string]: NormalCoplaneNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/converter/CoplaneMapConverter" {
    import { FieldConverter } from 'cross/runtime/module/persistent/converter/FieldConverter';
    import { PersistentAnnotation } from 'cross/runtime/module/persistent/PersistentAnnotation';
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    export class CoplaneMapConverter extends FieldConverter {
        filter(result: Array<any>, value: any): void;
        load(factory: PersistentFactory, context: any, item: any, config: any, annotation?: PersistentAnnotation): void;
        save(factory: PersistentFactory, context: any, item: any, config: any, annotation?: PersistentAnnotation): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/CountertopNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { AssemblyNode } from 'sk/data/family/model/instance/AssemblyNode';
    export class CountertopNode extends AssemblyNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        isValidSize(): boolean;
        dispose(): void;
        static create(document: Document): CountertopNode;
    }
    export type CountertopNodeMap = {
        [key: string]: CountertopNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/curve/CurveIterator" {
    export class CurveIterator {
        private items;
        private index;
        constructor(items: Array<any>);
        hasNext(): boolean;
        next(): any;
        back(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/curve/CurveOperator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export abstract class CurveOperator {
        node: DataNode;
        curves: Array<any>;
        constructor(node: DataNode);
        abstract getCurvePoints(divide?: number): Array<Vector2>;
    }
}
declare module "sk/data/scheme/database/furniture/model/curve/CubeCurveOperator" {
    import { List } from 'cross/runtime/lang/collection/List';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { CurveOperator } from "sk/data/scheme/database/furniture/model/curve/CurveOperator";
    export class CubeCurveOperator extends CurveOperator {
        node: PlankNode;
        private divide;
        points: Array<Vector2>;
        testPoints: List<Vector2>;
        constructor(node: PlankNode);
        hasCurve(): boolean;
        private draw;
        private drawLines;
        start: Vector2;
        end: Vector2;
        processPoint(nodes: List<any>): void;
        getCurvePoints(divide?: number): Array<Vector2>;
    }
}
declare module "sk/data/scheme/database/furniture/model/curve/CurveMoldingNode" {
    import { MMolding } from 'foundation/data/common/model/molding/MMolding';
    import { DataMoldingTypeEnum } from 'foundation/data/common/model/DataMoldingTypeEnum';
    import { ComponentMoldingNode } from "sk/data/scheme/database/furniture/model/ComponentMoldingNode";
    export class CurveMoldingNode extends ComponentMoldingNode {
        moldingCd: DataMoldingTypeEnum;
        molding: MMolding;
    }
}
declare module "sk/data/scheme/database/furniture/model/curve/CurvePoint" {
    export class CurvePoint {
        x: number;
        y: number;
        radius: number;
        clockwise: boolean;
    }
}
declare module "sk/data/scheme/database/furniture/model/curve/CurvePointConverter" {
    import { FieldConverter } from 'cross/runtime/module/persistent/converter/FieldConverter';
    import { PersistentAnnotation } from 'cross/runtime/module/persistent/PersistentAnnotation';
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    export class CurvePointConverter extends FieldConverter {
        load(factory: PersistentFactory, context: any, item: any, config: any, annotation?: PersistentAnnotation): void;
        save(factory: PersistentFactory, context: any, item: any, config: any, annotation?: PersistentAnnotation): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/curve/PlankCurveOperator" {
    import { List } from 'cross/runtime/lang/collection/List';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CurveOperator } from "sk/data/scheme/database/furniture/model/curve/CurveOperator";
    export class PlankCurveOperator extends CurveOperator {
        node: any;
        curves: Array<any>;
        private divide;
        points: Array<Vector2>;
        testPoints: List<Vector2>;
        testLines: List<any>;
        constructor(node: any);
        hasCurve(): boolean;
        private draw;
        private drawLines;
        start: Vector2;
        end: Vector2;
        processPoint(nodes: List<any>): void;
        getCurvePoints(divide?: number): Array<Vector2>;
    }
}
declare module "sk/data/scheme/database/furniture/model/curve/ProductCurveNode" {
    export class ProductCurveNode {
        constructor();
    }
}
declare module "sk/data/scheme/database/furniture/model/CutawayNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class CutawayNode extends ContentNode {
        millingGuid: string;
        width: number;
        deep: number;
        startX: number;
        startY: number;
    }
    export type CutawayNodeMap = {
        [key: string]: CutawayNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/decorate/CustomizedDecorateNode" {
    export class CustomizedDecorateNode {
        name: string;
        code: string;
    }
}
declare module "sk/data/scheme/database/furniture/model/decorate/DecorateEdgeNode" {
    export class DecorateEdgeNode {
    }
    export type DecorateEdgeNodeMap = {
        [key: string]: DecorateEdgeNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/decorate/IDecorateMaterial" {
    export interface IDecorateMaterial {
        previewUrl: string;
        textureUrl: string;
    }
}
declare module "sk/data/scheme/database/furniture/model/decorate/DecorateMaterialNode" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { DataResourceService } from 'foundation/data/common/io/DataResourceService';
    import { IDecorateMaterial } from "sk/data/scheme/database/furniture/model/decorate/IDecorateMaterial";
    export class DecorateMaterialNode extends InstanceObject implements IDecorateMaterial {
        pictureGuid: string;
        pictureVersion: string;
        protected _qualityService: QualityService;
        protected _resourceService: DataResourceService;
        get previewUrl(): string;
        get textureUrl(): string;
    }
    export type DecorateMaterialNodeMap = {
        [key: string]: DecorateMaterialNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/decorate/DecorateSubstrateNode" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class DecorateSubstrateNode extends InstanceObject {
        lengthX: string;
        lengthY: string;
        lengthZ: string;
    }
    export type DecorateSubstrateNodeMap = {
        [key: string]: DecorateSubstrateNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/EgdeSurfaceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { SurfaceNode } from 'foundation/data/common/model/brep/geometric/SurfaceNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { LayerNode } from 'sk/data/family/model/instance/LayerNode';
    import { MaterialDirectionEnum } from 'sk/data/family/enumeration/MaterialDirectionEnum';
    export class EgdeSurfaceNode extends BrepNode {
        static CLASS_NAME: string;
        static FIELD_SURFACE: string;
        static FIELD_SKIN: string;
        static FIELD_PRE_MILLING: string;
        static FIELD_MATERIAL_DIRECTION_CD: string;
        static FIELD_MATERIAL: string;
        surface: SurfaceNode;
        skin: LayerNode;
        preMilling: number;
        materialDirectionCd: MaterialDirectionEnum;
        constructor();
        static create(document: Document): EgdeSurfaceNode;
    }
    export type EgdeSurfaceNodeMap = {
        [key: string]: EgdeSurfaceNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/FramedDoorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { AssemblyPlaneNode } from 'sk/data/family/model/instance/AssemblyPlaneNode';
    export class FramedDoorNode extends AssemblyPlaneNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): FramedDoorNode;
    }
    export type FramedDoorNodeMap = {
        [key: string]: FramedDoorNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/GrooveNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TechniquePlaneEnum } from 'foundation/data/common/define/TechniquePlaneEnum';
    export class GrooveNode extends ContentNode {
        planeCd: TechniquePlaneEnum;
        millingXGuid: string;
        millingYGuid: string;
        width: number;
        deep: number;
        startX: number;
        startY: number;
        endX: number;
        endY: number;
    }
    export type GrooveNodeMap = {
        [key: string]: GrooveNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/HelperNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class HelperNode extends ContentNode {
        static FIELD_POSITION_X: string;
        static FIELD_POSITION_Y: string;
        static FIELD_POSITION_Z: string;
        static FIELD_LENGTH_X: string;
        static FIELD_LENGTH_Y: string;
        static FIELD_LENGTH_Z: string;
        positionX: number;
        positionY: number;
        positionZ: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        constructor();
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/SlotGraphicBox" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { GraphicBox } from 'sk/data/family/model/spatial/GraphicBox';
    import { HoleNode } from "sk/data/scheme/database/furniture/model/HoleNode";
    export class SlotGraphicBox extends GraphicBox {
        node: HoleNode;
        computeNode(node: HoleNode, matrix: Matrix4): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/SlotSpatialBox" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { SpatialBox } from 'sk/data/family/model/spatial/SpatialBox';
    import { HoleNode } from "sk/data/scheme/database/furniture/model/HoleNode";
    export class SlotSpatialBox extends SpatialBox {
        node: HoleNode;
        set(entity: any): void;
        computeNode(node: HoleNode, matrix: Matrix4): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/HoleNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TechniquePlaneEnum } from 'foundation/data/common/define/TechniquePlaneEnum';
    import { TechniqueSlotHostEnum } from 'foundation/data/common/define/TechniqueSlotHostEnum';
    import { TechniqueSlotTypeEnum } from 'foundation/data/common/define/TechniqueSlotTypeEnum';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { SlotGraphicBox } from "sk/data/scheme/database/furniture/model/spatial/SlotGraphicBox";
    import { SlotSpatialBox } from "sk/data/scheme/database/furniture/model/spatial/SlotSpatialBox";
    import { CompositeNode } from "sk/data/scheme/database/furniture/model/CompositeNode";
    export class HoleNode extends ContentNode {
        static FIELD_DIAMETER: string;
        static FIELD_LENGTH: string;
        static FIELD_ANGLE: string;
        optionDynamic: boolean;
        techniqueHostCd: TechniqueSlotHostEnum;
        techniquePlaneCd: TechniquePlaneEnum;
        techniqueCoplaneCd: RelativeDirectionEnum;
        techniqueTypeCd: TechniqueSlotTypeEnum;
        diameter: number;
        length: number;
        angle: number;
        drillGuid: string;
        substrateGuid: string;
        spatialBox: SlotSpatialBox;
        graphicBox: SlotGraphicBox;
        constructor();
        getTopComponents(): CompositeNode;
        getComponents(): CompositeNode;
        getWidth(): number;
        getHeight(): number;
        getDepth(): number;
    }
    export type HoleNodeMap = {
        [key: string]: HoleNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/HostNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    export class HostNode extends ContentNode {
        getTopContainer(): ChestNode;
        getContainer(): ChestNode;
    }
}
declare module "sk/data/scheme/database/furniture/model/ITechnologyNode" {
    export interface ITechnologyNode {
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/LinearGraphicBox" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { GraphicBox } from 'sk/data/family/model/spatial/GraphicBox';
    export class LinearGraphicBox extends GraphicBox {
        node: LinearNode;
        computeNode(node: LinearNode, matrix: Matrix4): void;
        compute(): void;
        computeMatrix(): Matrix4;
    }
}
declare module "sk/data/scheme/database/furniture/model/LinearNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { LinearPointNode } from 'sk/data/family/model/instance/LinearPointNode';
    import { LinearGraphicBox } from "sk/data/scheme/database/furniture/model/spatial/LinearGraphicBox";
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    import { ComponentMoldingNode } from "sk/data/scheme/database/furniture/model/ComponentMoldingNode";
    export class PolygonPoint extends Vector2 {
        x: number;
        y: number;
    }
    export class LinearNode extends ComponentMoldingNode {
        name: string;
        roundType: boolean;
        triangleRoundType: boolean;
        polygonStep: number;
        polygonWidth: number;
        polygonHeight: number;
        boundaryMinX: number;
        boundaryMinY: number;
        polygons: Array<PolygonPoint>;
        pathPoints: Types<LinearPointNode>;
        path: Array<string>;
        graphicBox: LinearGraphicBox;
        customizedDataType: string;
        constructor();
        hide(): void;
        show(): void;
        savePathPoints(): void;
        addChild(node: DataNode, dispatch?: boolean): void;
        removeChild(node: DataNode, dispatch?: boolean): void;
        getTopChest(): ChestNode;
        getChest(): ChestNode;
        dispose(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/PlankPointNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class PlankPointNode extends ContentNode {
        private static SIZE;
        radius: number;
        clockwise: boolean;
        constructor();
    }
}
declare module "sk/data/scheme/database/furniture/model/LinearPointNode" {
    import { PlankPointNode } from "sk/data/scheme/database/furniture/model/PlankPointNode";
    export class LinearPointNode extends PlankPointNode {
    }
}
declare module "sk/data/scheme/database/furniture/model/MaterialFace" {
    export interface MaterialFace {
        color: number;
        tileX: number;
        tileY: number;
        tileWidth: number;
        tileHeight: number;
        tileRotation: number;
    }
}
declare module "sk/data/scheme/database/furniture/model/MetaNode" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class MetaNode extends DataNode {
        x: number;
        y: number;
        z: number;
        xRotate: number;
        yRotate: number;
        zRotate: number;
        width: number;
        minWidth: number;
        maxWidth: number;
        depth: number;
        minDepth: number;
        maxDepth: number;
        height: number;
        minHeight: number;
        maxHeight: number;
    }
}
declare module "sk/data/scheme/database/furniture/model/MillingNode" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class MillingNode extends ContentNode {
        millingGuid: string;
        millingPositionCd: string;
        width: number;
        surfaceCd: string;
        startX: number;
        startY: number;
        startZ: number;
        endX: number;
        endY: number;
        endZ: number;
        radiusX: number;
        radiusY: number;
        clockwise: boolean;
    }
    export type MillingNodeMap = {
        [key: string]: MillingNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/PlankEdgeNode" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { Curve2dStructure } from 'foundation/data/common/structure/geometric/Curve2dStructure';
    import { MaterialDirectionEnum } from 'sk/data/family/enumeration/MaterialDirectionEnum';
    export class PlankEdgeNode extends BrepNode {
        static CLASS_NAME: string;
        static FIELD_MILL: string;
        static FIELD_SEAM: string;
        static FIELD_MATERIAL_ID: string;
        static FIELD_MATERIAL_DIRECTION_CD: string;
        static FIELD_THICKNESS: string;
        static FIELD_WIDTH: string;
        static FIELD_LENGTH: string;
        static FIELD_SKIN_BORDER: string;
        static FIELD_MATERIAL: string;
        mill: number;
        seam: number;
        materialId: string;
        materialDirectionCd: MaterialDirectionEnum;
        thickness: number;
        width: number;
        length: number;
        skinBorder: Curve2dStructure;
        constructor();
        updateBorder(): void;
    }
    export type PlankEdgeNodeMap = {
        [key: string]: PlankEdgeNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/PlankSurfaceNode" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { MaterialDirectionEnum } from 'sk/data/family/enumeration/MaterialDirectionEnum';
    export class PlankSurfaceNode extends DataNode {
        static CLASS_NAME: string;
        static FIELD_BARCODE: string;
        static FIELD_MATERIAL_ID: string;
        static FIELD_MATERIAL_DIRECTION_CD: string;
        static FIELD_MATERIAL: string;
        barcode: string;
        materialId: string;
        materialDirectionCd: MaterialDirectionEnum;
        constructor();
    }
    export type PlankSurfaceNodeMap = {
        [key: string]: PlankSurfaceNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/SlidingDoorLeafNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { AssemblyNode } from 'sk/data/family/model/instance/AssemblyNode';
    export class SlidingDoorLeafNode extends AssemblyNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): SlidingDoorLeafNode;
    }
    export type SlidingDoorLeafNodeMap = {
        [key: string]: SlidingDoorLeafNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/SlidingDoorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { AssemblyNode } from 'sk/data/family/model/instance/AssemblyNode';
    export class SlidingDoorNode extends AssemblyNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): SlidingDoorNode;
    }
    export type SlidingDoorNodeMap = {
        [key: string]: SlidingDoorNode;
    };
}
declare module "sk/data/scheme/database/furniture/model/SpaceNode2" {
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SidePlankInfo, SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    export class SpaceNode2 extends SpaceNode {
        static CLASS_NAME: string;
        static CLASS_ID: string;
        get depth(): number;
        getLeftPlanks(): Array<PlankNode>;
        getRightPlanks(): Array<PlankNode>;
        getTopPlanks(): Array<PlankNode>;
        getBottomPlanks(): Array<PlankNode>;
        getLeftSidePlankInfo(): SidePlankInfo;
        getRightSidePlankInfo(): SidePlankInfo;
        getTopSidePlankInfo(): SidePlankInfo;
        getBottomSidePlankInfo(): SidePlankInfo;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/ChestGraphicBox" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { GraphicBox } from 'sk/data/family/model/spatial/GraphicBox';
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    export class ChestGraphicBox extends GraphicBox {
        node: ChestNode;
        computeMatrix(): Matrix4;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/SpatialConnectEnum" {
    export class SpatialConnectEnum {
        static All: string;
        static Same: string;
        static Large: string;
        static Small: string;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/NodeSpatialOperator" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { CoplaneNode, CoplaneNodes } from 'foundation/data/common/model/spatial/CoplaneNode';
    import { SpatialOperator } from 'foundation/data/common/model/spatial/SpatialOperator';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { SpatialBox } from 'sk/data/family/model/spatial/SpatialBox';
    import { INodeSpatialable } from "sk/data/scheme/database/furniture/model/spatial/INodeSpatialable";
    import { SpatialConnectEnum } from "sk/data/scheme/database/furniture/model/spatial/SpatialConnectEnum";
    export class NodeSpatialOperator extends SpatialOperator {
        get spatialBox(): SpatialBox;
        get _coplanes(): CoplaneNodes;
        hasJoiners(): boolean;
        generateCoplanes(): void;
        updateCoplanes(): void;
        findCoplane(directionCd: RelativeDirectionEnum): CoplaneNode;
        get pxCoplane(): CoplaneNode;
        get nxCoplane(): CoplaneNode;
        get pyCoplane(): CoplaneNode;
        get nyCoplane(): CoplaneNode;
        get pzCoplane(): CoplaneNode;
        get nzCoplane(): CoplaneNode;
        findDirectionTargets(directionCd: RelativeDirectionEnum): Array<INodeSpatialable>;
        findSide(directionCd: RelativeDirectionEnum, type?: Function, connectCd?: SpatialConnectEnum): Array<INodeSpatialable>;
        findSideDeep(directionCd: RelativeDirectionEnum, clazz?: Function, target?: Array<INodeSpatialable>): Array<INodeSpatialable>;
        computeBoundary(target?: Box3): Box3;
        computeCoplaneTargets(spatialables: Array<INodeSpatialable>): void;
        clearCoplanes(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/SpaceBuilder" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PointBox3 } from 'foundation/data/common/model/spatial/PointBox3';
    import { CompositeNode } from "sk/data/scheme/database/furniture/model/CompositeNode";
    export class SpaceBuilder extends InstanceObject {
        protected _points: Array<Vector3>;
        protected _contentBoxs: Array<PointBox3>;
        protected _intersectsPoints: Array<Vector3>;
        protected _intersectsBoxs: Array<PointBox3>;
        protected _physicsBoxs: Array<Box3>;
        constructor();
        setup(): void;
        protected addPoint(point: Vector3): void;
        protected addBoxPoints(box: PointBox3): void;
        protected intersectContents(box: Box3): boolean;
        protected buildBoxs(): void;
        caculateIntersectBox(box1: PointBox3, box2: PointBox3): void;
        caculateSpaceBoxes(compositeNode: CompositeNode): Array<Box3>;
        clear(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/CompositeSpatialOperator" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    import { NodeSpatialOperator } from "sk/data/scheme/database/furniture/model/spatial/NodeSpatialOperator";
    import { SpaceBuilder } from "sk/data/scheme/database/furniture/model/spatial/SpaceBuilder";
    export class CompositeSpatialOperator extends NodeSpatialOperator {
        node: any;
        protected _spaceBuilder: SpaceBuilder;
        constructor(node?: any);
        computeJoiner(): void;
        calculatePoint(point: Vector3): Vector3;
        caculateSpaceBoxes(containerNode: any): Array<Box3>;
        computeCoplanes(special?: SpaceNode): void;
        clearSpaceNodes(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/util/CubeUtil" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { EdgeOverrideEnum } from 'foundation/data/common/define/EdgeOverrideEnum';
    export class CubeUtil {
        static ROTATION_TOLERANCE: number;
        static _matrix: Matrix4;
        static computeMatrix(plank: any): Matrix4;
        static computeLhMatrix(plank: any): Matrix4;
        static computeRhMatrix(plank: any): Matrix4;
        static computeExtendLength(thickness: number, mode: EdgeOverrideEnum): number;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/CubeSpatialBox" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { SpatialBox } from 'sk/data/family/model/spatial/SpatialBox';
    export class CubeSpatialBox extends SpatialBox {
        static BORDER: number;
        static DARK_COLOR: number;
        static LIGHT_COLOR: number;
        node: any;
        optionWorldMatrix: boolean;
        computeNode(cube: any, matrix: Matrix4): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/CubeSpatialOperator" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    import { NodeSpatialOperator } from "sk/data/scheme/database/furniture/model/spatial/NodeSpatialOperator";
    export class CubeSpatialOperator extends NodeSpatialOperator {
        node: any;
        points: Array<Vector3>;
        origin: Vector3;
        localMatrix: Matrix4;
        worldMatrix: Matrix4;
        constructor(node: any);
        protected resetBox(): void;
        computeMatrix(): void;
        computeJoiner(): void;
        removeOverlapSpaceNodeWithNodeInYAxisInDXCoordinate(spaceNodes: Array<SpaceNode>): any;
        findNearestSelectedSpaceNodeFromHitPoint(hitPoint: Vector3, spaceNodes: Array<SpaceNode>): SpaceNode;
        findNearestSelectedSpaceNodeFromAdjacentNodes(hitPoint: Vector3, spaceNodes: Array<SpaceNode>): SpaceNode;
        calculatePoint(point: Vector3): Vector3;
        protected isSpaceContainHitPointInXZPlaneInDXCoordinate(box3: Box3, hitPoint: Vector3): boolean;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/GroupGraphicBox" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { GraphicBox } from 'sk/data/family/model/spatial/GraphicBox';
    export class GroupGraphicBox extends GraphicBox {
        node: GroupNode;
        computeNode(node: GroupNode, matrix: Matrix4): void;
        computeMatrix(): Matrix4;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/PlankGraphicBox" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { PolygonGeometry, PolygonGeometryMap } from 'foundation/runtime/graphics/shape/geometry/PolygonGeometry';
    import { EdgeOverrideEnum } from 'foundation/data/common/define/EdgeOverrideEnum';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { GraphicBox } from 'sk/data/family/model/spatial/GraphicBox';
    import { CurvePoint } from "sk/data/scheme/database/furniture/model/curve/CurvePoint";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    export class PlankGraphicBox extends GraphicBox {
        static BORDER: number;
        static DARK_COLOR: number;
        static LIGHT_COLOR: number;
        optionModel: boolean;
        optionSelect: boolean;
        optionHover: boolean;
        optionVisible: boolean;
        optionBevel: boolean;
        optionBorder: boolean;
        node: PlankNode;
        border: number;
        box: Box3;
        geometries: PolygonGeometryMap;
        curvePolygon: Polygon;
        polygon: Polygon;
        polygonMatrix: Matrix4;
        constructor(entity: any);
        computeNode(plank: PlankNode, matrix: Matrix4): void;
        hasCurve(): boolean;
        getCurvePoints(divide?: number): Array<Vector2>;
        getSurfaceCds(): Array<RelativeDirectionEnum>;
        calculatePoints(curvePoints: Array<CurvePoint>): void;
        getNearlyPower(value: any): number;
        getSurfaceGeometry(directionCd: RelativeDirectionEnum): PolygonGeometry;
        getSurfaceMaterial(directionCd: RelativeDirectionEnum): any;
        getSurface(directionCd: RelativeDirectionEnum): PolygonGeometry;
        protected computeExtendLength(thickness: number, mode: EdgeOverrideEnum): number;
        update(): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/PlankSpatialOperator" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    import { CubeSpatialOperator } from "sk/data/scheme/database/furniture/model/spatial/CubeSpatialOperator";
    export class PlankSpatialOperator extends CubeSpatialOperator {
        node: any;
        points: Array<Vector3>;
        origin: Vector3;
        localMatrix: Matrix4;
        worldMatrix: Matrix4;
        constructor(node: any);
        protected resetBox(): void;
        computeMatrix(): void;
        computeJoiner(): void;
        findSidePlank(directionCd: RelativeDirectionEnum): Array<PlankNode>;
        removeOverlapSpaceNodeWithNodeInYAxisInDXCoordinate(spaceNodes: Array<SpaceNode>): SpaceNode[];
        findNearestSelectedSpaceNodeFromHitPoint(hitPoint: Vector3, spaceNodes: Array<SpaceNode>): SpaceNode;
        findNearestSelectedSpaceNodeFromAdjacentNodes(hitPoint: Vector3, spaceNodes: Array<SpaceNode>): SpaceNode;
        calculatePoint(point: Vector3): Vector3;
        protected isSpaceContainHitPointInXZPlaneInDXCoordinate(box3: Box3, hitPoint: Vector3): boolean;
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/SpaceGraphicBox" {
    import { GraphicBox } from 'sk/data/family/model/spatial/GraphicBox';
    export class SpaceGraphicBox extends GraphicBox {
    }
}
declare module "sk/data/scheme/database/furniture/model/spatial/SpatialUtil" {
    import { Spatialable } from 'foundation/data/common/model/spatial/Spatialable';
    export class SpatialUtil {
        static isTopModel(entity: any): boolean;
        static isSpatialable(spatialable: Spatialable): boolean;
    }
}
declare module "sk/data/scheme/database/furniture/model/util/ChestUtil" {
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    export class ChestUtil {
        static setChildrenVisible(chest: ChestNode, type: Function, visible: boolean): void;
        static setChildrenRandomColor(chest: ChestNode, type: Function): void;
    }
}
declare module "sk/data/scheme/database/furniture/model/util/CompositeUtil" {
    import { CompositeNode } from "sk/data/scheme/database/furniture/model/CompositeNode";
    export class CompositeUtil {
        static setChildrenFlag(composite: CompositeNode, type: Function, flag: number, value: boolean): void;
        static setChildrenVisible(composite: CompositeNode, type: Function, visible: boolean): void;
        static setChildrenRandomColor(composite: CompositeNode, type: Function): void;
        static fetchDecorateList(composite: CompositeNode, target?: Array<string>): Array<string>;
    }
}
declare module "sk/data/scheme/database/furniture/model/util/ContainerUtil" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { CompositeNode } from "sk/data/scheme/database/furniture/model/CompositeNode";
    export class ContainerUtil {
        private static _instance;
        private static get instance();
        static computeMatrix(components: CompositeNode): Matrix4;
    }
}
declare module "sk/data/scheme/database/furniture/model/util/SpaceUtil" {
    import { SpaceNode } from "sk/data/scheme/database/furniture/model/SpaceNode";
    export class DirectionEnum {
        static UP: string;
        static DOWN: string;
        static LEFT: string;
        static RIGHT: string;
    }
    export class ContentResult {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
    }
    export class SpaceUtil {
        static isRectSpace(spaceNode: SpaceNode): boolean;
        static getLinkPlanksBySpace(spaceNode: SpaceNode, direction: string): void;
        static getContentRotationBySpace(spaceNode: SpaceNode): ContentResult;
    }
}
declare module "sk/data/scheme/database/furniture/node/FurnitureCountertopNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { AssemblyNode } from 'sk/data/family/model/instance/AssemblyNode';
    export class FurnitureCountertopNode extends AssemblyNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): FurnitureCountertopNode;
    }
    export type FurnitureCountertopNodeMap = {
        [key: string]: FurnitureCountertopNode;
    };
}
declare module "sk/data/scheme/database/furniture/node/FurnitureProfileWareNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    export class FurnitureProfileWareNode extends ContentInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): FurnitureProfileWareNode;
    }
    export type FurnitureProfileWareNodeMap = {
        [key: string]: FurnitureProfileWareNode;
    };
}
declare module "sk/data/scheme/database/ipddata/drawingnode/DrawNodeConstants" {
    export class DrawNodeConstants {
    }
    export enum DrawNodeStyleFields {
        ISFROMIPD = 0,
        COLOR = 1,
        SHOWLEVEL = 2,
        TEXTANCHOR = 3,
        LINEWIDTH = 4,
        TEXTSCALE = 5,
        ALPHA = 6,
        LINEALPHA = 7,
        TEXTFONT = 8
    }
}
declare module "sk/data/scheme/database/ipddata/graphics/constants/GraphicsConstants" {
    export class GraphicsConstants {
        static DIMENSION_TEXT_MAX_SCALE: number;
        static DIMENSION_TEXT_MIN_SCALE: number;
        static CELL_SIZE_SCALE: number;
    }
}
declare module "sk/data/scheme/database/ipddata/graphics/constants/GraphicsDynamicConstant" {
    export class GraphicsDynamicConstant {
        static MAXFONT: number;
        static MINFONT: number;
        static ARROWLENGTH: number;
        static PIXELLINEWIDTH: number;
        static ONEPIXELSCALE: number;
        static resetData(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/graphics/model/GraphicsModel" {
    export class GraphicsModel {
        private min_text_height;
        private max_text_height;
        private main_cell_size;
        init(min_text_height: number, max_text_height: number, main_cell_size: number): void;
        getFitTextHeight(): number;
        getMinTextHeight(): number;
        getMaxTextHeight(): number;
        getMainCellSize(): number;
        clear(): void;
        reset(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/constants/IpdConstants" {
    export class IpdConstants {
        static IPDPLANKCOLOR: string;
        static IPDSUBPLANKCOLOR: string;
        static IPDLINEWIDHT: number;
        static CELLCOUNT: number;
        static CELLSIZE: number;
        static PROCESSCOLOR: string;
        static IPDROOTX: number;
        static IPDROOTY: number;
        static IPDSUBDIMENSIONCOLOR: string;
        static IPDPROCESSBACKCOLOR: string;
        static IPDPROCESSBACKTEXTCOLOR: string;
        static IPDPROCESSFRONTCOLOR: string;
        static IPDPROCESSFRONTTEXTCOLOR: string;
        static IPDPROCESSMIDCOLOR: string;
        static TEXTSIZE: number;
        static TEXTMINSIZE: number;
        static CHESTTEXTMAXSIZE: number;
        static CHESTTEXTMINSIZE: number;
        static GROOVETEXTCOLOR: string;
        static BASELINEDIMENSION: string;
        static BASELINEPROCESS: string;
        static BASELINECUBECODENUMBER: string;
        static LINEWIDTH: number;
        static DIMENMINDIS: number;
        static PROCESSTEXTCOLOR: string;
        static PLANKEDGECOLOR: string;
        static PLANKDECREEDGECOLOR: string;
        static PLANKMILLINGCOLOR: string;
        static CODENUMBERMAXSIZE: number;
        static CODENUMBERMINSIZE: number;
        static CUBECODENUMBERBASECOLOR: string;
        static CUBECODENUMBERSUBCOLOR: string;
        static MILLINGTRACKCOLOR: string;
        static OPENINGOUTLINECOLOR: string;
    }
    export enum PlaceDirection {
        UP = 0,
        DOWN = 1,
        LEFT = 2,
        RIGHT = 3
    }
    export enum IpdDirectType {
        FRONT = 0,
        BACK = 1
    }
    export enum PlankEdgeDirect {
        Up = 0,
        Down = 1,
        Left = 2,
        Right = 3
    }
    export enum ProjectType {
        Top = 0,
        West = 1,
        East = 2,
        North = 3,
        South = 4,
        Back = 5
    }
    export enum WareNodeType {
        StructureHardware = "structurehardware",
        Other = "other"
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdBase" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class IpdBase extends InstanceObject {
        childrend: IpdBase[];
        id: string;
        name: string;
        parent: IpdBase;
        childrendIds: string[];
        protected genAbPos: boolean;
        constructor();
        addChild(child: IpdBase): void;
        removeAllChildren(): void;
        hasChild(): boolean;
        parseObj(jsonObj: any): void;
        parseChildren(ipdlist: Dictionary<IpdBase>): void;
        protected genAbsolutePos(): void;
        childGetAbsolutePos(childpos: Vector2): void;
        genChildernAbPos(): void;
        childGetAbsolutePos3D(childpos: Vector3): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdCube" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class IpdCube extends IpdBase {
        x: number;
        y: number;
        z: number;
        x_ab: number;
        y_ab: number;
        z_ab: number;
        depth: number;
        height: number;
        width: number;
        direction: string;
        codenumber: string;
        y_reverse: boolean;
        node: ContentNode;
        childGetAbsolutePos3D(childpos: Vector3): void;
        protected genAbsolutePos(): void;
        getYReversePos(): Vector3;
        getYReverseRelativePos(parentabpos: Vector3): Vector3;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdChest" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { IpdCube } from "sk/data/scheme/database/ipddata/ipd/entity/IpdCube";
    export class IpdChest extends IpdCube {
        init(x: number, y: number, z: number, width: number, height: number, depth: number, name: string, id: string): void;
        parseObj(item: any): void;
        childGetAbsolutePos(childpos: Vector2): void;
        childGetAbsolutePos3D(childpos: Vector3): void;
        protected genAbsolutePos(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdEmpty" {
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class IpdEmpty extends IpdBase {
        x: number;
        y: number;
        constructor();
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdGroove" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { IpdDirectType } from "sk/data/scheme/database/ipddata/ipd/constants/IpdConstants";
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class IpdGroove extends IpdBase {
        begin: Vector2;
        end: Vector2;
        depth: number;
        width: number;
        begin_ab: Vector2;
        end_ab: Vector2;
        type: IpdDirectType;
        codenumber: number;
        constructor();
        parseObj(item: any): void;
        protected genAbsolutePos(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdHardware" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { IpdCube } from "sk/data/scheme/database/ipddata/ipd/entity/IpdCube";
    export class IpdHardware extends IpdCube {
        type: string;
        scale: number;
        barcodeBack: string;
        barcodeFront: string;
        parseObj(item: any): void;
        childGetAbsolutePos(childpos: Vector2): void;
        childGetAbsolutePos3D(childpos: Vector3): void;
        protected genAbsolutePos(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdHole" {
    import { IpdDirectType } from "sk/data/scheme/database/ipddata/ipd/constants/IpdConstants";
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class IpdHole extends IpdBase {
        x: number;
        y: number;
        z: number;
        diameter: number;
        angle: number;
        depth: number;
        x_ab: number;
        y_ab: number;
        z_ab: number;
        type: IpdDirectType;
        private localMatrix;
        codenumber: number;
        constructor();
        parseObj(item: any): void;
        protected genAbsolutePos(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdMilling" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { IpdDirectType } from "sk/data/scheme/database/ipddata/ipd/constants/IpdConstants";
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class IpdMilling extends IpdBase {
        radiux: number;
        radiuy: number;
        begin: Vector2;
        end: Vector2;
        lineWidth: number;
        circleDirect: number;
        begin_ab: Vector2;
        end_ab: Vector2;
        type: IpdDirectType;
        depth: number;
        startDepth: number;
        endDepth: number;
        cutType: number;
        codenumber: number;
        constructor();
        parseObj(item: any): void;
        protected genAbsolutePos(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdModule" {
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class IpdModule extends IpdBase {
        x: number;
        y: number;
        z: number;
        width: number;
        height: number;
        depth: number;
        constructor();
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdPlank" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { IpdCube } from "sk/data/scheme/database/ipddata/ipd/entity/IpdCube";
    export class IpdPlank extends IpdCube {
        millingSize: number[];
        decrementSize: number[];
        edgeSize: number[];
        type: string;
        decrementWidthValue: number;
        decrementDepthValue: number;
        barcodeFront: string;
        barcodeBack: string;
        errorMessage: string;
        textureName: string;
        textureCode: string;
        textureRealGrain: string;
        materialName: string;
        materialCode: string;
        constructor();
        parseObj(item: any): void;
        childGetAbsolutePos(childpos: Vector2): void;
        childGetAbsolutePos3D(childpos: Vector3): void;
        protected genAbsolutePos(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/ipd/entity/IpdRoot" {
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class IpdRoot extends IpdBase {
        x: number;
        y: number;
        constructor();
    }
}
declare module "sk/data/scheme/database/ipddata/node/NodeConstants" {
    export class NodeConstants {
        static TEXTSIZE: number;
        static DIMENSION_TEXT_SIZE: number;
        static TEXT_COLOR: string;
        static TEXT_SCALE: number;
        static TEXTPOINT_AJU_X: number;
        static TEXTPOINT_AJU_Y: number;
        static TEXTRECTCOLOR: string;
        static DIMENSION_LINE_COLOR: string;
        static DOMAIN_LINE_COLOR: string;
        static DIMENSION_ARROW_LENGTH: number;
        static LINECURVE2D_WIDTH: number;
        static NURBSLINEWIDTH: number;
        static LINE_WIDTH: number;
        static LINE_COLOR: string;
        static BASELINEDIMENSION: string;
        static BASELINETEXT: string;
        static CIRCLE_WIDTH: number;
        static CIRCLE_COLOR: string;
        static CIRCLEARC_COLOR: string;
        static NOCOLOR: string;
        static BLACK: string;
        static FRAMEALPHA: number;
        static FRAMELINECOLOR: string;
        static PANELCOLOR: string;
        static PANELALPHA: number;
        static PANELLINE: string;
        static PANELLINEALPHA: number;
        static ELLIPSE_LINE_COLOR: string;
        static SCALEFACTOR: number;
    }
}
declare module "sk/data/scheme/database/ipddata/parse/i2g/context/I2GDimensionContext" {
    import { PlaceDirection } from "sk/data/scheme/database/ipddata/ipd/constants/IpdConstants";
    export class I2GDimensionContext {
        protected upposlist: boolean[];
        protected downposlist: boolean[];
        protected leftposlist: boolean[];
        protected rightposlist: boolean[];
        protected cellsize: number;
        constructor(cellsize: number);
        setCellSize(cellsize: number): void;
        getCellSize(): number;
        getEmptyCell(placedi: PlaceDirection, startindex?: number): number;
        hasEmptyCell(placedi: PlaceDirection, index: number): boolean;
        takeEmptyCell(placedi: PlaceDirection, index: number): boolean;
    }
}
declare module "sk/data/scheme/drawing/constants/DrawingConstants" {
    export enum GraphicContentEnum {
        Outline = 0,
        Actual = 1
    }
    export enum GraphicProcessEnum {
        CloseGraphic = 0,
        Actual = 1
    }
    export enum DrawingModelEnum {
        DrawGraphicId = 0,
        DrawModeling = 1,
        DrawBoundary = 2,
        ToMath = 3
    }
    export enum DrawingNodeTypeEnum {
        Floorplan = "floorplan",
        Room = "room",
        Family = "family"
    }
    export enum DrawingViewTypeEnum {
        Top = 0,
        Ground = 1
    }
    export class DrawingNodeFeatures {
        static DrawingResource: string;
        static LogicCode: string;
        static ProcessedProducts: string;
    }
    export class DrawingNodeLogicCode {
        static CompositeUBPlankFloor: string;
        static CompositeUBPlankWall: string;
        static UBWall: string;
        static UBFloor: string;
        static UBCeiling: string;
    }
    export class DrawingNodeDimensionConstants {
        static readonly OutDimSpace: number;
        static readonly OutDimBorder: number;
    }
    export class DrawingNodeFamilyType {
        static Measure: string;
        static Ware: string;
        static DynamicWare: string;
        static CoverWare: string;
        static DynamicWareUB: string;
        static UBTopPlank: string;
        static UBCurtainPlank: string;
        static UBScreenPlank: string;
        static UBWallPlank: string;
        static UBFloorPlank: string;
        static UBPlankDryFloor: string;
        static UBTileDryFloor: string;
        static UBWall: string;
        static Container: string;
        static Composite: string;
        static Hardware: string;
        static HardwareSupport: string;
        static HardwareSupportCommon: string;
        static HardwareSupportSpecial: string;
        static Tile: string;
    }
    export class DrawingNodeColorConstants {
        static colors: string[];
    }
}
declare module "sk/data/scheme/drawing/config/DrawingNodeConverterConfig" {
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    export class DrawingNodeConverterConfig {
        processCode: string;
        converter: BaseDrawingConverter;
        clazz: Function;
        drawingOption?: DrawingNodeConverterOption;
        init(processCode: string, converterClazz: Function, clazz: Function, drawingOption?: DrawingNodeConverterOption): void;
    }
    export type DrawingNodeConverterOption = {
        code?: string;
        viewType?: DrawingViewTypeEnum;
        containerName?: string;
        hardwareContainerName?: string;
        showMode?: string;
    };
}
declare module "sk/data/scheme/drawing/constants/DrawingContentConstants" {
    export class DrawingContentConstants {
        static DefaultLineWidth: number;
        static DefaultColor: string;
        static DefaultLineType: string;
        static DefaultTextColor: string;
        static DefaultDimColor: string;
        static DefaultTransparency: number;
        static DefaultTextAlgin: number;
        static DefaultTextHeight: number;
        static DefaultTextOffset: number;
        static DefaultTextWidthFactor: number;
        static DefaultArrowType: string;
        static DefaultArrowSize: number;
        static DefaultBorderlineLength: number;
        static DefaultBorderlineExe: number;
        static DefaultLeaderBaseSpace: number;
        static DefaultAccuracy: number;
    }
}
declare module "sk/data/scheme/drawing/context/DrawingNodeContext" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    export class DrawingNodeContext extends ContextObject {
        isSvgDrawingCompute: boolean;
        param: any;
        name: string;
        info: string;
        code: string;
        view: DrawingViewTypeEnum;
        drawingContent: Map<number, any[]>;
        drawingAddContent: Map<number, any[]>;
        observeMatrix: Matrix4;
        constructor(context?: IContext);
        addContent(key: number, value: any[]): void;
        getContent(key: number): any[];
        pushContent(key: number, value: any[]): void;
        getPushContent(key: number): any[];
        dispose(): void;
    }
}
declare module "sk/data/scheme/drawing/data/DrawingNodeOption" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DrawingModelEnum, GraphicContentEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    export class DrawingNodeOption extends InstanceObject {
        drawModel: DrawingModelEnum;
        graphicModelsOrder: GraphicContentEnum[];
        constructor();
    }
    export class DrawingGraphicOption extends InstanceObject {
        replace: boolean;
        replacedOption: DrawingNodeOption;
        constructor();
    }
    export type DrawingNameOption = {
        space: number;
        style: any;
    };
    export type DrawingNodeBorderOption = {
        left?: boolean;
        right?: boolean;
        top?: boolean;
        bottom?: boolean;
        left_box?: boolean;
        right_box?: boolean;
        top_box?: boolean;
        bottom_box?: boolean;
        left_level?: number;
        right_level?: number;
        top_level?: number;
        bottom_level?: number;
        ignoreNoPoints?: boolean;
        cutByBox?: boolean;
        side?: boolean;
        isAutoDistance?: boolean;
        left_autoDistance?: number;
        right_autoDistance?: number;
        top_autoDistance?: number;
        bottom_autoDistance?: number;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomFloorDryNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { StretchingSolid } from 'foundation/runtime/geometry/solid/StretchingSolid';
    import { SectionSurfaceNode } from 'foundation/data/common/model/brep/geometric/surface/SectionSurfaceNode';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomFloorDryNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        static FIELD_POLYGON: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        polygon: SectionSurfaceNode;
        constructor();
        toMath(): StretchingSolid;
        dispose(): void;
        static create(document: Document): BathroomFloorDryNode;
    }
    export type BathroomFloorDryNodeMap = {
        [key: string]: BathroomFloorDryNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomFloorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { StretchingSolid } from 'foundation/runtime/geometry/solid/StretchingSolid';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomFloorNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        toMath(): StretchingSolid;
        dispose(): void;
        static create(document: Document): BathroomFloorNode;
    }
    export type BathroomFloorNodeMap = {
        [key: string]: BathroomFloorNode;
    };
}
declare module "sk/data/scheme/database/ipddata/util/TextUtil" {
    export class TextUtil {
        static FontWidthScale: number;
        static FontHeightScale: number;
        static getTextWidth(fontsize: number, text: string): number;
        static getTextLength(text: string): number;
        static getTextWidthOne(fontsize: number): number;
        static getTextFont(width: number, text: string): number;
        static getTextFontFromHeight(fontheight: number): number;
        static getTextHeight(fontsize: number): number;
    }
}
declare module "sk/data/scheme/drawing/data/DrawingNodeDimension" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonCurve2d } from 'foundation/runtime/geometry/curve2d/PolygonCurve2d';
    export class DrawingNodeDimension extends InstanceObject {
        top: Array<Vector2>;
        bottom: Array<Vector2>;
        left: Array<Vector2>;
        right: Array<Vector2>;
        constructor();
    }
    export type DrawingNodeDimensionData = {
        dimPos: Vector2;
        textPos: Vector2;
        textPolygon: PolygonCurve2d;
        textRotation: number;
        dimValue: number;
        dimText: string;
        valid: boolean;
        border1: Vector2;
        border2: Vector2;
        dimRadian: number;
        positive: boolean;
    };
    export class DrawingUnitBathroomDimensionGroup {
        dimensionNodes: Array<any>;
        noDimensionNodes: Array<any>;
        holeDimensionNodes: Array<any>;
        showDimensionNodes: Array<any>;
        openingDimensionNodes: Array<any>;
        holes: Array<any>;
        tiles: Array<any>;
        wallGeos: Array<any>;
        name: string;
        holeTileMap: Map<any, any>;
        constructor();
    }
}
declare module "sk/data/scheme/drawing/data/DrawingNode" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { DrawingDocument } from 'sk/data/family/drawing/DrawingDocument';
    export type DrawingNode = {
        key?: string;
        linkNodeId: string;
        name: string;
        type: string;
        fullName: string;
        visible?: boolean;
        children?: DrawingNode[];
        drawingItems?: DrawingNodeItem[];
        technologyInvalid: boolean;
        hasInvalidChildren?: boolean;
        hasTechnologyInvalidChildren?: boolean;
        mergeCd?: boolean;
        mergeDownCd?: boolean;
    };
    export type DrawingTree = {
        root: DrawingNode;
    };
    export type DrawingNodeItem = {
        key?: string;
        code: string;
        visible?: boolean;
        invalid?: boolean;
        errorInfo?: DrawingNodeErrorInfo;
        name: string;
        drawingName: string;
        sizeConfig: string;
        defaultSize: string;
        curSize: string;
        path: string;
        document?: DrawingDocument;
        svgMap?: SvgMap;
        taskId?: string;
        subTaskId?: string;
        convertCad?: boolean;
        cadJson?: any;
        cadJsonType?: cadJsonTypeEnum;
    };
    export enum cadJsonTypeEnum {
        cad = 0,
        skdb = 1
    }
    export type DrawingNodeErrorInfo = {
        message: string;
        stack: any;
    };
    export type DrawingNodeBoundary = {
        min: Value2;
        max: Value2;
    };
    export type SvgMap = {
        [key: string]: string;
    };
}
declare module "sk/data/scheme/drawing/data/DrawingNodeValueLineData" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class DrawingNodeValueLineData {
        type: 'h' | 'v';
        value: number;
        from: number;
        to: number;
        length: number;
        begin: Vector3;
        end: Vector3;
        constructor(type?: 'h' | 'v', value?: number, from?: number, to?: number, begin?: Vector3, end?: Vector3, length?: number);
    }
}
declare module "sk/data/scheme/drawing/util/DrawingNodeGeometricUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { PolygonCurve2d } from 'foundation/runtime/geometry/curve2d/PolygonCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Geometric } from 'foundation/runtime/geometry/Geometric';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { BufferAttribute } from 'foundation/runtime/graphics/data/BufferAttribute';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { CircleCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/CircleCurve2dDrawingNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { Text2dNode } from 'sk/data/family/model/assistant/text/Text2dNode';
    import { PointDrawingNode } from 'sk/data/family/model/brep/drawing/PointDrawingNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { WallSurfaceLineAndPath } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { DrawingNodeBoundary } from "sk/data/scheme/drawing/data/DrawingNode";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingNodeValueLineData } from "sk/data/scheme/drawing/data/DrawingNodeValueLineData";
    export class DrawingNodeGeometricUtil {
        static computeDirectionPoints(points: Vector2[], reverse?: boolean): void;
        static computeBoxByPoints(points: Vector2[]): Box2;
        static createGeometricProjectionMathOutline2dKeyPoints(matrixW: Matrix4, matrixP: Matrix4, geometric: Geometric, isPositive?: boolean): Vector2[];
        static createCurve2dsOutlineSectionSurface(curves: Curve2d[], isPositive?: boolean): SectionSurface[];
        static createCurve2dsOutlineSurface(sourceCurves: Curve2d[], isPositive?: boolean): SectionSurface[];
        static computeSurfacesByDirection(surfaces: Surface[], isPositive: boolean): Surface[];
        static computeSurfaceByDirection(surface: Surface, isPositive: boolean): Surface;
        static v3points2v2points(points: Array<Vector3>): Array<Vector2>;
        static v2points2v3points(points: Array<Vector2>): Array<Vector3>;
        static sortPoints(points: Array<Vector2>, property: string, reverse?: boolean): void;
        static spliceRepeatPoint(points: Array<Vector2>, property: string, tolerance?: number): void;
        static spliceSortedRepeatPoints(points: Vector2[]): void;
        static spliceRepeatPointsAll(points: Vector2[] | Vector3[]): void;
        static sortPointsByDirection(points: Vector2[], direction: Vector2): void;
        static sortPointsTwoProperty(points: Vector2[], propertyFirst: string, propertySecond: string, reverseFirst?: boolean, reverseSecond?: boolean): void;
        static pointsCutWithProperty(points: Vector2[], x: boolean, min: number, max: number, tolearance?: number): void;
        protected interOfSegAndSeg(line1: Line2, line2: Line2): Vector2;
        static moveGeometricNodesPerGroup(geoNodes: DataNode[], targetPoint: Vector2): void;
        static createPolygon2d(document: DrawingDataDocument, drawingPoints: Vector2[], style?: any, drawingLevel?: number): PolygonCurve2dDrawingNode;
        static createLineCurve2d(document: DrawingDataDocument, line2d: LineCurve2d, style?: any, drawingLevel?: number): LineCurve2dDrawingNode;
        static createLine2d(document: DrawingDataDocument, begin: Vector2, end: Vector2, style?: any, drawingLevel?: number): LineCurve2dDrawingNode;
        static getBorderClosestPoints(tbs: any, sbs: any): any;
        static getClosestPoints(tps: Array<Vector2>, sps: Array<Vector2>, property: string, sortReverse?: boolean): Array<Vector2>;
        static checkBoxesIntersection(boxes: Vector2[][], box: Vector2[]): boolean;
        static checkTwoBoxesIntersection(box: Vector2[], otherBox: Vector2[]): boolean;
        static checkBoxInOtherBox(sources: Vector2[], targets: Vector2[]): boolean;
        static computePointsOffset(points: Vector2[], offset: Vector2): void;
        static createPoint3(document: DrawingDataDocument, p: Vector3, round?: number): PointDrawingNode;
        static createPoint(document: DrawingDataDocument, x: number, y: number, z: number, round?: number): PointDrawingNode;
        static createRect(document: DrawingDataDocument, startX: number, startY: number, width: number, height: number, style?: any, drawingLevel?: number): BrepNode;
        static createCircleByCenterRadius(document: DrawingDataDocument, center: Vector2, radius: number, style?: any, drawingLevel?: number): CircleCurve2dDrawingNode;
        static createCircleByPoints(document: DrawingDataDocument, begin: Vector2, center: Vector2, style?: any, drawingLevel?: number): CircleCurve2dDrawingNode;
        static pointsClone(points: Vector3[] | Vector2[]): Vector3[] | Vector2[];
        static computeLinesFromPolygon(polygon: PolygonCurve2d): Line2[];
        static computeLineCurve2Line2(curve: LineCurve2d): Line2;
        static computeLineFromLineCurve(curve: LineCurve2d): Line2;
        static getSurfacesLines(surfaces: SectionSurface[]): Curve2d[];
        static getCurveFromCurvesByDirection(lines: Curve2d[], direction: Vector2): Curve2d;
        static getLineFromLinesByDirection(lines: Line2[], direction: Vector2): Line2;
        static transPointsRight2LeftHand(points: any): any;
        static checkPolygonArrayCollidePolygon(polygon2d: PolygonCurve2d, polygon2dArray: PolygonCurve2d[]): boolean;
        static computeObbBox2d(directionx: Vector2, points: Vector2[]): PolygonCurve2d;
        static computeClockwiseBoundaryOutlinesFromNode(node: ContentNode, isAnti?: boolean, observerMatrix?: Matrix4): Line2[];
        static createGeometricProjectionOneOutlineSectionSurface(worldMatrix: Matrix4, projectionMatrix: Matrix4, geometric: Geometric, isPositive?: boolean): SectionSurface;
        static getPathPointsFromPathLines(lines: Line2[], reverse?: boolean): Vector2[];
        static reBuildPathCurvesByCurveFirst(path: PathCurve2d, curve: Curve2d): PathCurve2d;
        static computeNodeInnerDirection(node: ContentNode, observerMatrix?: Matrix4): Vector3;
        static computeNodeInnerDirection2d(node: ContentNode, observeMatrix?: Matrix4): Vector2;
        static computeNodeTopViewInnerDirection(node: ContentNode): Vector2;
        static checkLineIntersectionWithSeg(point: Vector2, direction: Vector2, line: Line2): boolean;
        static convertCurve2dNodes2Curve2ds(nodes: Curve2dNode[]): Curve2d[];
        static computeCurve2dNodesKeyPoints(nodes: Curve2dNode[]): Vector2[];
        static computeNodeAnchorPoint(node: ContentNode, observeMatrix?: Matrix4): Vector2;
        static computeNodeInnerLine(node: ContentNode, observerMatrix?: Matrix4): Line2;
        static computeNodesOrderedByZValue(nodes: ContentNode[], observeMatrix: Matrix4): ContentNode[];
        private static calculateNodesObserverZValue;
        private static sortByObserverZValue;
        static computeLinePathIntersectionWithLine(linep1: Vector2, linep2: Vector2, path: PathCurve2d): Vector2[];
        static computeCutDirectionFromFaceLine(line: LineCurve2d): Vector3;
        static computeLineCurveIntersectionWithLineTopView(linecurve: LineCurve2d, linepoint1: Vector3, linepoint2: Vector3): Vector3;
        static surfaceLineIntersectionCutTopView(prelineandbox: WallSurfaceLineAndPath, nextlineandbox: WallSurfaceLineAndPath): boolean;
        static cutPathWithTolerance(path: PathCurve2d, from: Vector3, to: Vector3, tolerance?: number): PathCurve2d;
        static computeNodeBoundarySection(node: ContentNode, isPositive?: boolean, observeMatrix?: Matrix4, cutSurface?: SectionSurface): SectionSurface[];
        static createGeometricProjectionSurfaces(matrixw: Matrix4, matrixp: Matrix4, geometric: Geometric, isPositive?: boolean): SectionSurface[];
        static computeLineCutPath(linep1: Vector3, linep2: Vector3, path: PathCurve2d, ref?: Array<PathCurve2d>): boolean;
        static computeBoundaryByPoints(points: Vector2[]): Box2;
        static geometricToCurve2d(geo: GeometricNode): Curve2d;
        static geometricsToCurve2ds(geos: GeometricNode[]): Curve2d[];
        static computeAnchorPoint(anchorpoint: Vector3, matrixW: Matrix4, matrixP: Matrix4): Vector2;
        static getNodeDimensionPoints(node: GeometricNode): Vector2[];
        static computeCurveNodeKeyPoints(node: Curve2dNode): Vector2[];
        static computeCurveNodesKeyPoints(curvenodes: Curve2dNode[]): Vector2[];
        static getAllDimensionPoints(nodes: GeometricNode[]): Vector2[];
        static getBoundaryBoxByPoints(ps: Array<Vector2>): Box2;
        static getBound(points: Types<Vector3>): Box2;
        static createSurfaceOutlineCurve(surface: Surface): Curve2d[];
        static createSurfacesOutlineCurves(surfaces: Surface[]): Curve2d[];
        static createGeometricProjectionMathOutlines(matrixw: Matrix4, matrixp: Matrix4, geometric: Geometric, isPositive?: boolean): Curve2d[];
        static drawByPaths(document: DrawingDataDocument, pathcurves: PathCurve2d[], style?: any, drawingLevel?: number): GeometricNode[];
        static createDrawingCurves(document: DrawingDataDocument, curves: Array<Curve2d>, style?: any, drawingLevel?: number): Array<Curve2dNode>;
        static createDrawingCurveWithStyle(document: DrawingDataDocument, curve: Curve2d, style?: any, drawingLevel?: number): Curve2dNode;
        private static createDrawingCurveNode;
        static createSurfaceGeometrics(document: DrawingDataDocument, surface: Surface, style?: any, drawingLevel?: number): GeometricNode[];
        static createSurfacesGeometrics(document: DrawingDataDocument, surfaces: Surface[], style?: any, drawingLevel?: number): GeometricNode[];
        static createCurve2dsOutlineGeometrics(document: DrawingDataDocument, outlines: Curve2d[], style?: any, drawingLevel?: number, isPositive?: boolean): GeometricNode[];
        static createCurve2dsGeometric(document: DrawingDataDocument, outlinecurves: Curve2d[], style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption): BrepNode[];
        static createCurve2dsGeometricByOption(document: DrawingDataDocument, outlinecurves: Curve2d[], drawoption: DrawingNodeOption, isPositive?: boolean, style?: any, drawingLevel?: number): BrepNode[];
        static computeCurvesInsideSection(curves: Array<Curve2d>, section: SectionSurface, includeedge?: boolean, needrebuild?: boolean, tolerance?: number): Curve2d[];
        static computeCurve2dCutBySurface(curve2ds: Curve2d[], cutsurface: SectionSurface, includeedge?: boolean): Curve2d[];
        static createNodeProjectionCurve2ds(matrixw: Matrix4, matrixp: Matrix4, node: ContentNode, drawoption?: DrawingNodeOption): Curve2d[];
        static createGeometricProjections(document: DrawingDataDocument, matrixw: Matrix4, matrixp: Matrix4, geometric: Geometric, style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption, isPositive?: boolean): GeometricNode[];
        static translateDrawingNodes(nodes: BrepNode[], targetPosition: Vector2): void;
        static pointsSplitBorder(boundaryBox: Box2, points: Array<Vector2 | Vector3 | DrawingNodeValueLineData>, center?: Vector2, boxPointInclude?: boolean): any;
        static createNodeProjections(document: DrawingDataDocument, matrixw: Matrix4, matrixp: Matrix4, node: GeometricNode, style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption): GeometricNode[];
        static computeTwoSurfaceIntersectionCurves(surface: Surface, othersurface: Surface, tolerance?: number): Curve2d[];
        static findHorizontalLowestLongestCurve(curves: Curve2d[]): Curve2d;
        static createNodeProjectionMathOutlineSectionSurfaces(matrixw: Matrix4, matrixp: Matrix4, node: ContentNode, isPositive?: boolean, drawoption?: DrawingNodeOption): SectionSurface[];
        static getVertexToV3(att: BufferAttribute, index: number): Vector3;
        static buildLinesStructureFormBufferGeometry(bufferGeo: BufferGeometry, matrixP?: Matrix4): Array<{
            b: Vector3;
            e: Vector3;
        }>;
        static buildLinesFormBufferGeometry(bufferGeo: BufferGeometry, line2OrLine3?: boolean): Array<any>;
        static createNodeOutlineProjections(document: DrawingDataDocument, matrixp: Matrix4, node: GeometricNode, style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption, isPositive?: boolean): GeometricNode[];
        static convertGeometricNode(document: DrawingDataDocument, node: GeometricNode, observerMatrix: Matrix4, ref?: Array<BrepNode>): Array<BrepNode>;
        static textsApplyMatrix(texts: Array<Text2dNode>, matrix: Matrix4): void;
        static nodesApplyMatrix(nodes: Array<BrepNode>, matrix: Matrix4): void;
        static computeNodeZIndex(context: IContext, node: ContentNode, observerMatrix?: Matrix4): number;
        static removeRepeatCircle(nodes: Array<CircleCurve2dDrawingNode>): Array<CircleCurve2dDrawingNode>;
        private static isRepeatCircle;
        static makeLines(outline: Value2[], offset?: Value2): Array<Line2>;
        static computeCenter(vectors?: Array<Vector2> | Array<Vector3>, boundary?: DrawingNodeBoundary): Vector2;
        static computeBounds(points: Array<Vector2> | Array<Vector3>, offset?: Value2): DrawingNodeBoundary;
        static isParallel(outline?: Vector3[], line?: Line2): boolean;
        static getLongest(outline: Vector3[]): Line2;
        static computeLines(outline: Value2[]): any;
        static computeBoundaryPoints(boundary: DrawingNodeBoundary): Array<Vector2>;
        static processBound(bounds: DrawingNodeBoundary): any;
    }
}
declare module "sk/data/scheme/drawing/util/DrawingNodeDimensionUtil" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PolygonCurve2d } from 'foundation/runtime/geometry/curve2d/PolygonCurve2d';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { AlignLineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/AlignLineCurveDimensionDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { Text2dDrawingNode } from 'sk/data/family/model/brep/drawing/text2d/Text2dDrawingNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DimensionNode } from 'sk/data/family/model/assistant/dimension/DimensionNode';
    import { Text2dNode } from 'sk/data/family/model/assistant/text/Text2dNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeDimension, DrawingNodeDimensionData } from "sk/data/scheme/drawing/data/DrawingNodeDimension";
    import { DrawingNodeBorderOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    export class DrawingNodeDimensionUtil {
        static createText(document: DrawingDataDocument, x: number, y: number, w: number, h: number, content?: string, angle?: number, textHeight?: number, style?: any): TextControlNode;
        static createMultiTextWithArr(document: DrawingDataDocument, x: number, y: number, w: number, h: number, content: Array<string>, textHeight: number, style?: any): Array<Text2dDrawingNode>;
        static createMultiText(document: DrawingDataDocument, x: number, y: number, content: string, width?: number, style?: any, drawingLevel?: number): Text2dDrawingNode;
        static createText2d(document: DrawingDataDocument, x: number, y: number, content: string, style?: any, drawingLevel?: number, rotationZ?: number): Text2dDrawingNode;
        static getMaxTextOffset(dims: Array<BrepNode>): number;
        static createOneText(document: DrawingDataDocument, pos: Vector2, content: string, rotation: number, style?: any, drawingLevel?: number): Text2dDrawingNode;
        static createRadiusDimension(document: DrawingDataDocument, center: Vector2, circlePoint: Vector2, leaderLength: number, style?: any, drawingLevel?: number): DimensionNode;
        static createLeaderNode(document: DrawingDataDocument, content: string, point: Vector2, tailPoint: Vector2, angle: number, style?: any, drawingLevel?: number): LeaderDrawingNode;
        static createDiameterDimension(document: DrawingDataDocument, center: Vector2, circlePoint: Vector2, leaderLength: number, style?: any, drawingLevel?: number): DimensionNode;
        static createAlignDimension(document: DrawingDataDocument, pointA: Vector2, pointB: Vector2, dimPoint: Vector2, style?: any, drawingLevel?: number): AlignLineCurveDimensionDrawingNode;
        static createAlignDimensionWithDistance(document: DrawingDataDocument, pointA: Vector2, pointB: Vector2, distance: number, style?: any, drawingLevel?: number): AlignLineCurveDimensionDrawingNode;
        static createDimension(document: DrawingDataDocument, pointA: Vector2, pointB: Vector2, dimPoint: Vector2, angle: number, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode;
        static createDimensionsWithLinePoints(document: DrawingDataDocument, linePoints: Vector2[], distance: number, style?: any, drawingLevel?: number, optionCollider?: boolean, optionAlign?: boolean, reverse?: boolean, isNeedRemoveMinDim?: boolean, minDimTolerateValue?: number): LineCurveDimensionDrawingNode[];
        static createPointsDimensionsFromLine(document: DrawingDataDocument, points: Vector2[], from: Vector2, to: Vector2, distance: number, optionLine?: boolean, style?: any, drawingLevel?: number, optionCollider?: boolean, optionAlign?: boolean): BrepNode[];
        static createDimensionsByPoints(document: DrawingDataDocument, sourcePoints: Vector2[] | Vector3[], box: Box2, distance: number, style?: any, option?: DrawingNodeBorderOption, drawingLevel?: number, optionCollider?: boolean, optionSplit?: boolean): LineCurveDimensionDrawingNode[];
        static dimensionTextOffset(dimNodes: DimensionNode[], offset: number): void;
        static buildLineCurveDimensionNode(document: DrawingDataDocument, dimension: any, dimPoint2d: Vector2, angle: number, style?: any): LineCurveDimensionDrawingNode;
        static computeTextsSplit(document: DrawingDataDocument, texts: BrepNode[], leaderPointOffset?: Vector2): void;
        static getDimensionDataByNode(dim: DimensionNode): DrawingNodeDimensionData;
        static getTextWith(text: string, textH: number): number;
        static getDimTextPolygon(text: string, textHeight: number, textPosition: Vector2, rotation: number): PolygonCurve2d;
        private static getPointByAngle;
        static computeTextOffset(textNode: Text2dNode, textBoxes: Vector2[][]): boolean;
        static computeTextBox(text: BrepNode): Vector2[];
        protected static computeTextEmptySpaceOffset(points: Vector2[], offsets: Vector2[], boxes: Vector2[][]): Vector2;
        static getStyleFromNode(node: BrepNode): any;
        static setNodesDrawLevel(nodes: Array<BrepNode>, drawingLevel: number): void;
        static setNodesStyle(nodes: Array<BrepNode>, style?: any): void;
        static setNodeStyle(node: BrepNode, style?: any): void;
        static setNodesStyleByCode(nodes: Array<BrepNode>, code: string, value: any): void;
        static styleClone(style: any): any;
        static points2Dimensions(points: Array<Vector2>, refs?: Array<any>, endMarkOption?: any): Array<any>;
        static borderPointsToDimensions(bps: any, endRemark?: string): Array<any>;
        static computeDimensionPoints(line: Line2, bound: any, sourceDimNode: DrawingNodeDimension): DrawingNodeDimension;
        static pointsSplitBorderLeftHand(boundaryBox: Box2, points: Array<Vector2 | Vector3>, center?: Vector2, option?: DrawingNodeBorderOption, optionSplit?: boolean): any;
        static createDefaultBorderOption(borderEnable?: boolean, boxEnable?: boolean, levels?: number[], ignoreNoPoints?: boolean, cutByBox?: boolean, side?: boolean): DrawingNodeBorderOption;
        static groupLineCurveDimensionDrawingNodeByDirection(lineCurveDimensionDrawingNodeAry: LineCurveDimensionDrawingNode[]): Map<number, Map<number, LineCurveDimensionDrawingNode[]>>;
        static getNeedRemoveDim(groupLineCurveDimensionDrawingNode: Map<number, Map<number, LineCurveDimensionDrawingNode[]>>): LineCurveDimensionDrawingNode[];
        static getDimValue(lineCurveDimensionDrawingNode: LineCurveDimensionDrawingNode): number;
        static getDimDir(lineCurveDimensionDrawingNode: LineCurveDimensionDrawingNode): number;
        static removeDimByGroup(sameCountDimAry: LineCurveDimensionDrawingNode[][]): LineCurveDimensionDrawingNode[];
        static isSameNode(node1Ary: LineCurveDimensionDrawingNode[], node2Ary: LineCurveDimensionDrawingNode[]): boolean;
        static getAllDimPoint(nodeAry: LineCurveDimensionDrawingNode[], isHDim: boolean): number[];
        static avoidLeaderDimension(leaderDrawingNodeAry: LeaderDrawingNode[]): any[];
        static exchangeMoreInflectPos(element: LeaderDrawingNode[], reCombineLeaderPos: Map<string, Vector2>): LeaderDrawingNode[];
        static exchangeInflectPos(element: LeaderDrawingNode[]): LeaderDrawingNode[];
        static reCombineLeaderDimPos(leaderDimPosMap: Map<Vector2, Vector2>): Vector2[];
        static isMatchPosByPosition(arg0: Vector2, arg1: Vector2, leaderDimPosMap: Map<Vector2, Vector2>): boolean;
        static groupIntersectLeader(leaderDrawingNodeAry: LeaderDrawingNode[]): LeaderDrawingNode[][];
        static isIntersect(item: LeaderDrawingNode, inAry: LeaderDrawingNode[]): boolean;
        static reArrangeLeaderDim(leaderDrawingNodeAry: LeaderDrawingNode[]): any[];
        static excuteReArrange(groupLeader: Map<any, any>): LeaderDrawingNode[];
        static quadrantReArrange(quadrant: number, leaderAry: LeaderDrawingNode[]): LeaderDrawingNode[];
        static groupLeaderByQuadrant(leaderDrawingNodeAry: LeaderDrawingNode[]): Map<number, LeaderDrawingNode[]>;
        static getLeaderAryBox(leaderDrawingNodeAry: LeaderDrawingNode[]): Vector2[];
    }
}
declare module "sk/data/scheme/drawing/util/DrawingNodeConverterUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { MiddleItem, RoomInfo, WallSurfaceLineAndPath } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { DrawingModelEnum, GraphicContentEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    export class DrawingNodeConverterUtil {
        static getHex(value: string): string;
        static getDrawDocumentBox(document: DrawingDataDocument, expand?: Vector2): Box2;
        static getNodeBox(dataNode: DataNode, includeDimText?: boolean): Box2;
        private static getTextTextControlNode;
        private static getTextVectors;
        static hasBathroomFloorDryNode(node: BrepNode): boolean;
        static findChildrenContainerByName(node: DynamicWareNode, name: string, recursive?: boolean): DataNode;
        static getRoomInfos(rooms: Types<RoomNode>): Array<RoomInfo>;
        static computePlanksLineAndBox(planks: ContentNode[], wallDirection: Vector2, isOuter?: boolean): WallSurfaceLineAndPath;
        static hasFeature(node: FamilyInstanceNode, code: string, target: string): boolean;
        static computeFaceLineCutFromPoint(lineAndPath: WallSurfaceLineAndPath, point: Vector3, optionEnd?: boolean): boolean;
        static combineSortedLineAndFaceLineAndExpandPath(line: LineCurve2d, item: WallSurfaceLineAndPath): boolean;
        static computeSortLinesArrayFromItems(items: WallSurfaceLineAndPath[], middleItems: MiddleItem[]): LineCurve2d[];
        static checkContent(content: ContentNode, types: Array<Function>): boolean;
        static contentsExclude(contents: Array<ContentNode>, types: Array<Function>): void;
        static contentsOnlyInclude(contents: Array<ContentNode>, types: Array<Function>): void;
        static getMaxBorderWidth(widths: any): number;
        static createActualFirstDrawOption(): DrawingNodeOption;
        static createOutlineFirstDrawOption(): DrawingNodeOption;
        static createDrawOption(model?: DrawingModelEnum, graphicModelsOrder?: GraphicContentEnum[]): DrawingNodeOption;
        static node2DrawingNodes(document: DrawingDataDocument, nodes: Array<BrepNode>, refs?: Array<BrepNode>): Array<BrepNode>;
        static node2DrawingNode(document: DrawingDataDocument, node: BrepNode): BrepNode;
        static splitBrepNodes(nodes: Array<BrepNode>): any;
    }
}
declare module "sk/data/scheme/drawing/converter/base/BaseDrawingConverter" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { ControlNode } from 'sk/data/family/model/brep/frame/ControlNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingFrameNode } from 'sk/data/family/drawing/model/DrawingFrameNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingGraphDocument } from 'sk/data/family/drawing/DrawingGraphDocument';
    import { DrawingGraphDocumentService } from 'sk/data/family/service/DrawingGraphDocumentService';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { DrawingNodeConverterOption } from "sk/data/scheme/drawing/config/DrawingNodeConverterConfig";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeBorderOption, DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    export type RoomInfo = {
        x: number;
        y: number;
        area: number;
        name: string;
        identifier: string;
        height: number;
    };
    export type DrawingNodeProjectionData = {
        type: string;
        scaleSize: Vector2;
        matrix: Matrix4;
    };
    export type WallSurfaceLineAndPath = {
        faceLine: LineCurve2d;
        path: PathCurve2d;
    };
    export type MiddleItem = {
        curItem: WallSurfaceLineAndPath;
        lines: Curve2d[];
    };
    export class BaseDrawingConverter extends InstanceObject {
        protected _document: DrawingDataDocument;
        protected _domain: DrawingDomainNode;
        protected _boundaryRect: Box2;
        protected drawingGraphDocuments: Dictionary<DrawingGraphDocument>;
        isAsync: boolean;
        protected isExcuteAfterProcess: boolean;
        protected _schemeConfigService: SchemeConfigService;
        protected _drawingGraphDocumentService: DrawingGraphDocumentService;
        constructor(domain?: DrawingDomainNode);
        setup(domain?: DrawingDomainNode): void;
        formatProcess(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        private excuteAfterProcess;
        protected avoidLeaderDimensionIntersect(): void;
        protected removeSameLineCurveDimension(): void;
        private getAllDimensionDrawingNode;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: DrawingNodeConverterOption): Promise<ResultObject<DrawingDataDocument>>;
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        canConvert(node: BrepNode, option?: any): boolean;
        canConvertAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<boolean>;
        protected buildNodeFrame(): void;
        protected createDomain(x: number, y: number, w: number, h: number, parent?: DataNode): DrawingDomainNode;
        protected createFrame(x: number, y: number, w: number, h: number, parent?: DataNode): DrawingFrameNode;
        protected buildFrameBox(frame: DrawingFrameNode): void;
        protected setControlNode(node: ControlNode, x: number, y: number, w: number, h: number, parent?: DataNode): void;
        get document(): DrawingDataDocument;
        protected appendChildNodesArray(children: DataNode[][]): void;
        protected appendChildNodes(children: Array<DataNode>): void;
        protected appendChildNode(child: DataNode): void;
        protected removeChildNode(child: DataNode): void;
        protected removeChildNodes(children: Array<DataNode>): void;
        computeBoundaryRect(expand?: number, box?: Box2): Box2;
        computeBoundaryRectByNodes(nodes: Array<BrepNode>, box?: Box2): Box2;
        appendBoundaryRectByNode(dataNode: DataNode, box?: Box2, includeDimText?: boolean): void;
        appendBoundaryRectByRectAngle(x: number, y: number, w: number, h: number, angle: number, box?: Box2): void;
        appendBoundaryRect(point: PointNode, box?: Box2): void;
        appendBoundaryRectByValue2(v: Value2, box?: Box2): void;
        appendBoundaryRectBox(tBox: Box2, box?: Box2): void;
        appendBoundaryRectByValue2s(vs: Array<Value2>, box?: Box2): void;
        appendBoundaryRectValues(x: number, y: number, box?: Box2): void;
        appendBoundaryRectValue(value: number, box?: Box2): void;
        protected buildDimensions(node: BrepNode, style?: any): void;
        convertFamilyInstancesAsync(context: DrawingNodeContext, nodes: Array<DataNode>, observerMatrix: Matrix4, replace: boolean, deep?: boolean, refs?: Array<BrepNode>): Promise<Array<BrepNode>>;
        protected findNodeGraphicId(node: DataNode): string;
        protected drawFamilyInstancesByGraphIdAsync(context: DrawingNodeContext, nodes: DataNode[], observerMatrix: Matrix4, replace: boolean, style?: any, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption, checkValid?: boolean): Promise<Array<BrepNode>>;
        protected creatFamilyInstancesByGraphIdAsync(context: DrawingNodeContext, nodes: DataNode[], observerMatrix: Matrix4, replace: boolean, style?: any, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
        protected drawNodesByGraphicIdAsync(context: DrawingNodeContext, nodes: ContentNode[], observerMatrix: Matrix4, replace: boolean, style?: any, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
        protected drawNodeByGraphicIdAsync(context: IContext, node: ContentNode, observerMatrix: Matrix4, replace: boolean, style?: any, drawingLevel?: number, usepositiondrawingLevel?: boolean, replaceoption?: DrawingNodeOption): Promise<Array<BrepNode>>;
        protected drawFamilyInstanceByGraphIdAsync(context: DrawingNodeContext, node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
        protected creatFamilyInstanceByGraphIdAsync(context: DrawingNodeContext, node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
        convertFamilyInstanceAsync(context: DrawingNodeContext, node: DataNode, observerMatrix: Matrix4, replace: boolean, deep?: boolean, ref?: Array<BrepNode>): Promise<Array<BrepNode>>;
        computeNodeResourceTypeByObserverData(node: ContentNode, matrix: Matrix4): DrawingNodeProjectionData;
        convertGraphByIdTypeAsync(context: DrawingNodeContext, graphId: string, viewType: string, size: Value2, picMatrix: Matrix4, ref?: Array<BrepNode>): Promise<Array<BrepNode>>;
        getGraphContentsAsync(context: IContext, graphId: string, type: string): Promise<DrawingGraphDocument>;
        drawNodeProjections(worldMatrix: Matrix4, projectionMatrix: Matrix4, node: GeometricNode, style?: any, drawingLevel?: number, option?: DrawingNodeOption): GeometricNode[];
        protected drawNodeDimensions(wall: GeometricNode, size: number, style?: any, option?: DrawingNodeBorderOption, drawingLevel?: number): LineCurveDimensionDrawingNode[];
        computeDomainBoundary(expandnumber?: number): void;
        protected computeCanvasBoundary(): void;
        cleanDomainChildren(): void;
        protected drawDimensionsFromBox(nodes: GeometricNode[], box2: Box2, size: number, style?: any, option?: DrawingNodeBorderOption, drawingLevel?: number, optionCollider?: boolean): LineCurveDimensionDrawingNode[];
        protected drawDimensionsByBox(box: Box2, distance: number, style?: any, option?: DrawingNodeBorderOption, drawingLevel?: number, optionCollider?: boolean, split?: boolean): LineCurveDimensionDrawingNode[];
        protected drawDimensionsByPoints(allPoints: Vector2[] | Vector3[], box: Box2, distance: number, style?: any, option?: DrawingNodeBorderOption, drawingLevel?: number, optionCollider?: boolean, split?: boolean): LineCurveDimensionDrawingNode[];
        flipY(): void;
        protected buildDimensionByBorderPointsWithCollider(bps: any, distance: number, optionCollider: boolean, remark?: string, offset?: number, style?: any, textStyle?: any, drawingLevel?: number, borderWidths?: any): void;
        protected clearBoundaryData(): void;
        protected computeNodesBoundary(nodes: DataNode[], includeDimText?: boolean): Box2;
        protected computeNodeBoundary(node: DataNode, includeDimText?: boolean): Box2;
        protected drawPlankDirectionArrow(container: WareNode, projectionMatrix: Matrix4, width: number, height: number, style?: any): void;
        private sortVector3;
        protected drawArrowAtPoint(point: Vector2, direction: Vector2, width: number, height: number, style?: any): GeometricNode;
        protected drawingPolygonByVectors(document: DrawingDataDocument, vectors: Vector3[] | Vector2[], style?: any, drawingLevel?: number): PolygonCurve2dDrawingNode;
        protected drawSurfaceLineAndBoxIntersection(drawItems: WallSurfaceLineAndPath[], style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected drawInvalidText(node: any): void;
        dispose(flag?: boolean): void;
    }
}
declare module "sk/data/scheme/database/ipddata/parse/i2g/I2GBaseConvert" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { GraphicsModel } from "sk/data/scheme/database/ipddata/graphics/model/GraphicsModel";
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    export class I2GBaseConvert extends BaseDrawingConverter {
        protected gramodel: GraphicsModel;
        protected parseType: number;
        constructor(domain?: DrawingDomainNode);
        protected getCellSize(brepnode: BrepNode): number;
        protected computePolygonMinSize(polygon: PolygonCurve2dDrawingNode): number;
        setModel(gramodel: GraphicsModel): void;
        setParseType(parseType: number): void;
        getParseType(): number;
        parseIpd(ipd: IpdBase): BrepNode[];
    }
}
declare module "sk/data/scheme/database/ipddata/parse/i2g/I2GGrooveConvert" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    import { I2GBaseConvert } from "sk/data/scheme/database/ipddata/parse/i2g/I2GBaseConvert";
    export class I2GGrooveConvert extends I2GBaseConvert {
        parseIpd(ipd: IpdBase): BrepNode[];
    }
}
declare module "sk/data/scheme/database/ipddata/parse/i2g/I2GHardwareConvert" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    import { IpdHardware } from "sk/data/scheme/database/ipddata/ipd/entity/IpdHardware";
    import { I2GBaseConvert } from "sk/data/scheme/database/ipddata/parse/i2g/I2GBaseConvert";
    export class I2GHardwareConvert extends I2GBaseConvert {
        protected cellszie: any;
        protected centerpos: Vector2;
        parseIpd(ipd: IpdBase): BrepNode[];
        computeDomainBoundary(): void;
        createPolygon(hardware: IpdHardware, centerX: number, centerY: number, width: number, height: number): PolygonCurve2dDrawingNode;
        private trimStringZero;
        private createPolygonDims;
    }
}
declare module "sk/data/scheme/database/ipddata/parse/i2g/I2GHoleConvert" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    import { I2GBaseConvert } from "sk/data/scheme/database/ipddata/parse/i2g/I2GBaseConvert";
    export class I2GHoleConvert extends I2GBaseConvert {
        parseIpd(ipd: IpdBase): BrepNode[];
    }
}
declare module "sk/data/scheme/database/ipddata/parse/i2g/I2GMillingConvert" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    import { I2GBaseConvert } from "sk/data/scheme/database/ipddata/parse/i2g/I2GBaseConvert";
    export class I2GMillingConvert extends I2GBaseConvert {
        parseIpd(ipd: IpdBase): BrepNode[];
        protected drawMillingStraight(begin: Vector2, end: Vector2): void;
        protected drawStraightArrow(arrowtopp: Vector2, arrowdirection: Vector2, arrowlength: number): void;
        protected drawMillingArc(begin: Vector2, end: Vector2, center: Vector2, isPositive: boolean, radius: number, arrowlength?: number): void;
        protected drawArcArrow(arrowtop: Vector2, center: Vector2, positive: boolean, arrowlength: number, radius: number): void;
        protected createArcArrow(arrowtop: Vector2, center: Vector2, positive: boolean, arrowlength: number, radius: number, style?: any, drawingLevel?: number): Curve2dNode;
        protected getPointByAngel(radian: number, center: Vector2, radius: number): Vector2;
    }
}
declare module "sk/data/scheme/database/ipddata/parse/i2g/I2GPlankConvert" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    import { IpdGroove } from "sk/data/scheme/database/ipddata/ipd/entity/IpdGroove";
    import { IpdHole } from "sk/data/scheme/database/ipddata/ipd/entity/IpdHole";
    import { IpdMilling } from "sk/data/scheme/database/ipddata/ipd/entity/IpdMilling";
    import { IpdPlank } from "sk/data/scheme/database/ipddata/ipd/entity/IpdPlank";
    import { I2GBaseConvert } from "sk/data/scheme/database/ipddata/parse/i2g/I2GBaseConvert";
    export class I2GPlankConvert extends I2GBaseConvert {
        parseIpd(ipd: IpdBase): BrepNode[];
        protected fetchIpdChildren(plank: IpdPlank, clazz: Function): IpdBase[];
        protected replaceErrorIdWithCodeNumber(error: string, holelist: IpdHole[], millinglist: IpdMilling[], groovelist: IpdGroove[]): string;
        private createEdgesize;
        private createMillingSize;
        private createDecreSize;
        private createHoleText;
        private createAllHoleDimensionLeft;
        private createAllHoleDimensionRight;
        private createAllHoleDimensionUp;
        private createAllHoleDimensionDown;
        private createDimensionLeftFromXYDic;
        private createDimensionUpFromXYDic;
        private createDimensionRightFromXYDic;
        private createDimensionDownFromXYDic;
        private createSubRectHole;
        private createSubRectAndProcess;
        private createRect;
        private createEdgeDims;
        private trimStringZero;
        private arraySortTailINCRE;
        private arraySortTailDECRE;
        private arraySortIncrement;
        private arraySortDECRE;
    }
}
declare module "sk/data/scheme/database/ipddata/util/DimensionUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    export class DimensionUtil {
        static createDimensionLeft(points: Vector2[], leftedge: number, cellsize: number, borderlength: number, textheight: number, linecolor: string, linewidth: number, textcolor: string, showlevel: number, document: DrawingDataDocument): LineCurveDimensionDrawingNode[];
        static createDimensionRight(points: Vector2[], rightedge: number, cellsize: number, borderlength: number, textheight: number, linecolor: string, linewidth: number, textcolor: string, showlevel: number, document: DrawingDataDocument): LineCurveDimensionDrawingNode[];
        static createDimensionUp(points: Vector2[], upedge: number, cellsize: number, borderlength: number, textheight: number, linecolor: string, linewidth: number, textcolor: string, showlevel: number, document: DrawingDataDocument): LineCurveDimensionDrawingNode[];
        static createDimensionDown(points: Vector2[], downedge: number, cellsize: number, borderlength: number, textheight: number, linecolor: string, linewidth: number, textcolor: string, showlevel: number, document: DrawingDataDocument): LineCurveDimensionDrawingNode[];
        private static arraySortIncre;
        private static nearlyContain;
    }
}
declare module "sk/data/scheme/database/ipddata/util/G2DUtil" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class G2DUtil {
        static CENTERPOINT: Vector2;
        static MOVEMENT: Vector2;
        private static MODELSCALE;
        private static MODELMATRIX;
        static initMovement(movementx: number, movementy: number): void;
        static initModelMatrix(matrix: Matrix4): void;
        static initScale(rootEleWidthRaw: number, rootEleHeightRaw: number, backGroundWidth: number, backGroundHeight: number): void;
        static setScale(scale: number): void;
        static getScale(): number;
        static initCenterPoint(scale: number, rootEleWidthRaw: number, rootEleHeightRaw: number, backGroundWidth: number, backGroundHeight: number): void;
        static length2Drawing(length: number): number;
        static pos2Drawing(pos: Vector2): Vector2;
        static pos2DrawingByMatrix(pos: Vector2): Vector2;
        static length2DrawingByMatrix(length: number): number;
        static resetUtilData(): void;
    }
}
declare module "sk/data/scheme/database/ipddata/util/IpdConvertUtil" {
    export class IpdConvertUtil {
        static floatToFixed2(num: number): number;
    }
}
declare module "sk/data/scheme/database/light/element/AreaLightElement" {
    import { LightElement } from 'sk/data/family/element/instance/LightElement';
    export class AreaLightElement extends LightElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DISTANCE_DECAY_ENABLED: string;
        static FIELD_DISTANCE_DECAY_BEGIN: string;
        static FIELD_DISTANCE_DECAY_END: string;
        distanceDecayEnabled: boolean;
        distanceDecayBegin: number;
        distanceDecayEnd: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AreaLightElementMap = {
        [key: string]: AreaLightElement;
    };
}
declare module "sk/data/scheme/database/light/element/PointLightElement" {
    import { LightElement } from 'sk/data/family/element/instance/LightElement';
    export class PointLightElement extends LightElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DISTANCE_DECAY_ENABLED: string;
        static FIELD_DISTANCE_DECAY_BEGIN: string;
        static FIELD_DISTANCE_DECAY_END: string;
        distanceDecayEnabled: boolean;
        distanceDecayBegin: number;
        distanceDecayEnd: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type PointLightElementMap = {
        [key: string]: PointLightElement;
    };
}
declare module "sk/data/scheme/database/light/element/SpotLightElement" {
    import { LightElement } from 'sk/data/family/element/instance/LightElement';
    export class SpotLightElement extends LightElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_FALLSIZE: string;
        static FIELD_HOTSPOT: string;
        static FIELD_DISTANCE_DECAY_ENABLED: string;
        static FIELD_DISTANCE_DECAY_BEGIN: string;
        static FIELD_DISTANCE_DECAY_END: string;
        fallsize: number;
        hotspot: number;
        distanceDecayEnabled: boolean;
        distanceDecayBegin: number;
        distanceDecayEnd: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type SpotLightElementMap = {
        [key: string]: SpotLightElement;
    };
}
declare module "sk/data/scheme/database/light/model/AreaLightNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { LineCurve3d } from 'foundation/runtime/geometry/curve3d/LineCurve3d';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    export class AreaLightNode extends LightNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DISTANCE_DECAY_ENABLED: string;
        static FIELD_DISTANCE_DECAY_BEGIN: string;
        static FIELD_DISTANCE_DECAY_END: string;
        distanceDecayEnabled: boolean;
        distanceDecayBegin: number;
        distanceDecayEnd: number;
        constructor();
        toMath(): BoxSolid;
        toMathNonDecay(): BoxSolid;
        toMathDecay(): BoxSolid;
        getDirLine(): LineCurve3d;
        dispose(): void;
        static create(document: Document): AreaLightNode;
    }
    export type AreaLightNodeMap = {
        [key: string]: AreaLightNode;
    };
}
declare module "sk/data/scheme/database/light/model/PointLightNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { LineCurve3d } from 'foundation/runtime/geometry/curve3d/LineCurve3d';
    import { SphereSolid } from 'foundation/runtime/geometry/solid/SphereSolid';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    export class PointLightNode extends LightNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DISTANCE_DECAY_ENABLED: string;
        static FIELD_DISTANCE_DECAY_BEGIN: string;
        static FIELD_DISTANCE_DECAY_END: string;
        distanceDecayEnabled: boolean;
        distanceDecayBegin: number;
        distanceDecayEnd: number;
        constructor();
        toMath(): SphereSolid;
        toMathNonDecay(): SphereSolid;
        toMathDecay(): SphereSolid;
        getDirLine(): LineCurve3d;
        dispose(): void;
        static create(document: Document): PointLightNode;
    }
    export type PointLightNodeMap = {
        [key: string]: PointLightNode;
    };
}
declare module "sk/data/scheme/database/light/model/SpotLightNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { LineCurve3d } from 'foundation/runtime/geometry/curve3d/LineCurve3d';
    import { ConeSolid } from 'foundation/runtime/geometry/solid/ConeSolid';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    export class SpotLightNode extends LightNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_FALLSIZE: string;
        static FIELD_HOTSPOT: string;
        static FIELD_DISTANCE_DECAY_ENABLED: string;
        static FIELD_DISTANCE_DECAY_BEGIN: string;
        static FIELD_DISTANCE_DECAY_END: string;
        fallsize: number;
        hotspot: number;
        distanceDecayEnabled: boolean;
        distanceDecayBegin: number;
        distanceDecayEnd: number;
        constructor();
        toMath(): ConeSolid;
        toMathNonDecay(): ConeSolid;
        toMathDecay(): ConeSolid;
        toMathHotDecay(): ConeSolid;
        getDirLine(): LineCurve3d;
        dispose(): void;
        static create(document: Document): SpotLightNode;
    }
    export type SpotLightNodeMap = {
        [key: string]: SpotLightNode;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleAreaElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleAreaElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleAreaElementMap = {
        [key: string]: AssembleAreaElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingAreaElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingAreaElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingAreaElementMap = {
        [key: string]: AssembleCeilingAreaElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingBaseElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingBaseElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        baseThickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingBaseElementMap = {
        [key: string]: AssembleCeilingBaseElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingCornerElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingCornerElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingCornerElementMap = {
        [key: string]: AssembleCeilingCornerElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingDecorateElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingDecorateElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        decorateThickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingDecorateElementMap = {
        [key: string]: AssembleCeilingDecorateElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { CeilingEdgeHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/assemble/ceiling/CeilingEdgeHoldTypeEnum';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingEdgeElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_LEFT_OFFSET: string;
        static FIELD_RIGHT_OFFSET: string;
        static FIELD_FINISH: string;
        static FIELD_LEFT_HOLD_TYPE: string;
        static FIELD_RIGHT_HOLD_TYPE: string;
        static FIELD_LEFT_CORNER_TYPE: string;
        static FIELD_RIGHT_CORNER_TYPE: string;
        static FIELD_CLOCKWISE: string;
        static FIELD_OUTLINE: string;
        static FIELD_DECORATE_LAYER: string;
        thickness: number;
        leftOffset: number;
        rightOffset: number;
        finish: number;
        leftHoldType: CeilingEdgeHoldTypeEnum;
        rightHoldType: CeilingEdgeHoldTypeEnum;
        leftCornerType: CornerTypeEnum;
        rightCornerType: CornerTypeEnum;
        clockwise: boolean;
        outline: PolygonSurfaceStructure;
        decorateLayer: any;
        prev: AssembleCeilingEdgeElement;
        next: AssembleCeilingEdgeElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingEdgeElementMap = {
        [key: string]: AssembleCeilingEdgeElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingHangingElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingHangingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HANGING_THICKNESS: string;
        static FIELD_OUTLINE: string;
        hangingThickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingHangingElementMap = {
        [key: string]: AssembleCeilingHangingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingLayerElementBase" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingLayerElementBase extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        polygon: AreaPolygonElement;
        isMirrorX: boolean;
        isMirrorY: boolean;
        holes: Array<Array<Vector2>>;
        constructor();
        addChild(element: BrepElement, dispatch?: boolean): void;
        reset(): void;
    }
    export type AssembleCeilingLayerElementBasetMap = {
        [key: string]: AssembleCeilingLayerElementBase;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement" {
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssembleCeilingEdgeElement } from "sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class AssembleCeilingPlaneElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_POLYGON: string;
        static FIELD_DECORATE_LAYER: string;
        polygon: SectionSurfaceStructure;
        decorateLayer: DecorateLayerElement;
        root: AssembleCeilingEdgeElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingPlaneElementMap = {
        [key: string]: AssembleCeilingPlaneElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCeilingSurfaceElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCeilingSurfaceElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        static FIELD_SURFACE_THICKNESS: string;
        outline: PolygonSurfaceStructure;
        surfaceThickness: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCeilingSurfaceElementMap = {
        [key: string]: AssembleCeilingSurfaceElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCompositeCeilingElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCompositeCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_OUTLINE: string;
        baseSurfaceDecorateId: string;
        outline: PolygonSurfaceStructure;
        thickness: number;
        baseThickness: number;
        isXmirror: boolean;
        isYmirror: boolean;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCompositeCeilingElementMap = {
        [key: string]: AssembleCompositeCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCompositeWallBaseElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCompositeWallBaseElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_TOP_DISTANCE: string;
        static FIELD_BASE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankTopDistance: number;
        basePlankBottomDistance: number;
        basePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCompositeWallBaseElementMap = {
        [key: string]: AssembleCompositeWallBaseElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleCompositeWallSurfaceElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleCompositeWallSurfaceElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_TOP_DISTANCE: string;
        static FIELD_BASE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_TOP_DISTANCE: string;
        static FIELD_SURFACE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_TOP_DISTANCE: string;
        static FIELD_DECORATE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankTopDistance: number;
        basePlankBottomDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankTopDistance: number;
        surfacePlankBottomDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankTopDistance: number;
        decoratePlankBottomDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleCompositeWallSurfaceElementMap = {
        [key: string]: AssembleCompositeWallSurfaceElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleDoorElement" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { RoomElement } from "sk/data/scheme/database/floorplan/element/RoomElement";
    import { WallElement } from "sk/data/scheme/database/floorplan/element/WallElement";
    export class AssembleDoorElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_WALL_WORK_INNER_DISTANCE: string;
        static FIELD_WALL_WORK_OUTER_DISTANCE: string;
        static FIELD_OUTLINE: string;
        static FIELD_GROUND_OUTLINE: string;
        wallWorkInnerDistance: number;
        wallWorkOuterDistance: number;
        outline: PolygonSurfaceStructure;
        groundOutline: PolygonSurfaceStructure;
        bindWall: WallElement;
        originalPosition: Vector2;
        constructor();
        protected checkInRoom(room: RoomElement): boolean;
        reset(): void;
        dispose(): void;
    }
    export type AssembleDoorElementMap = {
        [key: string]: AssembleDoorElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleFlatWallPlankConfigElement" {
    import { Element } from 'sk/data/family/element/base/Element';
    export class AssembleFlatWallPlankConfigElement extends Element {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_BASE_PLANK_BEGIN_DISTANCE: string;
        static FIELD_BASE_PLANK_END_DISTANCE: string;
        static FIELD_SURFACE_PLANK_BEGIN_DISTANCE: string;
        static FIELD_SURFACE_PLANK_END_DISTANCE: string;
        baseThickness: number;
        surfaceThickness: number;
        basePlankBeginDistance: number;
        basePlankEndDistance: number;
        surfacePlankBeginDistance: number;
        surfacePlankEndDistance: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleFlatWallPlankConfigElementMap = {
        [key: string]: AssembleFlatWallPlankConfigElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleFloorplanElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleFloorplanElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleFloorplanElementMap = {
        [key: string]: AssembleFloorplanElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleLayerElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleLayerElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleLayerElementMap = {
        [key: string]: AssembleLayerElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleWallBaseElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleWallBaseElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        static FIELD_BASE_PLANK_TOP_DISTANCE: string;
        static FIELD_BASE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        baseThickness: number;
        outline: PolygonSurfaceStructure;
        basePlankTopDistance: number;
        basePlankBottomDistance: number;
        basePlankLeftDistance: number;
        basePlankRightDistance: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleWallBaseElementMap = {
        [key: string]: AssembleWallBaseElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleWallDecorateElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleWallDecorateElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_TOP_DISTANCE: string;
        static FIELD_DECORATE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        outline: PolygonSurfaceStructure;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankTopDistance: number;
        decoratePlankBottomDistance: number;
        decoratePlankRightDistance: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleWallDecorateElementMap = {
        [key: string]: AssembleWallDecorateElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleWallHardwareElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleWallHardwareElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleWallHardwareElementMap = {
        [key: string]: AssembleWallHardwareElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/AssembleWallSurfaceElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class AssembleWallSurfaceElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_TOP_DISTANCE: string;
        static FIELD_SURFACE_PLANK_BOTTOM_DISTANCE: string;
        outline: PolygonSurfaceStructure;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankRightDistance: number;
        surfacePlankTopDistance: number;
        surfacePlankBottomDistance: number;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type AssembleWallSurfaceElementMap = {
        [key: string]: AssembleWallSurfaceElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomClosestoolElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomClosestoolElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomClosestoolElementMap = {
        [key: string]: BathroomClosestoolElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomConverElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomConverElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomConverElementMap = {
        [key: string]: BathroomConverElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomDoorElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomDoorElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomDoorElementMap = {
        [key: string]: BathroomDoorElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomFloorDrainElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomFloorDrainElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomFloorDrainElementMap = {
        [key: string]: BathroomFloorDrainElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomFloorWetSlotElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomFloorWetSlotElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SEAM_THICKNESS: string;
        static FIELD_FINISH: string;
        static FIELD_FLOOR_WET_PLANK_INFO_ID: string;
        static FIELD_FLOOR_WET_SURFACE_INFO_ID: string;
        static FIELD_FLOOR_WET_SEAM_INFO_ID: string;
        static FIELD_FLOOR_WET_DRAIN_INFO_ID: string;
        static FIELD_FLOOR_WET_STONE_INFO_ID: string;
        static FIELD_FLOOR_WET_SLOT_INFO_ID: string;
        static FIELD_OUTLINE: string;
        static FIELD_OUTLINE_GAP: string;
        static FIELD_POLYGON: string;
        static FIELD_TECHNOLOGY_TYPE: string;
        static FIELD_GAP: string;
        static FIELD_START_X: string;
        static FIELD_START_Y: string;
        static FIELD_TILE_LENGTH_X: string;
        static FIELD_TILE_LENGTH_Y: string;
        static FIELD_OFFSET_X: string;
        static FIELD_OFFSET_Y: string;
        static FIELD_DESIGN_THICKNESS: string;
        static FIELD_SLOT_UP_DIS: string;
        static FIELD_SLOT_DOWN_DIS: string;
        static FIELD_SLOT_LEFT_DIS: string;
        static FIELD_SLOT_RIGHT_DIS: string;
        baseThickness: number;
        surfaceThickness: number;
        seamThickness: number;
        finish: number;
        floorWetPlankInfoId: string;
        floorWetSurfaceInfoId: string;
        floorWetSeamInfoId: string;
        floorWetDrainInfoId: string;
        floorWetStoneInfoId: string;
        floorWetSlotInfoId: string;
        outline: PolygonSurfaceStructure;
        outlineGap: number;
        polygon: SectionSurfaceStructure;
        technologyType: string;
        gap: number;
        startX: number;
        startY: number;
        tileLengthX: number;
        tileLengthY: number;
        offsetX: number;
        offsetY: number;
        designThickness: number;
        slotUpDis: number;
        slotDownDis: number;
        slotLeftDis: number;
        slotRightDis: number;
        constructor();
        get thickness(): string;
        set thickness(value: string);
        reset(): void;
        dispose(): void;
    }
    export type BathroomFloorWetSlotElementMap = {
        [key: string]: BathroomFloorWetSlotElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomFloorWetWareElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomFloorWetWareElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_TYPE: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        type: string;
        outline: PolygonSurfaceStructure;
        constructor();
        reset(): void;
    }
    export type BathroomFloorWetWareElementMap = {
        [key: string]: BathroomFloorWetWareElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomHeaterElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomHeaterElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomHeaterElementMap = {
        [key: string]: BathroomHeaterElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomSpliterElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomSpliterElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomSpliterElementMap = {
        [key: string]: BathroomSpliterElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BathroomTypeEnum" {
    export class DivideTypeEnum {
        static default: string;
        static headTailDivide: string;
        static tailTailDivide: string;
    }
}
declare module "sk/data/scheme/database/pattern/element/BathroomWallCupboardElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BathroomWallCupboardElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BathroomWallCupboardElementMap = {
        [key: string]: BathroomWallCupboardElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BedroomBedElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BedroomBedElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BedroomBedElementMap = {
        [key: string]: BedroomBedElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BedroomElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BedroomElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BedroomElementMap = {
        [key: string]: BedroomElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/BedroomWardrobeElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class BedroomWardrobeElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type BedroomWardrobeElementMap = {
        [key: string]: BedroomWardrobeElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/CompositeCeilingElement" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssembleCompositeCeilingElement } from "sk/data/scheme/database/pattern/element/AssembleCompositeCeilingElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class CompositeCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_ASSEMBLE: string;
        static FIELD_DECORATE_LAYER: string;
        assemble: AssembleCompositeCeilingElement;
        decorateLayer: DecorateLayerElement;
        thickness: number;
        baseThickness: number;
        baseSurfaceDecorateId: string;
        outline: PolygonSurfaceStructure;
        polygon: AreaPolygonElement;
        isMirrorX: boolean;
        isMirrorY: boolean;
        holes: Array<Array<Vector2>>;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CompositeCeilingElementMap = {
        [key: string]: CompositeCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/CompositeWallElement" {
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssembleCompositeWallBaseElement } from "sk/data/scheme/database/pattern/element/AssembleCompositeWallBaseElement";
    import { AssembleCompositeWallSurfaceElement } from "sk/data/scheme/database/pattern/element/AssembleCompositeWallSurfaceElement";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class CompositeWallElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_TOP_DISTANCE: string;
        static FIELD_BASE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_TOP_DISTANCE: string;
        static FIELD_SURFACE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_TOP_DISTANCE: string;
        static FIELD_DECORATE_PLANK_BOTTOM_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_START_WALL: string;
        static FIELD_IS_PRESS_PRE: string;
        static FIELD_IS_PRESS_NEXT: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankTopDistance: number;
        basePlankBottomDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankTopDistance: number;
        surfacePlankBottomDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankTopDistance: number;
        decoratePlankBottomDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        isStartWall: boolean;
        isPressPre: boolean;
        isPressNext: boolean;
        assembleBaseWall: AssembleCompositeWallBaseElement;
        assembleSurfaceWall: AssembleCompositeWallSurfaceElement;
        decorateLayer: DecorateLayerElement;
        prev: CompositeWallElement;
        next: CompositeWallElement;
        idx: number;
        bindElement: ContentInstanceElement;
        constructor();
        isWallPlank(): boolean;
        isWindowPlank(): boolean;
        isBeamPlank(): boolean;
        private isIndependentColumn;
        reset(): void;
        dispose(): void;
    }
    export type CompositeWallElementMap = {
        [key: string]: CompositeWallElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/ContainerTypeEnum" {
    export class ContainerTypeEnum {
        static Wall: string;
        static WallBaseBackboard: string;
        static WallFaceTile: string;
        static WallSeamBackboard: string;
        static WallHole: string;
        static FloorDry: string;
        static FloorDryBaseBackboard: string;
        static FloorDrySeam: string;
        static FloorDryFaceTile: string;
        static Ceiling: string;
        static CeilingBase: string;
        static CeilingFace: string;
        static FloorWet: string;
        static FloorWetBaseBackBoard: string;
        static FloorWetSeam: string;
        static FloorWetFaceTile: string;
    }
}
declare module "sk/data/scheme/database/pattern/element/CupboardEmbedElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class CupboardEmbedElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CupboardEmbedElementMap = {
        [key: string]: CupboardEmbedElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/CupboardFloorElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class CupboardFloorElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CupboardFloorElementMap = {
        [key: string]: CupboardFloorElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/CupboardNormalElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class CupboardNormalElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CupboardNormalElementMap = {
        [key: string]: CupboardNormalElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/CupboardWallElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class CupboardWallElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type CupboardWallElementMap = {
        [key: string]: CupboardWallElement;
    };
}
declare module "sk/data/scheme/database/pattern/node/config/DecorateLayerFamilyInfo" {
    import { DecorateLayerMaterialTypeEnum } from "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum";
    export type DecorateLayerFamilyInfo = {
        familyType: DecorateLayerMaterialTypeEnum;
        controlNode?: any;
        materialInfoId?: string;
    };
}
declare module "sk/data/scheme/database/pattern/element/DecorateLayerElementUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { PlaneSurfaceElement } from 'sk/data/family/element/instance/PlaneSurfaceElement';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { DecorateLayerFamilyInfo } from "sk/data/scheme/database/pattern/node/config/DecorateLayerFamilyInfo";
    import { DecorateLayerMaterialTypeEnum } from "sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export type DecorateLayerInfoCache = {
        isNull: boolean;
        materialInfoId?: string;
        layoutElement?: LayoutElement;
        directionEnum?: RelativeDirectionEnum;
        areaPolygonElements?: Types<AreaPolygonElement>;
    };
    export class DecorateLayerElementUtil {
        protected static _schemeConfigService: SchemeConfigService;
        static syncDecorateLayerInfoAsync(context: ContextObject, decorateLayer: DecorateLayerElement, decorateLayerMaterialInfoId?: string): Promise<ResultObject>;
        static decorateLayerDesignInfoAsync(context: ContextObject, decorateLayer: DecorateLayerElement, decorateLayerMaterialInfoId?: string): Promise<ResultObject>;
        static getPlankInfoAsync(context: ContextObject, decorateLayer: DecorateLayerElement): Promise<ResultObject<any>>;
        static buildPatternDecorateLayerAsync(context: ContextObject, element: any, builderAsync: any): Promise<ResultObject>;
        static findPlaneSurfaceElement(element: any, directionEnum?: RelativeDirectionEnum): PlaneSurfaceElement;
        static updateAssembleDecorateLayerAsync(context: ContextObject, element: DecorateLayerElement, familyInfoId: string, type: DecorateLayerMaterialTypeEnum, directionEnum?: RelativeDirectionEnum): Promise<void>;
        private static updateAllSurfacesOfPlank;
        static findDecorateInfoID(element: DecorateLayerElement): string;
        static cachedDecorateInfo(decorateLayer: DecorateLayerElement, directionEnum?: RelativeDirectionEnum): DecorateLayerInfoCache;
        static restoreDecorateInfo(decorateLayer: DecorateLayerElement, decorateInfoCache: DecorateLayerInfoCache): void;
        private static buildElementByReferenceAsync;
        static getDecorateLayerFamilyInfo(element: ContentInstanceElement): DecorateLayerFamilyInfo;
        static computeNewLayoutTileInfos(tileInfo: any, plankPolygon: Array<Vector2>, decorateLayer: DecorateLayerElement, layoutElement: LayoutElement): string;
        static completeTile(tilePolygon: Array<Value2>, plankPolygon: Array<Value2>, isFloor: boolean, tileLengthX: number, tileLengthY: number, tileGap: number, tolerance?: number): Array<Value2>;
        static cutTile(tilePolygon: Array<Value2>, plankPolygon: Array<Value2>): Array<Vector2>;
    }
}
declare module "sk/data/scheme/database/pattern/element/FlatWallGroupElement" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { FlatWallElement } from "sk/data/scheme/database/pattern/element/FlatWallElement";
    export class FlatWallGroupElement extends FamilyInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_MEMBERS: string;
        static FIELD_MAIN: string;
        members: Types<FlatWallElement>;
        main: FlatWallElement;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type FlatWallGroupElementMap = {
        [key: string]: FlatWallGroupElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/FlatwallTypeEnum" {
    export class FlatwallTypeEnum {
        static FreeArrange: string;
        static InHole: string;
        static BuildByWall: string;
    }
}
declare module "sk/data/scheme/database/pattern/element/FloorCupboardElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class FloorCupboardElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type FloorCupboardElementMap = {
        [key: string]: FloorCupboardElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenBasinElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenBasinElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenBasinElementMap = {
        [key: string]: KitchenBasinElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenHearthElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenHearthElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenHearthElementMap = {
        [key: string]: KitchenHearthElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenRangeHoodElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenRangeHoodElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenRangeHoodElementMap = {
        [key: string]: KitchenRangeHoodElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenroomElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenroomElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenroomElementMap = {
        [key: string]: KitchenroomElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenroomFloorCabinetElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenroomFloorCabinetElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenroomFloorCabinetElementMap = {
        [key: string]: KitchenroomFloorCabinetElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenroomSurfaceElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenroomSurfaceElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenroomSurfaceElementMap = {
        [key: string]: KitchenroomSurfaceElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenroomWallCabinetElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenroomWallCabinetElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenroomWallCabinetElementMap = {
        [key: string]: KitchenroomWallCabinetElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/KitchenSinkElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class KitchenSinkElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type KitchenSinkElementMap = {
        [key: string]: KitchenSinkElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LampCeilingElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class LampCeilingElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type LampCeilingElementMap = {
        [key: string]: LampCeilingElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LampEmbedElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class LampEmbedElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type LampEmbedElementMap = {
        [key: string]: LampEmbedElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LampStripElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class LampStripElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type LampStripElementMap = {
        [key: string]: LampStripElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LevelingWallLayerFlagEnum" {
    export class LevelingWallLayerFlagEnum {
        static Leveler: number;
        static Base: number;
        static Surface: number;
        static Decorate: number;
    }
}
declare module "sk/data/scheme/database/pattern/element/LivingroomDiningElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class LivingroomDiningElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type LivingroomDiningElementMap = {
        [key: string]: LivingroomDiningElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LivingroomElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class LivingroomElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type LivingroomElementMap = {
        [key: string]: LivingroomElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LivingroomRestElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class LivingroomRestElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type LivingroomRestElementMap = {
        [key: string]: LivingroomRestElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/LivingroomVideoElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class LivingroomVideoElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type LivingroomVideoElementMap = {
        [key: string]: LivingroomVideoElement;
    };
}
declare module "sk/data/scheme/util/SchemeDecorateUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ISpecificationFamily } from 'sk/data/specification/base/ISpecificationFamily';
    import { DecorateController } from 'sk/data/family/element/config/decorate/DecorateController';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { SchemeConfigDecorateInfo } from "sk/data/scheme/config/SchemeConfigDecorateInfo";
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    export class SchemeDecorateUtil {
        protected static _calculatorService: CalculatorService;
        protected static _schemeConfigService: SchemeConfigService;
        static getDecorateItemFamilyAsync(context: ContextObject, decorate: SchemeConfigDecorateInfo): Promise<ResultObject<ISpecificationFamily>>;
        static saveDocumentDecorateInfoAsync(document: FamilyDocument): Promise<void>;
        static syncVisionModelDecorate(element: any, code: any): void;
        protected static saveElementDecorateToControllerAsync(element: NestElement, controller: DecorateController): Promise<void>;
    }
}
declare module "sk/data/scheme/database/pattern/element/PatternElementUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamily } from 'sk/data/specification/base/ISpecificationFamily';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ComponentPatternElement } from 'sk/data/family/element/pattern/ComponentPatternElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { SchemeLibraryPatternDocumentService } from "sk/data/scheme/config/SchemeLibraryPatternDocumentService";
    import { SchemeWorkflowOptions } from "sk/data/scheme/service/SchemeDocumentService";
    import { DecorateLayerElement } from "sk/data/scheme/database/pattern/element/DecorateLayerElement";
    export class PatternElementUtil {
        protected static _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        static findPatternElementByFamilyInfoIdAsync(context: ContextObject, familyInfoId: string, clazz: Function): Promise<ResultObject<ComponentPatternElement>>;
        static getPatternElementRootElementAsync(context: ContextObject, familyInfoId: string): Promise<ResultObject<ComponentPatternElement>>;
        static getPatternDocumentByFamilyInfoIdAsync(context: ContextObject, patternInfoId: string): Promise<ResultObject>;
        static findPatternElementByDocument(patternDocument: PatternDocument, clazz: Function): ComponentPatternElement;
        static getFamilyInfoIdByLinkAsync(context: ContextObject, linkElement: LinkerPatternElement): Promise<ResultObject<string>>;
        static getFamilyInfoIdsByLinkAsync(context: ContextObject, linkElement: LinkerPatternElement): Promise<ResultObject<Array<string>>>;
        static getFamilyIdByLinkAsync(context: ContextObject, linkElement: LinkerPatternElement): Promise<ResultObject<string>>;
        static switchVisible(element: BrepElement): void;
        static computeWorkflowVisonAsync(element?: BrepElement, options?: SchemeWorkflowOptions): Promise<ResultObject>;
        static getDecorateValueByLinkAsync(context: ContextObject, linkElement: LinkerPatternElement, decorateCode?: string): Promise<ResultObject<{
            decorateValue: DecorateValueStructure;
            familyContent: ISpecificationFamily;
        }>>;
        static setDecorateLayerByLinkAsync(context: ContextObject, decorateLayer: DecorateLayerElement, linkElement: LinkerPatternElement): Promise<ResultObject>;
    }
}
declare module "sk/data/scheme/database/pattern/element/WallSurfaceSocketElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class WallSurfaceSocketElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type WallSurfaceSocketElementMap = {
        [key: string]: WallSurfaceSocketElement;
    };
}
declare module "sk/data/scheme/database/pattern/element/WallSurfaceSwitchElement" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    export class WallSurfaceSwitchElement extends PatternInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type WallSurfaceSwitchElementMap = {
        [key: string]: WallSurfaceSwitchElement;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleAreaNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleAreaNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleAreaNode;
    }
    export type AssembleAreaNodeMap = {
        [key: string]: AssembleAreaNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleBathroomNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleBathroomNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleBathroomNode;
    }
    export type AssembleBathroomNodeMap = {
        [key: string]: AssembleBathroomNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleBeamNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleBeamNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_FINISH_LEFT_DISTANCE: string;
        static FIELD_FINISH_RIGHT_DISTANCE: string;
        static FIELD_FINISH_BOTTOM_DISTANCE: string;
        static FIELD_START_CONTRACTION: string;
        static FIELD_END_CONTRACTION: string;
        static FIELD_HAS_LEFT_PANK: string;
        static FIELD_HAS_RIGHT_PLANK: string;
        static FIELD_ORIGIN_HIGH: string;
        static FIELD_ORIGIN_BOTTOM_Z: string;
        static FIELD_OUTLINE: string;
        finishLeftDistance: number;
        finishRightDistance: number;
        finishBottomDistance: number;
        startContraction: number;
        endContraction: number;
        hasLeftPank: boolean;
        hasRightPlank: boolean;
        originHigh: number;
        originBottomZ: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleBeamNode;
    }
    export type AssembleBeamNodeMap = {
        [key: string]: AssembleBeamNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingAreaNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCeilingAreaNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingAreaNode;
    }
    export type AssembleCeilingAreaNodeMap = {
        [key: string]: AssembleCeilingAreaNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingBaseNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCeilingBaseNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        baseThickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingBaseNode;
    }
    export type AssembleCeilingBaseNodeMap = {
        [key: string]: AssembleCeilingBaseNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingCornerNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCeilingCornerNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingCornerNode;
    }
    export type AssembleCeilingCornerNodeMap = {
        [key: string]: AssembleCeilingCornerNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingDecorateNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCeilingDecorateNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        decorateThickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingDecorateNode;
    }
    export type AssembleCeilingDecorateNodeMap = {
        [key: string]: AssembleCeilingDecorateNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingEdgeNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { DecorateLayerNode } from "sk/data/scheme/database/pattern/node/DecorateLayerNode";
    export class AssembleCeilingEdgeNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DECORATE_LAYER: string;
        decorateLayer: DecorateLayerNode;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingEdgeNode;
    }
    export type AssembleCeilingEdgeNodeMap = {
        [key: string]: AssembleCeilingEdgeNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingHangingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCeilingHangingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HANGING_THICKNESS: string;
        static FIELD_OUTLINE: string;
        hangingThickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingHangingNode;
    }
    export type AssembleCeilingHangingNodeMap = {
        [key: string]: AssembleCeilingHangingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingNode;
    }
    export type AssembleCeilingNodeMap = {
        [key: string]: AssembleCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingPlaneNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { DecorateLayerNode } from "sk/data/scheme/database/pattern/node/DecorateLayerNode";
    export class AssembleCeilingPlaneNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DECORATE_LAYER: string;
        decorateLayer: DecorateLayerNode;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingPlaneNode;
    }
    export type AssembleCeilingPlaneNodeMap = {
        [key: string]: AssembleCeilingPlaneNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCeilingSurfaceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCeilingSurfaceNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        surfaceThickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCeilingSurfaceNode;
    }
    export type AssembleCeilingSurfaceNodeMap = {
        [key: string]: AssembleCeilingSurfaceNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleColumnNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleColumnNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleColumnNode;
    }
    export type AssembleColumnNodeMap = {
        [key: string]: AssembleColumnNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCompositeCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCompositeCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCompositeCeilingNode;
    }
    export type AssembleCompositeCeilingNodeMap = {
        [key: string]: AssembleCompositeCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCompositeWallBaseNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCompositeWallBaseNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCompositeWallBaseNode;
    }
    export type AssembleCompositeWallBaseNodeMap = {
        [key: string]: AssembleCompositeWallBaseNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleCompositeWallSurfaceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleCompositeWallSurfaceNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleCompositeWallSurfaceNode;
    }
    export type AssembleCompositeWallSurfaceNodeMap = {
        [key: string]: AssembleCompositeWallSurfaceNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleDoorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleDoorNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_WALL_WORK_INNER_DISTANCE: string;
        static FIELD_WALL_WORK_OUTER_DISTANCE: string;
        static FIELD_OUTLINE: string;
        static FIELD_GROUND_OUTLINE: string;
        wallWorkInnerDistance: number;
        wallWorkOuterDistance: number;
        outline: PolygonSurfaceStructure;
        groundOutline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleDoorNode;
    }
    export type AssembleDoorNodeMap = {
        [key: string]: AssembleDoorNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleFlatWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleFlatWallNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleFlatWallNode;
    }
    export type AssembleFlatWallNodeMap = {
        [key: string]: AssembleFlatWallNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleFloorplanNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleFloorplanNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleFloorplanNode;
    }
    export type AssembleFloorplanNodeMap = {
        [key: string]: AssembleFloorplanNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleLayerNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleLayerNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleLayerNode;
    }
    export type AssembleLayerNodeMap = {
        [key: string]: AssembleLayerNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleLevelingCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { StretchingSolid } from 'foundation/runtime/geometry/solid/StretchingSolid';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleLevelingCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        toMath(): StretchingSolid;
        dispose(): void;
        static create(document: Document): AssembleLevelingCeilingNode;
    }
    export type AssembleLevelingCeilingNodeMap = {
        [key: string]: AssembleLevelingCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleLevelingFloorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { StretchingSolid } from 'foundation/runtime/geometry/solid/StretchingSolid';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleLevelingFloorNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_SURFACE_DECORATE_ID: string;
        static FIELD_PLANK_TILE_FLIP: string;
        static FIELD_PLANK_TILE_ROTATION: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        baseSurfaceDecorateId: string;
        decorateThickness: number;
        decorateSurfaceDecorateId: string;
        plankTileFlip: boolean;
        plankTileRotation: number;
        outline: PolygonSurfaceStructure;
        constructor();
        toMath(): StretchingSolid;
        get totalThickness(): number;
        dispose(): void;
        static create(document: Document): AssembleLevelingFloorNode;
    }
    export type AssembleLevelingFloorNodeMap = {
        [key: string]: AssembleLevelingFloorNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssemblePelmetNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssemblePelmetNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_HEIGHT: string;
        static FIELD_SPACE_WIDTH: string;
        static FIELD_LEFT_MARGIN: string;
        static FIELD_RIGHT_MARGIN: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_LAPPED: string;
        height: number;
        spaceWidth: number;
        leftMargin: number;
        rightMargin: number;
        outline: PolygonSurfaceStructure;
        isLapped: boolean;
        constructor();
        dispose(): void;
        static create(document: Document): AssemblePelmetNode;
    }
    export type AssemblePelmetNodeMap = {
        [key: string]: AssemblePelmetNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleWallBaseNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleWallBaseNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_OUTLINE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankRightDistance: number;
        outline: PolygonSurfaceStructure;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleWallBaseNode;
    }
    export type AssembleWallBaseNodeMap = {
        [key: string]: AssembleWallBaseNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleWallDecorateNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleWallDecorateNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        outline: PolygonSurfaceStructure;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleWallDecorateNode;
    }
    export type AssembleWallDecorateNodeMap = {
        [key: string]: AssembleWallDecorateNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleWallHardwareNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleWallHardwareNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_HARDWARE_NAIL: string;
        static FIELD_HARDWARE_SUPPORT: string;
        static FIELD_HARDWARE_SUPPORT_SPECIAL: string;
        outline: PolygonSurfaceStructure;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        hardwareNail: LinkerPatternElement;
        hardwareSupport: LinkerPatternElement;
        hardwareSupportSpecial: LinkerPatternElement;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleWallHardwareNode;
    }
    export type AssembleWallHardwareNodeMap = {
        [key: string]: AssembleWallHardwareNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleWallSurfaceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleWallSurfaceNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_OUTLINE: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        surfaceThickness: number;
        outline: PolygonSurfaceStructure;
        surfacePlankLeftDistance: number;
        surfacePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleWallSurfaceNode;
    }
    export type AssembleWallSurfaceNodeMap = {
        [key: string]: AssembleWallSurfaceNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/AssembleWindowNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class AssembleWindowNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_INNER_DEPTH: string;
        static FIELD_WALL_THICKNESS: string;
        static FIELD_LEVELER_MIN_DISTANCE: string;
        static FIELD_OUTLINE: string;
        innerDepth: number;
        wallThickness: number;
        levelerMinDistance: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): AssembleWindowNode;
    }
    export type AssembleWindowNodeMap = {
        [key: string]: AssembleWindowNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomAreaNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomAreaNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomAreaNode;
    }
    export type BathroomAreaNodeMap = {
        [key: string]: BathroomAreaNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { StretchingSolid } from 'foundation/runtime/geometry/solid/StretchingSolid';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        toMath(): StretchingSolid;
        dispose(): void;
        static create(document: Document): BathroomCeilingNode;
    }
    export type BathroomCeilingNodeMap = {
        [key: string]: BathroomCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomClosestoolNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomClosestoolNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomClosestoolNode;
    }
    export type BathroomClosestoolNodeMap = {
        [key: string]: BathroomClosestoolNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomConverNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomConverNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomConverNode;
    }
    export type BathroomConverNodeMap = {
        [key: string]: BathroomConverNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomDoorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomDoorNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_OUTLINE: string;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomDoorNode;
    }
    export type BathroomDoorNodeMap = {
        [key: string]: BathroomDoorNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomFloorDrainNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomFloorDrainNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomFloorDrainNode;
    }
    export type BathroomFloorDrainNodeMap = {
        [key: string]: BathroomFloorDrainNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomFloorWetNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomFloorWetNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomFloorWetNode;
    }
    export type BathroomFloorWetNodeMap = {
        [key: string]: BathroomFloorWetNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomFloorWetSlotNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomFloorWetSlotNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomFloorWetSlotNode;
    }
    export type BathroomFloorWetSlotNodeMap = {
        [key: string]: BathroomFloorWetSlotNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomFloorWetWareNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomFloorWetWareNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomFloorWetWareNode;
    }
    export type BathroomFloorWetWareNodeMap = {
        [key: string]: BathroomFloorWetWareNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomHeaterNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomHeaterNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomHeaterNode;
    }
    export type BathroomHeaterNodeMap = {
        [key: string]: BathroomHeaterNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomShowerNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomShowerNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomShowerNode;
    }
    export type BathroomShowerNodeMap = {
        [key: string]: BathroomShowerNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomSpliterNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomSpliterNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomSpliterNode;
    }
    export type BathroomSpliterNodeMap = {
        [key: string]: BathroomSpliterNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomWallCupboardNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomWallCupboardNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        static create(document: Document): BathroomWallCupboardNode;
    }
    export type BathroomWallCupboardNodeMap = {
        [key: string]: BathroomWallCupboardNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BathroomWallNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        thickness: number;
        constructor();
        dispose(): void;
        static create(document: Document): BathroomWallNode;
    }
    export type BathroomWallNodeMap = {
        [key: string]: BathroomWallNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BathroomWallNodeUtil" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    export class BathroomWallNodeUtil {
        static findCutHolesByBathroomWall(bathroomWall: BathroomWallNode): Array<HoleStructure>;
        static isDiryBathroomWallCutHoles(bathroomWall: BathroomWallNode): boolean;
        static findLinkRoom(node: BathroomNode): RoomNode;
        protected static findBindValue(node: ContentNode, parameterCode: string, findslave?: boolean): string;
    }
}
declare module "sk/data/scheme/database/pattern/node/BedroomBedNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BedroomBedNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BedroomBedNode;
    }
    export type BedroomBedNodeMap = {
        [key: string]: BedroomBedNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BedroomNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BedroomNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BedroomNode;
    }
    export type BedroomNodeMap = {
        [key: string]: BedroomNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/BedroomWardrobeNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class BedroomWardrobeNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BedroomWardrobeNode;
    }
    export type BedroomWardrobeNodeMap = {
        [key: string]: BedroomWardrobeNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/CompositeCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { AssembleCeilingNode } from "sk/data/scheme/database/pattern/node/AssembleCeilingNode";
    import { DecorateLayerNode } from "sk/data/scheme/database/pattern/node/DecorateLayerNode";
    export class CompositeCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_ASSEMBLE: string;
        static FIELD_DECORATE_LAYER: string;
        assemble: AssembleCeilingNode;
        decorateLayer: DecorateLayerNode;
        constructor();
        dispose(): void;
        static create(document: Document): CompositeCeilingNode;
    }
    export type CompositeCeilingNodeMap = {
        [key: string]: CompositeCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/CompositeWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class CompositeWallNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_PLANK_LEFT_DISTANCE: string;
        static FIELD_BASE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_SURFACE_THICKNESS: string;
        static FIELD_SURFACE_PLANK_LEFT_DISTANCE: string;
        static FIELD_SURFACE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_PLANK_LEFT_DISTANCE: string;
        static FIELD_DECORATE_PLANK_RIGHT_DISTANCE: string;
        static FIELD_WALL_BEGIN_OFFSET_X: string;
        static FIELD_WALL_END_OFFSET_X: string;
        static FIELD_OUTLINE: string;
        static FIELD_IS_PRESS_PRE: string;
        static FIELD_IS_PRESS_NEXT: string;
        static FIELD_IS_START_WALL: string;
        thickness: number;
        baseThickness: number;
        basePlankLeftDistance: number;
        basePlankRightDistance: number;
        surfaceThickness: number;
        surfacePlankLeftDistance: number;
        surfacePlankRightDistance: number;
        decorateThickness: number;
        decoratePlankLeftDistance: number;
        decoratePlankRightDistance: number;
        wallBeginOffsetX: number;
        wallEndOffsetX: number;
        outline: PolygonSurfaceStructure;
        isPressPre: boolean;
        isPressNext: string;
        isStartWall: boolean;
        constructor();
        dispose(): void;
        static create(document: Document): CompositeWallNode;
    }
    export type CompositeWallNodeMap = {
        [key: string]: CompositeWallNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/CupboardEmbedNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class CupboardEmbedNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): CupboardEmbedNode;
    }
    export type CupboardEmbedNodeMap = {
        [key: string]: CupboardEmbedNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/CupboardFloorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class CupboardFloorNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): CupboardFloorNode;
    }
    export type CupboardFloorNodeMap = {
        [key: string]: CupboardFloorNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/CupboardNormalNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class CupboardNormalNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): CupboardNormalNode;
    }
    export type CupboardNormalNodeMap = {
        [key: string]: CupboardNormalNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/CupboardWallNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class CupboardWallNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): CupboardWallNode;
    }
    export type CupboardWallNodeMap = {
        [key: string]: CupboardWallNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/FlatWallGroupNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    export class FlatWallGroupNode extends FamilyInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_MEMBERS: string;
        static FIELD_MAIN: string;
        members: Types<FlatWallNode>;
        main: FlatWallNode;
        constructor();
        dispose(): void;
        static create(document: Document): FlatWallGroupNode;
    }
    export type FlatWallGroupNodeMap = {
        [key: string]: FlatWallGroupNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/FloorCupboardNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class FloorCupboardNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        static create(document: Document): FloorCupboardNode;
    }
    export type FloorCupboardNodeMap = {
        [key: string]: FloorCupboardNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenBasinNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenBasinNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenBasinNode;
    }
    export type KitchenBasinNodeMap = {
        [key: string]: KitchenBasinNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenHearthNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenHearthNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenHearthNode;
    }
    export type KitchenHearthNodeMap = {
        [key: string]: KitchenHearthNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenRangeHoodNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenRangeHoodNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenRangeHoodNode;
    }
    export type KitchenRangeHoodNodeMap = {
        [key: string]: KitchenRangeHoodNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenroomFloorCabinetNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenroomFloorCabinetNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenroomFloorCabinetNode;
    }
    export type KitchenroomFloorCabinetNodeMap = {
        [key: string]: KitchenroomFloorCabinetNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenroomNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenroomNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenroomNode;
    }
    export type KitchenroomNodeMap = {
        [key: string]: KitchenroomNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenroomSurfaceNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenroomSurfaceNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenroomSurfaceNode;
    }
    export type KitchenroomSurfaceNodeMap = {
        [key: string]: KitchenroomSurfaceNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenroomWallCabinetNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenroomWallCabinetNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenroomWallCabinetNode;
    }
    export type KitchenroomWallCabinetNodeMap = {
        [key: string]: KitchenroomWallCabinetNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/KitchenSinkNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class KitchenSinkNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): KitchenSinkNode;
    }
    export type KitchenSinkNodeMap = {
        [key: string]: KitchenSinkNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LampCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LampCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): LampCeilingNode;
    }
    export type LampCeilingNodeMap = {
        [key: string]: LampCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LampEmbedNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LampEmbedNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): LampEmbedNode;
    }
    export type LampEmbedNodeMap = {
        [key: string]: LampEmbedNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LampStripNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LampStripNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): LampStripNode;
    }
    export type LampStripNodeMap = {
        [key: string]: LampStripNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LevelingCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { StretchingSolid } from 'foundation/runtime/geometry/solid/StretchingSolid';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LevelingCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        outline: PolygonSurfaceStructure;
        constructor();
        toMath(): StretchingSolid;
        dispose(): void;
        static create(document: Document): LevelingCeilingNode;
    }
    export type LevelingCeilingNodeMap = {
        [key: string]: LevelingCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LevelingFloorNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { StretchingSolid } from 'foundation/runtime/geometry/solid/StretchingSolid';
    import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LevelingFloorNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_THICKNESS: string;
        static FIELD_BASE_THICKNESS: string;
        static FIELD_BASE_SURFACE_DECORATE_ID: string;
        static FIELD_DECORATE_THICKNESS: string;
        static FIELD_DECORATE_SURFACE_DECORATE_ID: string;
        static FIELD_OUTLINE: string;
        thickness: number;
        baseThickness: number;
        baseSurfaceDecorateId: string;
        decorateThickness: number;
        decorateSurfaceDecorateId: string;
        outline: PolygonSurfaceStructure;
        constructor();
        toMath(): StretchingSolid;
        dispose(): void;
        static create(document: Document): LevelingFloorNode;
    }
    export type LevelingFloorNodeMap = {
        [key: string]: LevelingFloorNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LivingroomDiningNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LivingroomDiningNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): LivingroomDiningNode;
    }
    export type LivingroomDiningNodeMap = {
        [key: string]: LivingroomDiningNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LivingroomNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LivingroomNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): LivingroomNode;
    }
    export type LivingroomNodeMap = {
        [key: string]: LivingroomNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LivingroomRestNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LivingroomRestNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): LivingroomRestNode;
    }
    export type LivingroomRestNodeMap = {
        [key: string]: LivingroomRestNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/LivingroomVidioNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class LivingroomVidioNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): LivingroomVidioNode;
    }
    export type LivingroomVidioNodeMap = {
        [key: string]: LivingroomVidioNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/PelmetNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class PelmetNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): PelmetNode;
    }
    export type PelmetNodeMap = {
        [key: string]: PelmetNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/ProxyCeilingNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { AssembleCeilingNode } from "sk/data/scheme/database/pattern/node/AssembleCeilingNode";
    import { DecorateLayerNode } from "sk/data/scheme/database/pattern/node/DecorateLayerNode";
    export class ProxyCeilingNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_ASSEMBLE: string;
        static FIELD_DECORATE_LAYER: string;
        assemble: AssembleCeilingNode;
        decorateLayer: DecorateLayerNode;
        constructor();
        dispose(): void;
        static create(document: Document): ProxyCeilingNode;
    }
    export type ProxyCeilingNodeMap = {
        [key: string]: ProxyCeilingNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/util/CompleteLineElementUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    export class CompleteLineElementUtil {
        static checkCompleteLineAreaFunc(entity: any): boolean;
        static getPolygonRoomOutline(area: AreaPolygonElement): Array<Vector2>;
        static creatCompleteLineByRoom(room: RoomNode): void;
        static getRoomPolygon(room: RoomNode): Vector2[];
        static getRoomPolygon1(room: RoomNode): Vector2[];
        static getRoomPolygon2(room: RoomNode): Vector2[];
        static getRoomCompleteLinePolygon(room: RoomNode, defaultThickness?: number): Vector2[];
    }
}
declare module "sk/data/scheme/database/pattern/node/util/AssembleRoomNodeTecDivUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { DecorateSurfaceLineInfo, WallSurfaceLineInfo } from "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil";
    import { CeilingSurfaceElement } from "sk/data/scheme/database/floorplan/element/CeilingSurfaceElement";
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { AssembleCeilingElement } from "sk/data/scheme/database/pattern/element/AssembleCeilingElement";
    import { LevelingCeilingElement } from "sk/data/scheme/database/pattern/element/LevelingCeilingElement";
    import { LevelingFloorElement } from "sk/data/scheme/database/pattern/element/LevelingFloorElement";
    import { LevelingWallElement } from "sk/data/scheme/database/pattern/element/LevelingWallElement";
    import { AssembleLevelingWallNode } from "sk/data/scheme/database/pattern/node/AssembleLevelingWallNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    export class AssembleRoomNodeTecDivUtil {
        static getRelationLevelingWall(cowallNode: CowallNode): LevelingWallElement;
        static getRelationParalelLevelingWalls(cowallNode: CowallNode): Array<LevelingWallElement>;
        static getRoomCompleteLineArea(room: RoomNode): AreaPolygonElement;
        static getRoomDecoratePolygonInfo(room: RoomNode): Array<DecorateSurfaceLineInfo>;
        static getRoomDecoratePolygon(room: RoomNode): Array<Vector2>;
        static getRoomWorkPolygonInfo(room: RoomNode, clipDoorHole?: boolean): Array<WallSurfaceLineInfo>;
        private static getRoomWorkPolygonInfoByClipper;
        private static getCutHolesInfo;
        static getRoomWorkClipHolesPolygonInfo(roomNode: RoomNode): Array<Line2>;
        private static getLevelingWallBox;
        private static checkSegmentCover;
        private static getCrossLinesToPoints;
        static getRoomAssembleCeiling(room: RoomNode): LevelingCeilingElement | AssembleCeilingElement;
        static getRoomAssembleFloor(room: RoomNode): LevelingFloorElement;
        static getRoomCeilingWorkThickness(room: RoomNode): number;
        static getRoomFloorWorkThickness(room: RoomNode): number;
        static getRoomCeilingOriginalPolygons(room: RoomNode, decorateLine?: boolean): Array<{
            polygon: Array<Vector2>;
            surface: CeilingSurfaceElement;
        }>;
        static getRoomPelmetPolygons(levelingWallNode: LevelingWallNode, roomNode: RoomNode): Array<Array<Vector2>>;
        static getRoomPelmetLines(levelingWallNode: LevelingWallNode, roomNode: RoomNode): Array<Array<Vector2>>;
        static getBeamPolygon(beam: BeamNode): Array<Vector2>;
        static getAssembleBeamPolygon(beam: BeamNode): Array<Vector2>;
        static getAssembleLevelingWallPolygon(lWall: AssembleLevelingWallNode): Array<Vector2>;
        private static getPelmetLine;
        private static getPelmetPolygons;
        static getRoomCeilingWorkPolygons(room: RoomNode, decorateLine?: boolean): Array<{
            polygon: Array<Vector2>;
            surface: CeilingSurfaceElement;
        }>;
    }
}
declare module "sk/data/scheme/database/pattern/node/util/BathroomWallInfoUtil" {
    import { HoleElement } from "sk/data/scheme/database/floorplan/element/HoleElement";
    import { AssembleBathroomElement } from "sk/data/scheme/database/pattern/element/AssembleBathroomElement";
    import { BathroomElement } from "sk/data/scheme/database/pattern/element/BathroomElement";
    import { BathroomWallElement } from "sk/data/scheme/database/pattern/element/BathroomWallElement";
    export class BathroomWallInfoUtil {
        static slectBathroomInfloorplanHoleValue(bathroom: BathroomElement, hole: HoleElement): {
            dir: boolean;
            holeValue: number;
        };
        static selectBathroomWallByHole(hole: HoleElement, bathroom: AssembleBathroomElement): BathroomWallElement;
        static calculateAngle(hole: HoleElement, bathroom: AssembleBathroomElement, bathroomWall: BathroomWallElement): number;
        static calculateCavityDistance(hole: HoleElement, bathroom: AssembleBathroomElement, bathroomWall: BathroomWallElement): number;
        private static convertLine2ToLocalPosition;
        private static convertSinglePointReleativeOrigin;
        private static findClosetWallLineFromHole;
        private static getDistancePointToLine;
        private static getHoleCenterLine;
    }
}
declare module "sk/data/scheme/database/pattern/node/util/DecorateLayerNodeUtil" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { LayoutNode } from 'sk/data/family/model/instance/LayoutNode';
    import { DecorateLayerFamilyInfo } from "sk/data/scheme/database/pattern/node/config/DecorateLayerFamilyInfo";
    export class DecorateLayerNodeUtil {
        static getDecorateLayerInfo(node: ContentInstanceNode): DecorateLayerFamilyInfo;
        private static setDecorateLayerInfo;
        static getDecorateMaterialLayoutParentNode(node: ContentNode): ContentNode;
        static getDecorateLayoutIndex(node: LayoutNode): number;
        static getDecorateAreaPolygonIndex(node: AreaPolygonNode): number;
        static getMaterialDepthScale(node: BrepNode): number;
    }
}
declare module "sk/data/scheme/database/pattern/node/WallSurfaceSocketNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class WallSurfaceSocketNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): WallSurfaceSocketNode;
    }
    export type WallSurfaceSocketNodeMap = {
        [key: string]: WallSurfaceSocketNode;
    };
}
declare module "sk/data/scheme/database/pattern/node/WallSurfaceSwitchNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class WallSurfaceSwitchNode extends PatternInstanceNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): WallSurfaceSwitchNode;
    }
    export type WallSurfaceSwitchNodeMap = {
        [key: string]: WallSurfaceSwitchNode;
    };
}
declare module "sk/data/scheme/database/plumbing/element/PipeElement" {
    import { LinearElement } from 'sk/data/family/element/instance/LinearElement';
    export class PipeElement extends LinearElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type PipeElementMap = {
        [key: string]: PipeElement;
    };
}
declare module "sk/data/scheme/database/plumbing/element/PipeSegmentElement" {
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    export class PipeSegmentElement extends FamilyInstanceElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        reset(): void;
        dispose(): void;
    }
    export type PipeSegmentElementMap = {
        [key: string]: PipeSegmentElement;
    };
}
declare module "sk/data/scheme/database/technology/element/TechnologyPouchMillingElement" {
    import { ElementStructure } from 'foundation/data/common/element/ElementStructure';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    export class TechnologyPouchMillingElement extends TechnologyElement {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_DEPTH: string;
        depth: number;
        constructor();
        static create(familyStructure: ElementStructure): TechnologyPouchMillingElement;
        reset(): void;
        dispose(): void;
    }
    export type TechnologyPouchMillingElementMap = {
        [key: string]: TechnologyPouchMillingElement;
    };
}
declare module "sk/data/scheme/database/technology/util/HardwareElementUtil" {
    export class HardwareElementUtil {
    }
}
declare module "sk/data/scheme/database/technology/util/HardwareHoleElementUtil" {
    export class HardwareHoleElementUtil {
    }
}
declare module "sk/data/scheme/drawing/config/DrawingConfigItemBase" {
    export function DrawingConfigItem(name: string): (clazzType: Function) => any;
    export class DrawingConfigItemBase {
        name: string;
        value: {
            name: string;
            value: any;
        };
        options: {
            [key: string]: any;
        };
        constructor();
        defultValue(): {
            name: string;
            value: any;
        };
        initOptions(): void;
    }
}
declare module "sk/data/scheme/drawing/config/DrawingConfig" {
    import { DrawingConfigItemBase } from "sk/data/scheme/drawing/config/DrawingConfigItemBase";
    export class DrawingConfig {
        static items: {
            [key: string]: Function;
        };
        static defultConfigs: {
            [key: string]: DrawingConfigItemBase;
        };
        configs: {
            [key: string]: DrawingConfigItemBase;
        };
        constructor();
        reInit(): void;
        setValue(name: string, value: {
            name: string;
            value: any;
        }): boolean;
        getValue(name: string): {
            name: string;
            value: any;
        };
        getValueOnly(name: string): any;
    }
}
declare module "sk/data/scheme/drawing/config/DrawingConfigTextStyle" {
    import { DrawingConfigItemBase } from "sk/data/scheme/drawing/config/DrawingConfigItemBase";
    export class DrawingConfigTextStyle extends DrawingConfigItemBase {
        defultValue(): {
            name: string;
            value: any;
        };
        initOptions(): void;
    }
}
declare module "sk/data/scheme/drawing/constants/DrawingNodeConfigTypeEnum" {
    export enum DrawingNodeConfigTypeEnum {
        Class = 0,
        LogicCode = 1,
        FamilyType = 2
    }
}
declare module "sk/data/scheme/drawing/config/DrawingNodeConfig" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DrawingNodeConfigTypeEnum } from "sk/data/scheme/drawing/constants/DrawingNodeConfigTypeEnum";
    export interface MergeConfig {
        name: string;
        drawingName: string;
        code: string;
        sizes: string[];
        nameTypes: string[];
        convertCad?: boolean;
    }
    export class DrawingNodeConfig {
        name: string;
        code: string;
        type: DrawingNodeConfigTypeEnum;
        itemCodes: Types<string>;
        clazz: Function;
        parentClazz?: Function;
        mergeCd?: boolean;
        mergeDownCd?: boolean;
        mergeConfig?: MergeConfig;
        constructor();
        init(name: string, code: string, type: DrawingNodeConfigTypeEnum, itemCodes: Array<string>, clazz: Function, parentClazz?: Function, mergeCd?: boolean, mergeDownCd?: boolean, mergeConfig?: MergeConfig): void;
    }
}
declare module "sk/data/scheme/drawing/config/DrawingNodeConfigItem" {
    export class DrawingNodeConfigItem {
        name: string;
        drawingName: string;
        code: string;
        processCode: string;
        sizeConfig: string;
        defaultSize: string;
        parameter?: any;
        splitCd?: string;
        filterCd?: string;
        convertCad?: boolean;
        mergeCd?: boolean;
        constructor();
        init(name: string, drawingName: string, code: string, processCode: string, nameTypes: Array<string>, sizes: Array<string>, mergeCd: boolean, convertCad?: boolean): void;
        private formatName;
        private parseSizes;
    }
}
declare module "sk/data/scheme/drawing/constants/DrawingProcessCode" {
    export enum DrawingProcessCode {
        Structure = "structure",
        RoomSmallBox = "room.smallbox",
        RoomFloorMapping = "room.floor.mapping",
        FloorplanSmallBox = "floorplan.smallbox",
        FloorplanNoInstance = "floorplan.no.instance",
        FloorplanNoInstanceTop = "floorplan.no.instance.top",
        FloorplanAssembleGround = "floorplan.structure.assemble.ground",
        FloorplanAssembleTop = "floorplan.structure.assemble.top",
        FloorplanFamilyGround = "floorplan.structure.family.ground",
        FloorplanFamilyTop = "floorplan.structure.family.top",
        FloorplanPipelineGround = "floorplan.structure.pipeline.ground",
        FloorplanPipelineTop = "floorplan.structure.pipeline.top",
        FloorplanFlatWallSurvey = "floorplan.flatwall.survey",
        FloorplanSurveyPoints = "floorplan.measure.survey.points",
        LevelingFloorHardware = "leveling.floor.hardware",
        LevelingFloorBase = "leveling.floor.base",
        LevelingCeilingSurvey = "leveling.ceiling.survey",
        LevelingCeilingKeelHanging = "leveling.ceiling.keel.hanging",
        LevelingCeilingKeelLayer = "leveling.ceiling.keel.layer",
        LevelingCeilingKeelLayerCode = "leveling.ceiling.keel.layer.code",
        LevelingCeilingBase = "leveling.ceiling.base",
        LevelingCeilingSurface = "leveling.ceiling.surface",
        LevelingCeilingDecorate = "leveling.ceiling.decorate",
        ProxyCeilingSurvey = "proxy.ceiling.survey",
        ProxyCeilingSurveyCenter = "proxy.ceiling.survey.center",
        ProxyCeilingSurveyBorder = "proxy.ceiling.survey.border",
        ProxyCeilingKeelHanging = "proxy.ceiling.keel.hanging",
        ProxyCeilingKeelLayerCenter = "proxy.ceiling.keel.layer.center",
        ProxyCeilingKeelLayerCenterCode = "proxy.ceiling.keel.layer.center.code",
        ProxyCeilingKeelLayerBorder = "proxy.ceiling.keel.layer.border",
        ProxyCeilingKeelLayerBorderCode = "proxy.ceiling.keel.layer.border.code",
        ProxyCeilingBase = "proxy.ceiling.base",
        ProxyCeilingSurface = "proxy.ceiling.surface",
        ProxyCeilingProfile = "proxy.ceiling.profile",
        PelmetProfile = "pelmet.profile",
        LevelingWallSurvey = "leveling.wall.survey",
        LevelingWallSurveyNew = "leveling.wall.survey.new",
        LevelingWallContainer = "leveling.wall.container",
        LevelingWallHardware = "leveling.wall.hardware",
        LevelingWallBase = "leveling.wall.base",
        LevelingWallBaseWithPlankSize = "leveling.wall.basewithplanksize",
        LevelingWallSurface = "leveling.wall.surface",
        LevelingWallSurfaceWithPlankSize = "leveling.wall.surfacewithplanksize",
        LevelingWallDecorate = "leveling.wall.decorate",
        LevelingWindowProfile = "leveling.window.profile",
        AssembledBeamSection = "assembled.beam.section",
        FlatWallSurvey = "flat.wall.survey",
        FlatWallBase = "flat.wall.base",
        FlatWallInnerBase = "flat.wall.inner.base",
        FlatWallOuterBase = "flat.wall.outer.base",
        FlatWallInnerSurface = "flat.wall.inner.surface",
        FlatWallOuterSurface = "flat.wall.outer.surface",
        FlatWallInnerDecorate = "flat.wall.inner.decorate",
        FlatWallOuterDecorate = "flat.wall.outer.decorate",
        FlatWallKeel = "flat.wall.keel",
        FlatWallKeelInner = "flat.wall.keel.inner",
        FlatWallKeelOuter = "flat.wall.keel.outer",
        UnitBathroomFloorPlank = "unit.bathroom.floor.plank",
        UnitBathroomFloorTile = "unit.bathroom.floor.tile",
        UnitBathroomFloor = "unit.bathroom.floor",
        UnitBathroomFloorSupport = "unit.bathroom.floor.support",
        UnitBathroomFloorPlankOutline = "unit.bathroom.floor.plank.outline",
        UnitBathroomFloorPlankLine = "unit.bathroom.floor.plank.line",
        UnitBathroomFloorPlankFold = "unit.bathroom.floor.plank.fold",
        UnitBathroomFloorFinish = "unit.bathroom.floor.finish",
        UnitBathroomFloorKeel = "unit.bathroom.floor.keel",
        UnitBathroomFloorMapping = "unit.bathroom.floor.mapping",
        UnitBathroomWallPlank = "unit.bathroom.wall.plank",
        UnitBathroomWallSurfacePlank = "unit.bathroom.wall.surface.plank",
        UnitBathroomWallSurfaceTile = "unit.bathroom.wall.surface.tile",
        UnitBathroomWallElevation = "unit.bathroom.wall.surface.elevation",
        UnitBathroomFloorLink = "unit.bathroom.floor.link",
        UnitBathroomPlan = "unit.bathroom.plan",
        UnitBathroomCeiling = "unit.bathroom.ceiling",
        ChestStructure = "chest.structure",
        FurnitureTop = "furniture.top",
        FurnitureFront = "furniture.front",
        FurnitureFrontWithoutDoor = "furniture.front.without.door",
        FurnitureRight = "furniture.right",
        FurnitureLeft = "furniture.left",
        FurnitureProjection = "furniture.projection",
        SingleCubeStructure = "single.structure",
        TestDrawing = "test.drawing",
        FloorplanOriginDrawing = "floorplan.origin.drawing",
        FloorplanLevelingWallDrawing = "floorplan.leveling.wall.drawing",
        FloorplanBaseInforDrawing = "floorplan.base.infor.drawing",
        FloorplanDecorateInforDrawing = "floorplan.decorate.infor.drawing",
        LevelingWallElevationLayoutDrawing = "leveling.wall.elevation.layout.drawing",
        UnitBathroomCeilingPlaneLayoutDrawing = "unit.bathroom.ceiling.plane.layout.drawing",
        UnitBathroomCeilingManufactureDrawing = "unit.bathroom.ceiling.plane.manufacture.drawing",
        UnitBathroomOriginFloorplanDrawing = "unit.bathroom.origin.floorplan.drawing",
        UnitBathroomWarePlaneLayoutDrawing = "unit.bathroom.ware.plane.layout.drawing",
        UnitBathroomWallElevationTileLayoutDrawing = "unit.bathroom.wall.elevation.tile.layout.drawing",
        UnitBathroomWallElevationManufactureDrawing = "unit.bathroom.wall.elevation.manufacture.drawing",
        UnitBathroomWallPlaneLayoutDrawing = "unit.bathroom.wall.plane.layout.drawing",
        UnitBathroomFloorPlaneTileLayoutDrawing = "unit.bathroom.floor.plane.tile.layout.drawing",
        UnitBathroomAreaPlaneLayoutDrawing = "unit.bathroom.area.plane.layout.drawing",
        UnitBathroomWallElevationATileLayoutDrawing = "unit.bathroom.wall.elevationa.tile.layout.drawing",
        UnitBathroomWallElevationBTileLayoutDrawing = "unit.bathroom.wall.elevationb.tile.layout.drawing",
        UnitBathroomWallElevationCTileLayoutDrawing = "unit.bathroom.wall.elevationc.tile.layout.drawing",
        UnitBathroomWallElevationDTileLayoutDrawing = "unit.bathroom.wall.elevationd.tile.layout.drawing",
        UnitBathroomWallElevationA1TileLayoutDrawing = "unit.bathroom.wall.elevationa1.tile.layout.drawing",
        UnitBathroomWallElevationB1TileLayoutDrawing = "unit.bathroom.wall.elevationb1.tile.layout.drawing",
        UnitBathroomWallElevationC1TileLayoutDrawing = "unit.bathroom.wall.elevationc1.tile.layout.drawing",
        UnitBathroomWallElevationD1TileLayoutDrawing = "unit.bathroom.wall.elevationd1.tile.layout.drawing",
        UnitBathroomWallElevationA2TileLayoutDrawing = "unit.bathroom.wall.elevationa2.tile.layout.drawing",
        UnitBathroomWallElevationB2TileLayoutDrawing = "unit.bathroom.wall.elevationb2.tile.layout.drawing",
        UnitBathroomWallElevationC2TileLayoutDrawing = "unit.bathroom.wall.elevationc2.tile.layout.drawing",
        UnitBathroomWallElevationD2TileLayoutDrawing = "unit.bathroom.wall.elevationd2.tile.layout.drawing",
        UnitBathroomMergeDrawing = "unit.bathroom.merge.drawing",
        StandardDoorFrontDrawing = "door.face.drawing",
        StandardDoorTopDrawing = "door.side.top.drawing"
    }
}
declare module "sk/data/scheme/drawing/converter/common/CubeDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export type SubGraphicsResult = {
        graphics: BrepNode[];
        dimpoints: Vector2[];
    };
    export type WholeGraphicsResult = {
        graphics: BrepNode[];
        wholeBox: Box2;
        graphicBox: Box2;
        anchors: BrepNode[];
    };
    export class CubeDrawingConverter extends BaseDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, cubenode: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        computeDrawing(context: DrawingNodeContext, cubenode: BrepNode, option?: any): void;
        private createWholeGeos;
        private createNodeMainGraphics;
        private createNodeAnchorGraphic;
        protected computeNodeAnchorCircleSize(node: ContentNode): number;
        protected createNodeSubGraphics(context: DrawingNodeContext, node: BrepNode, matrixp: Matrix4, showidentify: boolean, style?: any, textstyle?: any, drawingLevel?: number, textdrawingLevel?: number): SubGraphicsResult;
        private drawOutlineDims;
        private computeOffset;
        private createWholeBox;
        private createNodeIdentify;
        private getStandardDistance;
        private decideFaceShowIdentify;
        private getPartAllDimpoints;
        protected pointProjection(matrixp: Matrix4, matrixw: Matrix4, point: Vector3): Vector2;
    }
}
declare module "sk/data/scheme/enumeration/SchemeLogicCodeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeLogicCodeEnum extends EnumerationObject {
        static Unknown: string;
        static UnitBathroomCeiling: string;
        static UnitBathroomCeilingPlank: string;
        static UnitBathroomFloor: string;
        static UnitBathroomFloorDry: string;
        static UnitBathroomFloorDryBaseplate: string;
        static UnitBathroomFloorDryTile: string;
        static UnitBathroomFloorDryTileDocker: string;
        static UnitBathroomFloorWet: string;
        static UnitBathroomFloorWetBaseplate: string;
        static UnitBathroomWall: string;
        static LogicAssembledFlatWall: string;
        static LogicAssembledLevelingCeiling: string;
        static LogicAssembledLevelingWall: string;
        static LogicAssembledLevelingFloor: string;
        static LogicAssemledRoom: string;
        static UnitBathroomPlankCommonStandard: string;
        static UnitBathroomPlankOutercorner: string;
        static UnitBathroomWallTile: string;
        static UnitBathroomWallTileDocker: string;
        static LogicAssembledFlatWallPlank: string;
        static LogicAssembledLevelingCeilingPlank: string;
        static LogicAssembledLevelingWallPlank: string;
        static LogicAssembledLevelingFloorPlank: string;
        static LogicAssembledHardwareStructure: string;
        static UnitBathroomFloorDrySupport: string;
        static UnitBathroomPlankScreen: string;
        static UnitBathroomPlankComposite: string;
        static UnitBathroom: string;
        static LogicAssembledDoor: string;
        static LogicAssembledWindow: string;
        static LogicAssembledLevelingBeam: string;
        static LogicAssembledHardwareStructureUshaped: string;
        static LogicAssembledExpansionBolt: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/drawing/constants/DrawingSplitCdEnum" {
    export class DrawingSplitCdEnum {
        static BeamWallSplit: string;
        static FlatWallBaseSplit: string;
        static FlatWallKeelSplit: string;
        static LevelingFloorSplit: string;
        static SingleStructureSplit: string;
        static ProxyCeilingBorderSplit: string;
    }
}
declare module "sk/data/scheme/drawing/data/DrawingNodeData" {
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    export class DrawingNodeData {
        type: string;
        name: string;
        info: ISpecificationFamilyInfo;
    }
}
declare module "sk/data/scheme/enumeration/SchemeWareParameterEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeWareParameterEnum extends EnumerationObject {
        static Unknown: string;
        static RoomElementId: string;
        static WallElementId: string;
        static CowallElementId: string;
        static WallSurfaceElementId: string;
        static CeilingSurfaceElementId: string;
        static FloorSurfaceElementId: string;
        static DoorElementId: string;
        static WindowElementId: string;
        private static _items;
        static get Items(): Array<EnumItem>;
        static CategoryId: string;
    }
}
declare module "sk/data/scheme/drawing/util/DrawingNodeRelationUtil" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { AssembleBeamElement } from "sk/data/scheme/database/pattern/element/AssembleBeamElement";
    import { AssembleDoorElement } from "sk/data/scheme/database/pattern/element/AssembleDoorElement";
    import { AssembleRoomElement } from "sk/data/scheme/database/pattern/element/AssembleRoomElement";
    import { AssembleWindowElement } from "sk/data/scheme/database/pattern/element/AssembleWindowElement";
    import { LevelingCeilingElement } from "sk/data/scheme/database/pattern/element/LevelingCeilingElement";
    import { LevelingFloorElement } from "sk/data/scheme/database/pattern/element/LevelingFloorElement";
    import { LevelingWallElement } from "sk/data/scheme/database/pattern/element/LevelingWallElement";
    import { PelmetElement } from "sk/data/scheme/database/pattern/element/PelmetElement";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { PelmetNode } from "sk/data/scheme/database/pattern/node/PelmetNode";
    export class DrawingNodeRelationUtil {
        static getRoomOfLevelingCeiling(levelingCeiling: LevelingCeilingElement): RoomNode;
        static getRoomOfLevelingWall(levelingWall: LevelingWallElement): RoomNode;
        static getAssembleRoomOfLevelingWall(levelingWall: LevelingWallElement): AssembleRoomElement;
        static getAssembleBeamsOfAssembleRoom(assembleRoom: AssembleRoomElement): AssembleBeamElement[];
        static getRoomOfPelmet(pelmet: PelmetElement): RoomNode;
        static getLevelingWallOfPelmet(pelmet: PelmetElement): LevelingWallNode;
        static getWallSurfaceOfAssembleLevelingWall(levelingWall: LevelingWallElement): WallSurfaceNode;
        static getPelmetOfAssembleLevelWall(levelingWall: LevelingWallElement): PelmetNode;
        static getRoomOfAssembleBeam(assembleBeam: AssembleBeamElement): RoomNode;
        static getRoomOfWindow(window: AssembleWindowElement): RoomNode;
        static getRoomOfDoor(door: AssembleDoorElement): RoomNode;
        static getRoomOfPatternElement(element: PatternInstanceElement): RoomNode;
        static getRoomOfLevelingFloor(levelingFloor: LevelingFloorElement): RoomNode;
        static getRoomOfAssembleRoom(assembleRoom: AssembleRoomElement): RoomNode;
        static getLevelingWallOfAssembleLevelingWall(levelingWall: LevelingWallElement): LevelingWallNode;
        static getLinkOpening(node: DataNode): OpeningNode;
        static getLinkBeam(node: DataNode): BeamNode;
        static findLinkNodeInFloorplan(node: DataNode, code: string, clazz?: Function): DataNode;
        static getRoomBeams(room: RoomNode, refs?: Array<BeamNode>): Array<BeamNode>;
        static getRoomColumns(room: RoomNode, refs?: Array<ColumnNode>): Array<ColumnNode>;
        static getRoomOpenings(room: RoomNode, refs?: Array<OpeningNode>): Array<OpeningNode>;
        static getColumnsByCowall(cowall: CowallNode): Array<ColumnNode>;
        static getColumnsBySurface(surface: WallSurfaceNode): Array<ColumnNode>;
        static findNodeByElementId(nodes: DataNode[], elementId: string): DataNode;
        static findRelationByCode(element: ContentInstanceElement, code: string, optionSlave?: boolean): InstanceElement;
        static findChildrenByLogicCode(parent: DataNode, logicCode: string, recursive?: boolean, target?: Array<FamilyInstanceNode>, recursiveCount?: number): FamilyInstanceNode[];
        static findChildrenByFamilyType(parent: DataNode, code: string, recursive?: boolean, target?: Array<FamilyInstanceNode>, recursiveCount?: number): FamilyInstanceNode[];
        static findChildrenByNameAndType(parent: DataNode, clazz: Function, name: string, recursive?: boolean, recursiveCount?: number, optionLike?: boolean): DataNode[];
        static findChildrenByRecursiveCount(parent: DataNode, clazz: Function, recursive?: boolean, target?: Array<DataNode>, recursiveCount?: number): DataNode[];
        static findChildByRecursiveCount(parent: DataNode, clazz: Function, recursive?: boolean, recursiveCount?: number): DataNode;
        static findContainerByName(node: DataNode, name: string, recursive?: boolean, recursiveCount?: number, isLike?: boolean): DataNode;
        static findChildFamilyInstanceByFamilyType(node: DataNode, code: string, deep?: boolean): FamilyInstanceNode;
        static fetchChildrenByFamilyType(node: DataNode, code: string, deep?: boolean, ref?: Array<FamilyInstanceNode>): Array<FamilyInstanceNode>;
        static findChildByFeature(node: DataNode, code: string, value: string, deep?: boolean): FamilyInstanceNode;
        static fetchChildrenByFeature(node: DataNode, code: string, value: string, deep?: boolean, ref?: Array<FamilyInstanceNode>): Array<FamilyInstanceNode>;
        static findDynamicWareByRoom(room: RoomNode): DynamicWareNode;
        static findRelationId(node: ContentNode, findSlave?: boolean): string;
        static findBindValue(node: DataNode, parameterCode: string): string;
        static findLinkRoom(node: ContentNode): RoomNode;
        static findChildrenDynamicByLogicCode(sourceNode: DynamicWareNode, logicCode: string): Array<DynamicWareNode>;
        static findLinkNode(sourceNode: ContentNode, code: string, clazz: Function): DataNode;
        static findDynamicByRoom(room: RoomNode): DynamicWareNode;
    }
}
declare module "sk/data/scheme/drawing/util/DrawingNodeConfigUtil" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeData } from "sk/data/scheme/drawing/data/DrawingNodeData";
    export class DrawingNodeConfigUtil {
        static getDrawingDataByNode(context: IContext, node: DataNode): DrawingNodeData;
        private static setGroupName;
        static getDrawingName(context: IContext, node: BrepNode, drawingName: string): string;
        private static buildDrawingName;
        static getDrawingFrameTexts(context: IContext, node: DataNode, name: string, drawingTitle: string): Map<string, string>;
        private static getRoomName;
        private static getRoom;
        static getScreenSize(size: string): Vector2;
        static parseCurrentSize(size: string): EnumItem;
        static getSizeConfig(sizes: Array<string>): string;
        static getIntersectionSizeConfigs(sizes: Array<string>): string;
        static parseSizeConfig(sizeConfig: string): Array<EnumItem>;
        static containSize(sizeConfig: string, size: string): boolean;
        static buildDrawingContexts(context: IContext, node: DataNode, splitCd?: string): Array<DrawingNodeContext>;
        static buildContextsByBeamWall(context: IContext, beam: BeamNode, node: DataNode): DrawingNodeContext[];
        static buildContextsByFlatWallKeel(context: IContext, node: DataNode): Array<DrawingNodeContext>;
        static buildContextsByLevelingFloor(context: IContext, node: DataNode): Array<DrawingNodeContext>;
        static buildContextsByFlatWallBase(context: IContext, node: DataNode): Array<DrawingNodeContext>;
        static buildContextsBySingleStructure(context: IContext, node: DataNode): Array<DrawingNodeContext>;
        static buildContextsByProxyCeilingBorder(context: IContext, node: DataNode): Array<DrawingNodeContext>;
        static containDrawingCode(source: string, code: string): boolean;
        static getSvgContentAsync(context: IContext, url: string, random?: boolean): Promise<any>;
        private static getSvgRandomUrl;
    }
}
declare module "sk/data/scheme/drawing/converter/component/FormComponentConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export type FormParam = {
        rowNumber: number;
        rowHeight: number;
        rowHeightArray: Array<number>;
        columnNumber: number;
        columnWidth: number;
        columnWidthArray: Array<number>;
        contents: Array<string>;
        graphicContents: Array<BrepNode[]>;
        position: Vector2;
        textStyle: any;
        formStyle: any;
        formDrawingLevel: number;
    };
    export class FormComponentConverter extends BaseDrawingConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        computeDrawingComponent(node: BrepNode, formparam: FormParam, option?: any): BrepNode[];
        protected drawTextInForm(formParam: FormParam, boxes: Array<Array<Box2>>): BrepNode[];
        protected drawTextInBox(box: Box2, textcontent: string, textstyle?: any): BrepNode;
        protected drawForm(formParam: FormParam, boxes: Array<Array<Box2>>): BrepNode[];
        private createFormSizeArray;
        protected drawCell(startpos: Vector2, width: number, height: number, box?: Box2, style?: any, drawingLevel?: number): BrepNode;
    }
}
declare module "sk/data/scheme/drawing/converter/base/BaseLevelingDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { Fill2dDrawingNode } from 'sk/data/family/model/brep/drawing/Fill2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { AssembleRoomNode } from "sk/data/scheme/database/pattern/node/AssembleRoomNode";
    import { DecorateLayerNode } from "sk/data/scheme/database/pattern/node/DecorateLayerNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { BaseDrawingConverter, WallSurfaceLineAndPath } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export type ComputeNearestPointResult = {
        p: Vector2;
        b: Vector2;
        i: number;
    };
    export enum LevelingDrawingContentEnum {
        wallsCompleteLinesGeos = 0,
        wallCompletePoitns = 1
    }
    export type WallCompleteInfo = {
        completeInnerLine: Line2;
        completePoints: Vector2[];
    };
    export type WallBaseInfo = {
        baseOuterLine: Line2;
        basePoints: Vector2[];
    };
    export class BaseLevelingDrawingConverter extends BaseDrawingConverter {
        protected graphicFormMap: Map<BrepNode[], string>;
        protected keelsMap: Map<string, string>;
        protected formConverter: FormComponentConverter;
        protected _room: RoomNode;
        constructor(domain?: DrawingDomainNode);
        protected wallsFilterInvalid(walls: WallNode[]): WallNode[];
        protected cowallsFilterInvalid(cowalls: CowallNode[]): CowallNode[];
        protected findAssembelRoomByAssembelWall(wallnode: ContentNode): ContentNode;
        protected fetchFloorplanAllWalls(floorplan: FloorplanNode): DataNode[];
        protected isInRoom(room: RoomNode, instance: ContentNode, checkBox?: boolean, includeRoomOutline?: boolean): boolean;
        protected checkPointsInRoomFlatWalls(room: RoomNode, points: Vector2[], includeedge: boolean): boolean;
        protected checkPointsInRoomCowalls(room: RoomNode, points: Vector2[], includeedge: boolean): boolean;
        protected checkPointsInPolygon(points: Vector2[], polygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        protected checkPolygonsIntersection(polygon: Vector2[], otherpolygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        protected checkCurveLinecurve(curve2d: Curve2d, tolerance?: number): boolean;
        protected checksectionSurfaceIntersectSectionSurface(section: SectionSurface, othersection: SectionSurface): boolean;
        protected findRoomContents(room: RoomNode, excludearray?: Array<Function>, onlyincludearray?: Array<Function>): FamilyInstanceNode[];
        protected findAssembledRooms(floorplan: FloorplanNode): ContentNode[];
        protected findAssembledRoomByRoomNode(room: RoomNode): AssembleRoomNode;
        protected getLevelWalls(assembledRoom: ContentNode): ContentNode[];
        protected getMarkPoints(floorNode: BrepNode): ContentNode[];
        protected getLevelBeams(assembledRoom: ContentNode): ContentNode[];
        protected findBeam(node: ContentNode): ContentNode;
        protected drawDynamicRoom(context: DrawingNodeContext, roomdynamicware: ContentNode): void;
        protected findCowallFromDynamicwall(node: DynamicWareNode): CowallNode;
        protected findRoomFromAssembledRoom(node: ContentNode): RoomNode;
        protected computeNodeStartDirection(node: BrepNode): Vector2;
        protected buildFloorplanDimensions(node: BrepNode, style?: any): void;
        protected computeAssemledBoundary(node: BrepNode, box?: Box2): Box2;
        protected createBeamsInfos(instances: FamilyInstanceNode[], pos?: Vector2, textHeight?: number): void;
        protected drawWallsCavityAndDims(walls: DynamicWareNode[], style?: any, drawingLevel?: number): void;
        protected drawWallCavityAndDims(wall: ContentNode, planks: ContentNode[], style?: any, drawingLevel?: number): void;
        protected drawForm(): void;
        private drawTextForm;
        private drawGraphicForm;
        protected drawKeelText(textpos: Vector2, rotationZ: number, keel: ContentInstanceNode, needserialNumber: boolean, needProcessNumber: boolean, keeltypecodedict: Map<string, string>, replacetypecodearray: Array<string>, keepmaptext?: Map<string, string>, style?: any, drawingLevel?: number): BrepNode;
        protected createKeelText(textpos: Vector2, rotationZ: number, keel: ContentInstanceNode, needserialNumber: boolean, needProcessNumber: boolean, keeltypecodedict: Map<string, string>, replacetypecodearray: Array<string>, keepmaptext?: Map<string, string>, style?: any, drawingLevel?: number): BrepNode;
        protected computeKeelMapText(keel: ContentInstanceNode, code: string, textmap: Map<string, string>): void;
        protected computeKeelCode(keel: ContentInstanceNode, typedict: Map<string, string>, replacetypecodearray: Array<string>): string;
        protected drawFlatWall(flatwall: FlatWallNode): BrepNode[];
        protected drawingWallLines(document: DrawingDataDocument, cowalls: CowallNode[], workInstance?: boolean, dimEnable?: boolean, dimBase?: number): void;
        protected checkCeilOrFloorTouchWall(ceil: ContentNode, wall: ContentNode, tolerance?: number): boolean;
        protected checkCurvesIntersection(curves: Curve2d[], othercurves: Curve2d[]): boolean;
        protected drawWallsCompleteLines(context: DrawingNodeContext, walls: ContentNode[], style?: any, drawingLevel?: number): void;
        protected computeDecorateSurfaceInnerLineAndPath(decorateLayer: DecorateLayerNode): WallSurfaceLineAndPath;
        protected computeWallLineAndBox(levelingWall: ContentNode, isOuterLine?: boolean): WallSurfaceLineAndPath;
        protected computeNearestPointInLinecurve(linecurve: LineCurve2d, point: Vector3): Vector3;
        protected computeDynamicWallSurfaceLine(dynamicwall: ContentNode): Line2;
        protected getLinesPoints(lines: Line2[]): Vector2[];
        protected computePlankDirectionTopView(plank: PlankNode): Vector2;
        protected computeWallsZindex(walls: Array<WallNode>, observeMatrix?: Matrix4): number;
        protected drawingRoomCowalls(room: RoomNode, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected drawingCoWalls(document: DrawingDataDocument, cowalls: Array<CowallNode>, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected computeDirectionPolygons(polygons: Vector2[][], positive?: boolean): Vector2[][];
        protected computeDirectionPolygon(points: Vector2[], positive?: boolean): Vector2[];
        protected computePolygonDirection(polygon: Vector2[]): boolean;
        protected getAngleFromVector2s(v1: Vector2, v2: Vector2): number;
        protected drawLineArrow(point1: Vector2, point2: Vector2, style: any, drawingLevel?: number): void;
        protected drawingWalls(document: DrawingDataDocument, walls: Array<WallNode>, fillEnable: boolean, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean): void;
        protected createWallPolygonsWithoutOpening(document: DrawingDataDocument, walls: Array<WallNode> | Array<CowallNode>, wallPoints: Vector2[][], observeMatrix?: Matrix4): PolygonCurve2dDrawingNode[];
        protected createFillsByWall(document: DrawingDataDocument, dpolygons: PolygonCurve2dDrawingNode[], id: string): Fill2dDrawingNode[];
        protected drawFlatWallsAsync(context: DrawingNodeContext, flatwalls: FlatWallNode[], observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwallsoutlines?: Array<Vector2>): Promise<BrepNode[]>;
        protected drawFloorplanFlatWallsText(flatwalls: FlatWallNode[], textHeight?: number, dimBoxs?: Box2[]): void;
        protected flatwallTextOffset(flatwallAndNames: {
            flatwall: FlatWallNode;
            leader: LeaderDrawingNode;
        }[], textHeight?: number, dimBoxs?: Box2[]): void;
        protected computeLeaderTextBox(point: Value2, text: string, textHeight: number): Box2;
        protected offsetFlatWallText(curLeaderAndBox: {
            leader: LeaderDrawingNode;
            box: Box2;
        }, offsetDir: Vector2, offsetStep: number, leaderAndBoxs: {
            leader: LeaderDrawingNode;
            box: Box2;
        }[], boxs: Box2[], textHeight: number, offsetArr?: Vector2[], curOffsetCount?: number, originPoint?: Value2): void;
        protected computeOffsetArr(offsetDir: Value2, offsetCount: number): Array<any>;
        protected drawFlatwallCodeForm(flatwalls: FlatWallNode[]): void;
        protected drawFlatWallAsync(context: DrawingNodeContext, flatwall: FlatWallNode, observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwalloutlines?: Array<Vector2>, cutsurface?: SectionSurface, roomnode?: RoomNode): Promise<BrepNode[]>;
        protected computeFlatwallGeosExcludeDoors(geos: Curve2dNode[], openings: OpeningNode[]): BrepNode[];
        protected computeFlatWallOpenings(flatwall: FlatWallNode): OpeningNode[];
        protected drawFlatWallPlanks(flatwall: FlatWallNode, observeMatrix?: Matrix4, cutsurface?: SectionSurface): BrepNode[];
        protected drawFlatWallCode(flatwall: FlatWallNode, textHeight?: number, cutsurface?: SectionSurface, roomnode?: RoomNode): {
            codeText: BrepNode[];
            nameText: LeaderDrawingNode[];
        };
        protected drawFlatWallCodeText(flatwallnode: FlatWallNode, innerdirection: Vector2, cutsurface?: SectionSurface, roomnode?: RoomNode, textHeight?: number): LeaderDrawingNode[];
        protected drawFlatWallOuterKeelCode(outercontainer: ContainerNode, flatwallinnerdirection: Vector2, cutsurface?: SectionSurface): BrepNode;
        protected drawFlatWallInnerKeelCode(innercontainer: ContainerNode, flatwallinnerdirection: Vector2, cutsurface?: SectionSurface): BrepNode;
        protected drawRoomFlatWallAsync(context: DrawingNodeContext, roomnode: RoomNode, observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, flatwallsoutlines?: Array<Vector2>): Promise<void>;
        protected checkFlatWallOverRoom(flatwall: FlatWallNode, room: RoomNode): boolean;
        protected getRoomFlatWalls(roomnode: RoomNode): FlatWallNode[];
        protected findWallsFromCowalls(cowalls: CowallNode[]): WallNode[];
        protected findNodeFromNodeIdInNodes(id: string, nodes: DataNode[]): DataNode;
        protected findNodeFromElementIdInNodes(id: string, nodes: DataNode[]): DataNode;
        protected isElementIdInNodes(id: string, nodes: DataNode[]): boolean;
        protected drawFloorplanFlatWallAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean, breakbyopening?: boolean): Promise<void>;
        protected drawWallAndLineDistanceDim(line: Line2, dynamicware: ContentNode, dimstyle?: any, drawingLevel?: number): void;
        protected computeOGWallFromAssemblewall(assemblewall: ContentNode): CowallNode[];
        protected computeOGWallNearestInnerLine(cowall: CowallNode, innerline: Line2): Line2;
        protected computeOGWallInnerLine(assembledWall: ContentNode): Line2;
        protected findSurfaceNodeByElementId(floorplannode: FloorplanNode, elementid: string): WallSurfaceNode;
        protected createCompleteDistanceDims(completeline: Line2, distance: number, centerposoffset: number, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[];
        protected getInnerEdgeFromColumnInnerDirection(columnNode: ColumnNode, direction: Vector2): Line2;
        protected findUpAssemledRoom(node: DataNode): ContentNode;
        protected findChildrenAssemledRoom(node: DataNode): BrepNode;
        protected findNodeRelationContent(node: ContentNode, findslave?: boolean): InstanceElement;
        protected findNodeRelationElementId(node: ContentNode, findslave?: boolean): string;
        protected findBindValue(node: ContentNode, parameterCode: string, findslave?: boolean): string;
        protected findRelationElements(node: ContentNode, findslave?: boolean): InstanceElement[];
        protected getCowallById(id: string, cowalls: Types<CowallNode>): CowallNode;
        protected getColumnByAssembelColumnWall(wall: ContentNode): ColumnNode;
        protected getColumnByIdFromCowalls(id: string, cowalls: Types<CowallNode>): ColumnNode;
        protected checkColumn(node: ContentNode): boolean;
        protected computeWallCavityLine(dynamicware: DynamicWareNode, base: WareNode): Line2;
        protected computeWallCompleteLineFromAssembleWall(dynamicWare: ContentNode): Line2;
        protected computeWallInnerDirection(dynamiware: ContentNode): Vector2;
        protected computeWallInnerLine(dynamiware: ContentNode): Line2;
        protected computeWallBaseInfo(dynamicware: ContentNode, base: ContentNode): WallBaseInfo;
        protected computeSurfaceContainerInnerLine(dynamicware: ContentNode, surface: WareNode): Line2;
        protected findChildContainerByName(node: DynamicWareNode, name: string): DataNode;
        protected getRoomWorkPoints(): Types<Vector3>;
        protected getRoomInnerPoints(): Types<Vector3>;
        protected getRoomBeamPoints(): Array<Vector3>;
        protected drawingRoomInstancesAsync(context: DrawingNodeContext, room: RoomNode, openingEnable?: boolean, beamEnable?: boolean, columnEnable?: boolean): Promise<void>;
        protected getBreakOpeningFlagByCode(context: DrawingNodeContext): boolean;
        protected drawingOpenings(document: DrawingDataDocument, room: RoomNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingOpening(document: DrawingDataDocument, opening: OpeningNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingOpeningCode(opening: OpeningNode, matrix?: Matrix4): void;
        protected drawOpeningNodeText(node: ContentNode, startX: number, startY: number, content: string, offset: number): void;
        protected computeVectorsByBoundary(box: BoundaryBox, matrix?: Matrix4): Vector3[];
        textBoxs: Box2[];
        protected isCollision(textBox: Box2): boolean;
        protected getTextOffsetPoint(textStr: string, textHeight: number, originPoint: Vector2, offsetY?: number): Vector2;
        protected textStrIsCollision(textStr: string, textHeight: number, originPoint: Value2): boolean;
        protected getAssembleWallBox(node: ContentNode): Box2;
        protected drawStartPoint(points: Vector2[], borders: Vector2[], path: PathCurve2d, style?: any): void;
        protected computeNearestPoint(points: Vector2[], borders: Vector2[]): ComputeNearestPointResult;
        protected getBeamClipPoints(beam: BeamNode, roomPoints: Vector2[]): Array<Vector2>;
        protected createInstanceInfos(instances: FamilyInstanceNode[], code?: string, textHeight?: number): void;
        protected computeCurve2dNodeCutBySurface(curve2dNode: Curve2dNode, cutsurface: SectionSurface, keepstyleanddrawinglevel?: boolean, includeedge?: boolean): Curve2dNode[];
        protected computeCurve2dNodesCutBySurface(curve2dNodes: Curve2dNode[], cutsurface: SectionSurface, keepstyleanddrawinglevel?: boolean, includeedge?: boolean): Curve2dNode[];
        createNodesProjections(matrixp: Matrix4, nodes: GeometricNode[], style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption): GeometricNode[];
        protected findFlatWallDrawNode(flatwall: FlatWallNode): HardwareNode[];
        protected computeSectionSurfaceByPoints(points: Vector2[]): SectionSurface;
        protected computeLineCurvesFromOrderPoints2d(points: Vector2[]): LineCurve2d[];
    }
}
declare module "sk/data/scheme/drawing/converter/common/SurveyLineContainerDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Text2dDrawingNode } from 'sk/data/family/model/brep/drawing/text2d/Text2dDrawingNode';
    import { ReferenceLineNode } from 'sk/data/family/model/assistant/reference/ReferenceLineNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeValueLineData } from "sk/data/scheme/drawing/data/DrawingNodeValueLineData";
    import { BaseLevelingDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDrawingConverter";
    export class SurveyLineContainerDrawingConverter extends BaseLevelingDrawingConverter {
        protected rotateX: number;
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: ContainerNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: ContainerNode): any;
        protected drawingReferenceLine(document: DrawingDataDocument, node: ContainerNode, matrixp?: Matrix4): void;
        private createPolygons;
        private drawingLines;
        protected getLevelingWallFromContainer(node: ContentNode): ContentNode;
        protected checkBeam(node: ContentNode): boolean;
        protected drawLinkAssembelWallCode(lines: ReferenceLineNode[], assembelWalls: ContentNode[], matrixp?: Matrix4, style?: any, drawingLevel?: number): BrepNode[];
        protected computeLinecurvesBox(lines: LineCurve2d[]): Box2;
        protected drawCodeAtSurfaceAndBorderlinesIntersectionMiddle(surfacenode: WareNode, lines: LineCurve2d[], matrixp: Matrix4, code: string, bordercenter: Vector2, offset: number, style?: any, drawingLevel?: number): Text2dDrawingNode;
        protected computeReferenceLinecurves(referencelines: ReferenceLineNode[], matrixp: Matrix4): LineCurve2d[];
        protected computeWallAndBorderLinesIntersectionWallSurfaceTopView(walls: ContentNode[], lines: ReferenceLineNode[]): ContentNode[];
        protected checkSurfaceNodeAndBorderLinesIntersection(surface: WareNode, lines: ReferenceLineNode[]): boolean;
        protected computeLinesLinesIntersection(lines: Curve2d[], referlines: Curve2d[]): Vector3[];
        protected drawCodeSurfacelineAndBorderlineIntersection(line: LineCurve2d, path: PathCurve2d, code: string, style?: any, drawingLevel?: number): Text2dDrawingNode;
        protected drawLinesFill(lines: LineCurve2d[], style?: any, drawingLevel?: number): void;
        protected buildDimensions(node: ContainerNode, matrixp?: Matrix4): void;
        protected getBorderPointsByRefercenceLines(node: ContentNode, lines: Array<ReferenceLineNode>, matrixp?: Matrix4, getLineValue?: boolean): any;
        protected spliteLineByHVType(linesGroup: Array<ReferenceLineNode>, matrixp?: Matrix4): any;
        protected buildDimensionGroupByReferenceLines(node: ContentNode, linesGroup: Array<Array<ReferenceLineNode>>, level: number, space: number, style: any, remarks?: Array<string>, matrixp?: Matrix4): void;
        protected buildDimensionByReferenceLines(node: ContentNode, lines: Array<ReferenceLineNode>, level: number, space: number, style: any, remark?: string, matrixp?: Matrix4): void;
        protected buildDimensionByReferenceLinesNew(node: ContentNode, lines: Array<ReferenceLineNode>, level: number, space: number, style: any, remark?: string, matrixp?: Matrix4): void;
        protected fetechDrawingCodeStart(lines: Array<ReferenceLineNode>, code: string, refRemarks?: Array<string>): Array<Array<ReferenceLineNode>>;
        protected linesToValueLineDataByNode(lines: Array<ReferenceLineNode>, matrixp?: Matrix4): DrawingNodeValueLineData[];
        private lineToValueLineDataByNode;
        protected linesToPointByNode(node: ContentNode, lines: Array<ReferenceLineNode>, ref?: Array<Vector2>, matrixp?: Matrix4): Array<Vector2>;
        splitReferenceLineByDrawingCodes(node: ContainerNode, targetCodes: string[]): any;
        protected getRemarkByCode(code: string, text?: string): string;
        protected getRemarkByCodes(codes: Array<string>, text?: string): string;
    }
}
declare module "sk/data/scheme/drawing/util/DrawingNodeSvgConverterUtil" {
    export class DrawingNodeSvgConverterUtil {
        private static nscale;
        static setNscale(nscale: number): void;
        static getNscale(): number;
        static nscaleValue(value: number): number;
        static resetData(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { RoomInfo } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { BaseLevelingDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDrawingConverter";
    export type BuildDimResult = {
        topDimLevel: number;
        bottomDimLevel: number;
        leftDimLevel: number;
        rightDimLevel: number;
    };
    export class BaseLevelingDynamicDrawingConverter extends BaseLevelingDrawingConverter {
        protected createTextsByRoomInfos(infos: Array<RoomInfo>, textHeight?: number): Array<TextControlNode>;
        protected reSliceRepeatPoints(points: Vector2[], direction: Vector2): Vector2[];
        protected reSortPointsFromDirection(points: Vector2[], direction: Vector2): Vector2[];
        protected drawWallAndLineDistanceDim(line: Line2, dynamicware: ContentNode, dimstyle?: any, drawingLevel?: number): void;
        protected nodeGetCowalls(node: BrepNode): CowallNode[];
        protected computeFloorplanNodeOutlineBox(node: FloorplanNode): Box2;
        protected computeNodeOutlineBox(node: BrepNode): Box2;
        protected computeNodeOutlinePoints(node: BrepNode): Vector2[];
        protected nodeGetBeams(node: BrepNode): BeamNode[];
        protected nodeGetColumns(node: BrepNode): ColumnNode[];
        protected computeContentsDimPoints(contents: ContentNode[]): Vector2[];
        protected computeContentsTopDimLines(contents: ContentNode[]): Line2[];
        protected computeContentDimPoints(content: ContentNode): Vector2[];
        protected computeContentTopDimLines(content: ContentNode): Line2[];
        protected findFloorRoomNodeContentsWithoutOpenings(node: BrepNode, excludearray?: Array<Function>, onlyincludearray?: Array<Function>): Array<ContentNode>;
        protected buildFloorRoomNodeDimensionsAll(node: BrepNode, dimsdistance: number, style?: any, includeContents?: boolean, wallbreakbyOpenings?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, firstdimdistance?: number, drawingLevel?: number): void;
        protected buildFloorRoomNodeDimensionsAllNew201030(node: BrepNode, dimsdistance: number, style?: any, includeContents?: boolean, wallbreakbyOpenings?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, firstdimdistance?: number, drawingLevel?: number): void;
        protected computeContentsTopOutlineBoundary(node: BrepNode, includeContents: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>): Box2;
        protected computeDynamicStyle(style: any, codes: string[], defaultvalues: number[]): any;
        protected computeBoundaryArea(boundary: Box2): number;
        protected createFlatWallsOutlineDimLines(node: BrepNode, wallbreakbyOpenings?: boolean): Line2[];
        protected createFlatWallOutlineDimLines(flatwall: FlatWallNode, wallbreakbyOpenings?: boolean, cutsurface?: SectionSurface): Line2[];
        protected convertLineCurves2Line2s(linecurves: LineCurve2d[]): Line2[];
        protected buildFloorRoomNodeDimensions(node: BrepNode, boundary: Box2, dimsdistance: number, firstdimdistance?: number, wallbreakbyOpenings?: boolean, includeOutlineDim?: boolean, includeContents?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, style?: any, drawingLevel?: number): BuildDimResult;
        protected sortRooms(node: FloorplanNode): RoomNode[];
        protected getLinesStartEnd(line: Line2[]): Array<Vector2>;
        protected fetchRoomSingleCowall(room: RoomNode): any[];
        getValidSurface(cowall: CowallNode): WallSurfaceNode;
        protected buildFloorRoomNodeDimensionsNew201030(node: BrepNode, boundary: Box2, dimsdistance: number, firstdimdistance?: number, wallbreakbyOpenings?: boolean, includeOutlineDim?: boolean, includeContents?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, style?: any, drawingLevel?: number): BuildDimResult;
        protected createNodesOutlineDimLines(nodes: FamilyInstanceNode[]): Line2[];
        protected createNodeOutlineDimLines(node: FamilyInstanceNode): Line2[];
        protected sortLinesByLength(lines: Line2[]): void;
        protected computeCowallsOutlineBoundary(cowalls: CowallNode[]): Box2;
        protected buildDimensionsFromLinesNew(lines: Line2[], dimpointssortdirection: Vector2, dimsdistance: number, firstdimdistance?: number, firstborderpoint?: Vector2, lastborderpoint?: Vector2, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[][];
        protected buildDimensionsFromLinesNew201030(lines: Line2[], dimpointssortdirection: Vector2, dimsdistance: number, firstdimdistance?: number, firstborderpoint?: Vector2, lastborderpoint?: Vector2, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[][];
        protected computeDimPointsFromLinesAndBorder(lines: Line2[], pointssortdirection: Vector2, firstborderpoint?: Vector2, lastborderpoint?: Vector2): Vector2[];
        protected combineLinesNew(lines: Line2[]): Line2[][];
        protected checkLineLinesIntersection(line: Line2, lines: Line2[]): boolean;
        linesIntersection(line1: Line2, line2: Line2): boolean;
        isPointOnLine(point: Vector2, line: Line2, includeLineEndpoint?: boolean, tolerance?: number): boolean;
        protected createCowallsOutlineDimLines(cowalls: CowallNode[], wallbreakbyOpenings?: boolean): Line2[];
        protected createGroupCowallOutlineDimLines(groupcowalls: CowallNode[], includeopenings?: boolean): Line2[];
        protected computeRelinkLines(lines: Line2[]): Line2;
        protected reLinkLines(lines: Line2[]): Line2;
        protected createOutlineDimLinesFromPoints(innerfrom: Vector2, innerto: Vector2, outerfrom: Vector2, outerto: Vector2, outlinebreakpoints?: any[]): Line2[];
        protected breakLinesByPoints(breakpoints: Vector2[], line: Line2): Line2[];
        protected createSingleCowallOutlineDimLinesNew201030(cowall: CowallNode, wallbreakbyOpenings?: boolean): Line2[];
        protected createSingleCowallOutlineDimLines(cowall: CowallNode, wallbreakbyOpenings?: boolean): Line2[];
        protected computeSingleCowallRoomInfo(cowall: CowallNode): any;
        protected computeSingleCowallRoomInfoNew201030(cowall: CowallNode): any;
        protected computeCowallInnerOuterLineFromSingleCowall(cowallroominfo: any, singlecowallroominfo: any, istojoiner?: boolean): any;
        protected lineCut(line: Line2, cutpoint: Vector2, cutdirection: Vector2, cutend?: boolean): Line2;
        protected needCutDimCowall(cowall: CowallNode): boolean;
        protected checkCutDimCowall(joiner: WallJoinnerNode, cowall: CowallNode): boolean;
        protected getCutCowall(joiner: WallJoinnerNode, cowall: CowallNode): CowallNode;
        protected computeCowallLineFromJoiner2OtherJoiner(joiner: WallJoinnerNode, cowall: CowallNode): Line2;
        protected computeJoiner2OtherJoinerLine(joiner: WallJoinnerNode, otherjoiner: WallJoinnerNode): Line2;
        protected getOtherJoiner(joiner: WallJoinnerNode, cowall: CowallNode): WallJoinnerNode;
        protected checkCowallOrPartnerIsCowall(cowall: CowallNode, id: string): boolean;
        protected checkSingleCowall(cowall: CowallNode): boolean;
        protected getOpeningDimPoints(opening: OpeningNode): Vector2[];
        protected findColumns(node: FloorplanNode): DataNode[];
        protected buildFloorplanDimensions(node: BrepNode, style?: any): void;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected afterCompute(context: IContext): void;
        protected preCompute(context: IContext, node: BrepNode): void;
        protected prepareDynamicData(context: IContext, node: BrepNode): void;
        protected getStandardBoundary(): Box2;
        protected getStandardDomainBoundary(): Box2;
        protected computeStandardScale(): number;
        protected computeNscale(node: BrepNode): number;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected dynamicAdjustBoundary(): void;
        protected reSetFontSize(nscale: number): void;
        protected linesSplitBorder(boundary: Box2, lines: Line2[], center?: Vector2): Line2[][];
        protected removeRepeatLines(lines: Line2[]): Line2[];
        protected removeInvalidLines(lines: Line2[]): Line2[];
    }
}
declare module "sk/data/scheme/drawing/converter/floorplan/FloorplanNoInstanceDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BaseboardNode } from "sk/data/scheme/database/floorplan/model/BaseboardNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    type WallInfo = {
        x: number;
        y: number;
        name: string;
        angle: number;
    };
    export class FloorplanNoInstanceDrawingConverter extends BaseLevelingDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: FloorplanNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingDetailAsync(context: DrawingNodeContext, floorplan: FloorplanNode): Promise<void>;
        private computeDrawingAsync;
        protected buildFloorPlanDimensionsByViewType(node: FloorplanNode, dimsdistance: number, viewtype: DrawingViewTypeEnum, style?: any, firstdimdistance?: number, drawingLevel?: number): void;
        protected getFamilyInstancesByViewType(viewtype: DrawingViewTypeEnum, floorplan: FloorplanNode): FamilyInstanceNode[];
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawWallSurfaceCode(assemblyroom: ContentNode): void;
        protected drawBaseboardLine(floorplan: FloorplanNode): BrepNode[];
        protected findBaseboards(floorplan: FloorplanNode): DataNode[];
        protected drawBaseboards(baseboards: BaseboardNode[]): BrepNode[];
        protected drawBaseboard(baseboard: BaseboardNode): BrepNode[];
        protected getWallIdentifier(cowall: CowallNode): number;
        protected getWallInfos(cowalls: CowallNode[]): Array<WallInfo>;
        protected drawDynamicWallCode(wall: ContentNode, distance: number, code: string, style?: any, drawingLevel?: number): void;
        private drawWallCode;
        protected createTextsByWallInfos(infos: Array<WallInfo>): Array<TextControlNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/linear/LinearDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class LinearDrawingConverter extends BaseDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: LinearNode): ResultObject<DrawingDataDocument>;
        private computeDrawing;
        parse2Graphics(linearNode: LinearNode): Array<BrepNode>;
        private createDimensionOutlineLength;
        private arrange;
        private computeSectionOffset;
        private computeCurvesOffset;
        private computeBoundaryOfCurveNodes;
        private createSectionCurvesNodes;
        private createCurveDimension;
        private createPointsCoordsDimensions;
        private projectBToA;
        private setStyle;
        private computeLevelObject;
        private computeLevelByLength;
        private createDebugPoints;
    }
}
declare module "sk/data/scheme/drawing/converter/plank/PlankDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { ComplexHoleSurface } from 'foundation/runtime/geometry/surface/ComplexHoleSurface';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DimensionNode } from 'sk/data/family/model/assistant/dimension/DimensionNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { IpdPlank } from "sk/data/scheme/database/ipddata/ipd/entity/IpdPlank";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class PlankDrawingConverter extends BaseDrawingConverter {
        private directionAccuracy;
        private graphicsModel;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: PlankNode): Promise<ResultObject<DrawingDataDocument>>;
        computeDrawingAsync(context: DrawingNodeContext, plank: PlankNode): Promise<void>;
        parse2Graphics(plank: PlankNode): Array<BrepNode>;
        static createSectionDimension(document: DrawingDataDocument, section: SectionSurface, dis: number, projects: Array<Curve2d>, radius: Array<number>, dimCurves: Array<Curve2d>, boundary: SectionSurface): Array<DimensionNode>;
        static createHoleDimension(document: DrawingDataDocument, surface: ComplexHoleSurface, dis: number, projects: Array<Curve2d>, radius: Array<number>, dimCurves: Array<Curve2d>, boundary: SectionSurface): Array<DimensionNode>;
        static closestDimension(begin: Vector3, outLine: SectionSurface, axis: Vector3, dLine: LineCurve2d): number;
        static avoidCoincideDimension(dLine: LineCurve2d, section: SectionSurface, projects: Array<Curve2d>, dimCurves: Array<Curve2d>, dis: number): LineCurve2d;
        static avoidInterDimension(dLine: LineCurve2d, projects: Array<Curve2d>, dimCurves: Array<Curve2d>, dis: number): LineCurve2d;
        static isRepeatDim(dLine: Curve2d, dimCurves: Array<Curve2d>): boolean;
        static createCurveDimension(document: DrawingDataDocument, dim: Curve2d, curve: Curve2d, radius: Array<number>, result: Array<DimensionNode>): void;
        parseNodeAsync(context: DrawingNodeContext, plank: PlankNode): Promise<IpdPlank>;
        private getPlankType;
        private createPlank;
        private makePlankProcessInfo;
        private convertMilling;
        private convertGrooves;
        private convertHole;
        private getHoleAngle;
        private getDirction;
        private isCloseDirection;
        private isClose;
        private getHoleSide;
        private getGrooveSide;
        private moveLeftHalf;
        reset(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/room/RoomDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    type WallInfo = {
        x: number;
        y: number;
        name: string;
        angle: number;
    };
    export class RoomDrawingConverter extends BaseLevelingDynamicDrawingConverter {
        processAsync(context: DrawingNodeContext, node: RoomNode): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        private drawingWallCodes;
        protected getWallIdentifier(wall: WallNode): string;
        protected getWallInfos(walls: WallNode[]): Array<WallInfo>;
        protected createTextsByWallInfos(infos: Array<WallInfo>): Array<TextControlNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/wall/CowallDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class CowallDrawingConverter extends BaseDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: BrepNode): ResultObject<DrawingDataDocument>;
        private computeDrawing;
        private drawingCowall;
        protected drawingDimensions(dimensionPoints: Types<Vector3>, distance: number, color?: string): void;
        private computeBox;
        private drawingOpenings;
        private drawingOpening;
        private drawingCowallBound;
        private buildMatrix;
    }
}
declare module "sk/data/scheme/drawing/declare/DrawingNodeStructureConverterConfigDeclare" {
    import { DrawingNodeConverterRegisterOption } from "sk/data/scheme/drawing/register/converter/DrawingNodeStructureConverterRegister";
    export function DrawingNodeStructureConverterConfigDeclare(nodeClazz: Function, converterClazz: Function, option?: DrawingNodeConverterRegisterOption): (target: any) => void;
}
declare module "sk/data/scheme/drawing/service/DrawingNodeConverterService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeConverterConfig } from "sk/data/scheme/drawing/config/DrawingNodeConverterConfig";
    import { DrawingNodeStructureConverterConfig } from "sk/data/scheme/drawing/config/DrawingNodeStructureConverterConfig";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    export class DrawingNodeConverterService extends Service {
        protected _configs: TypeMap<string, DrawingNodeConverterConfig>;
        protected _structureConfigs: TypeMap<string, DrawingNodeStructureConverterConfig[]>;
        private getConfigByCode;
        private getConfigByNode;
        registerConfigByCode(code: string, config: DrawingNodeConverterConfig): void;
        registerConfigsByType(clazz: Function, config: DrawingNodeStructureConverterConfig): void;
        processAsync(context: DrawingNodeContext, processCode: string, node: BrepNode, domain: DrawingDomainNode): Promise<ResultObject<DrawingDataDocument>>;
        processByCodeAsync(context: DrawingNodeContext, processCode: string, node: BrepNode, domain: DrawingDomainNode): Promise<ResultObject<DrawingDataDocument>>;
        processByNodeAsync(context: DrawingNodeContext, processCode: string, node: BrepNode, domain: DrawingDomainNode): Promise<ResultObject<DrawingDataDocument>>;
        private processCommonAsync;
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeStructureConverterRegister" {
    import { DrawingNodeConverterOption } from "sk/data/scheme/drawing/config/DrawingNodeConverterConfig";
    import { DrawingNodeConverterConfigOption } from "sk/data/scheme/drawing/config/DrawingNodeStructureConverterConfig";
    export class DrawingNodeStructureConverterRegister {
        setup(clazz: Function, converterClazz: Function, option: DrawingNodeConverterRegisterOption): void;
    }
    export type DrawingNodeConverterRegisterOption = {
        configOption?: DrawingNodeConverterConfigOption;
        drawingOption?: DrawingNodeConverterOption;
    };
}
declare module "sk/data/scheme/drawing/config/DrawingNodeStructureConverterConfig" {
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { DrawingNodeConverterRegisterOption } from "sk/data/scheme/drawing/register/converter/DrawingNodeStructureConverterRegister";
    export class DrawingNodeStructureConverterConfig {
        clazz: Function;
        processCode: string;
        converter: BaseDrawingConverter;
        option?: DrawingNodeConverterRegisterOption;
        init(clazz: Function, converterClazz: Function, option: DrawingNodeConverterRegisterOption): void;
    }
    export type DrawingNodeConverterConfigOption = {
        optionDefault?: boolean;
        drawingCode?: string;
    };
}
declare module "sk/data/scheme/drawing/constants/DrawingFilterCdEnum" {
    export class DrawingFilterCdEnum {
        static FlatWallFilter: string;
    }
}
declare module "sk/data/scheme/drawing/constants/DrawingGeneratorEnum" {
    export class DrawingGeneratorEnum {
        static readonly svg: string;
        static readonly cad: string;
    }
}
declare module "sk/data/scheme/drawing/constants/DrawingNodeConfigCode" {
    export enum DrawingNodeConfigCode {
        Floorplan = "floorplan.node.drawing.list",
        Room = "room.node.drawing.list",
        FlatWall = "flat.wall.drawing.list",
        LevelingWall = "leveling.wall.node.drawing.list",
        LevelingFloor = "leveling.floor.node.drawing.list",
        LevelingCeiling = "leveling.ceiling.node.drawing.list",
        ProxyCeiling = "proxy.ceiling.node.drawing.list",
        LevelingBeam = "leveling.beam.node.drawing.list",
        Pelmet = "pelmet.drawing.list",
        AssembleWindow = "leveling.window.node.drawing.list",
        AssembleDoor = "leveling.door.node.drawing.list",
        AssembleBeam = "leveling.beam.container.drawing.list",
        Bathroom = "bathroom.drawing.list",
        BathroomWall = "bathroom.wall.drawing.list",
        BathroomClosestool = "bathroom.closestool.drawing.list",
        BathroomShowerCurtain = "bath.room.shower.curtain.drawing.list",
        BathroomHeater = "bathroom.heater.drawing.list",
        BathroomCupboard = "bathroom.cupboard.drawing.list",
        BathroomFloorWet = "bathroom.floor.wet.drawing.list",
        BathroomFloorDry = "bathroom.floor.dry.drawing.list",
        BathroomCeiling = "bathroom.ceiling.drawing.list",
        BathroomFloorDryPlank = "bathroom.floor.dry.plank.drawing.list",
        Chest = "chest.drawing.list",
        Furniture = "furniture.drawing.list",
        FurnitureCountertop = "furniture.counter.top.drawing.list",
        StandardDoor = "standard.door.drawing.list"
    }
}
declare module "sk/data/scheme/drawing/constants/DrawingNodeConfigItemCode" {
    export enum DrawingNodeConfigItemCode {
        Structure = "structure",
        FloorplanStructure = "floorplan.structure",
        FloorplanSmallBox = "floorplan.smallbox",
        FloorplanNoInstance = "floorplan.no.instance",
        FloorplanNoInstanceTop = "floorplan.no.instance.top",
        FloorplanAssembleGround = "floorplan.structure.assemble.ground",
        FloorplanAssembleTop = "floorplan.structure.assemble.top",
        FloorplanFamilyGround = "floorplan.structure.family.ground",
        FloorplanFamilyTop = "floorplan.structure.family.top",
        FloorplanPipelineGround = "floorplan.structure.pipeline.ground",
        FloorplanPipelineTop = "floorplan.structure.pipeline.top",
        FloorplanFlatWallSurvey = "floorplan.flat.wall.survey",
        FloorplanSurveyPoints = "floorplan.measure.survey.points",
        RoomStructure = "room.structure",
        RoomFloorMapping = "room.floor.mapping",
        RoomSmallBox = "room.smallbox",
        LevelingBeamStructure = "leveling.beam.structure",
        LevelingBeamSurvey = "leveling.beam.survey",
        LevelingBeamContainer = "leveling.beam.container",
        LevelingBeamHardware = "leveling.beam.hardware",
        LevelingBeamBase = "leveling.beam.base",
        LevelingBeamBaseWithPlankSize = "leveling.beam.base.with.plank.size",
        LevelingBeamSurface = "leveling.beam.surface",
        LevelingBeamSurfaceWithPlankSize = "leveling.beam.surface.with.plank.size",
        LevelingBeamDecorate = "leveling.beam.decorate",
        LevelingOpeningStructure = "leveling.opening.structure",
        LevelingOpeningSurvey = "leveling.opening.survey",
        LevelingOpeningContainer = "leveling.opening.container",
        LevelingOpeningHardware = "leveling.opening.hardware",
        LevelingOpeningBase = "leveling.opening.base",
        LevelingOpeningSurface = "leveling.opening.surface",
        LevelingOpeningBaseWithPlankSize = "leveling.opening.base.with.plank.size",
        LevelingOpeningSurfaceWithPlankSize = "leveling.opening.surface.with.plank.size",
        LevelingOpeningDecorate = "leveling.opening.decorate",
        LevelingFloorStructure = "leveling.floor.structure",
        LevelingFloorHardware = "leveling.floor.hardware",
        LevelingFloorBase = "leveling.floor.base",
        LevelingCeilingSurvey = "leveling.ceiling.survey",
        LevelingCeilingKeelHanging = "leveling.ceiling.keel.hanging",
        LevelingCeilingKeelLayer = "leveling.ceiling.keel.layer",
        LevelingCeilingKeelLayerCode = "leveling.ceiling.keel.layer.code",
        LevelingCeilingBase = "leveling.ceiling.base",
        LevelingCeilingSurface = "leveling.ceiling.surface",
        LevelingCeilingDecorate = "leveling.ceiling.decorate",
        PelmetProfile = "pelmet.profile",
        LevelingWallStructure = "leveling.wall.structure",
        LevelingWallSurvey = "leveling.wall.survey",
        LevelingWallSurveyNew = "leveling.wall.survey.new",
        LevelingWallContainer = "leveling.wall.container",
        LevelingWallHardware = "leveling.wall.hardware",
        LevelingWallBase = "leveling.wall.base",
        LevelingWallBaseWithPlankSize = "leveling.wall.base.with.plank.size",
        LevelingWallSurface = "leveling.wall.surface",
        LevelingWallSurfaceWithPlankSize = "leveling.wall.surface.with.plank.size",
        LevelingWallDecorate = "leveling.wall.decorate",
        LevelingWindowProfile = "leveling.window.profile",
        AssembledBeamSection = "assembled.beam.section",
        FlatWallSurvey = "flat.wall.survey",
        FlatWallBase = "flat.wall.base",
        FlatWallInnerBase = "flat.wall.inner.base",
        FlatWallOuterBase = "flat.wall.outer.base",
        FlatWallInnerSurface = "flat.wall.inner.surface",
        FlatWallOuterSurface = "flat.wall.outer.surface",
        FlatWallInnerDecorate = "flat.wall.inner.decorate",
        FlatWallOuterDecorate = "flat.wall.outer.decorate",
        FlatWallKeel = "flat.wall.keel",
        FlatWallKeelInner = "flat.wall.keel.inner",
        FlatWallKeelOuter = "flat.wall.keel.outer",
        ProxyCeilingSurvey = "proxy.ceiling.survey",
        ProxyCeilingSurveyCenter = "proxy.ceiling.survey.center",
        ProxyCeilingSurveyBorder = "proxy.ceiling.survey.border",
        ProxyCeilingKeelHanging = "proxy.ceiling.keel.hanging",
        ProxyCeilingKeelLayerCenter = "proxy.ceiling.keel.layer.center",
        ProxyCeilingKeelLayerCenterCode = "proxy.ceiling.keel.layer.center.code",
        ProxyCeilingKeelLayerBorder = "proxy.ceiling.keel.layer.border",
        ProxyCeilingKeelLayerBorderCode = "proxy.ceiling.keel.layer.border.code",
        ProxyCeilingBase = "proxy.ceiling.base",
        ProxyCeilingSurface = "proxy.ceiling.surface",
        ProxyCeilingProfile = "proxy.ceiling.profile",
        FurnitureStructure = "furniture.structure",
        FurnitureTop = "furniture.top",
        FurnitureFront = "furniture.front",
        FurnitureFrontWithoutDoor = "furniture.front.without.door",
        FurnitureRight = "furniture.right",
        FurnitureLeft = "furniture.left",
        FurnitureProjection = "furniture.projection",
        SingleCubeStructure = "single.structure",
        FurnitureCountertopStructure = "furniture.countertop.structure",
        FurnitureCountertopTop = "furniture.countertop.top",
        FurnitureCountertopFront = "furniture.countertop.front",
        FurnitureCountertopRight = "furniture.countertop.right",
        FurnitureCountertopLeft = "furniture.countertop.left",
        FurnitureCountertopProjection = "furniture.countertop.projection",
        TestDrawing = "test.drawing",
        FloorplanOriginDrawing = "floorplan.origin.drawing",
        FloorplanLevelingWallDrawing = "floorplan.leveling.wall.drawing",
        FloorplanBaseInforDrawing = "floorplan.base.infor.drawing",
        FloorplanDecorateInforDrawing = "floorplan.decorate.infor.drawing",
        LevelingWallElevationLayoutDrawing = "leveling.wall.elevation.layout.drawing",
        UnitBathroomCeilingPlaneLayoutDrawing = "unit.bathroom.ceiling.plane.layout.drawing",
        UnitBathroomOriginFloorplanDrawing = "unit.bathroom.origin.floorplan.drawing",
        UnitBathroomWarePlaneLayoutDrawing = "unit.bathroom.ware.plane.layout.drawing",
        UnitBathroomWallElevationTileLayoutDrawing = "unit.bathroom.wall.elevation.tile.layout.drawing",
        UnitBathroomWallPlaneLayoutDrawing = "unit.bathroom.wall.plane.layout.drawing",
        UnitBathroomFloorPlaneTileLayoutDrawing = "unit.bathroom.floor.plane.tile.layout.drawing",
        UnitBathroomAreaPlaneLayoutDrawing = "unit.bathroom.area.plane.layout.drawing",
        UnitBathroomWallElevationATileLayoutDrawing = "unit.bathroom.wall.elevationa.tile.layout.drawing",
        UnitBathroomWallElevationBTileLayoutDrawing = "unit.bathroom.wall.elevationb.tile.layout.drawing",
        UnitBathroomWallElevationCTileLayoutDrawing = "unit.bathroom.wall.elevationc.tile.layout.drawing",
        UnitBathroomWallElevationDTileLayoutDrawing = "unit.bathroom.wall.elevationd.tile.layout.drawing",
        UnitBathroomWallElevationA1TileLayoutDrawing = "unit.bathroom.wall.elevationa1.tile.layout.drawing",
        UnitBathroomWallElevationB1TileLayoutDrawing = "unit.bathroom.wall.elevationb1.tile.layout.drawing",
        UnitBathroomWallElevationC1TileLayoutDrawing = "unit.bathroom.wall.elevationc1.tile.layout.drawing",
        UnitBathroomWallElevationD1TileLayoutDrawing = "unit.bathroom.wall.elevationd1.tile.layout.drawing",
        UnitBathroomWallElevationA2TileLayoutDrawing = "unit.bathroom.wall.elevationa2.tile.layout.drawing",
        UnitBathroomWallElevationB2TileLayoutDrawing = "unit.bathroom.wall.elevationb2.tile.layout.drawing",
        UnitBathroomWallElevationC2TileLayoutDrawing = "unit.bathroom.wall.elevationc2.tile.layout.drawing",
        UnitBathroomWallElevationD2TileLayoutDrawing = "unit.bathroom.wall.elevationd2.tile.layout.drawing",
        UnitBathroomMergeDrawing = "unit.bathroom.merge.drawing",
        StandardDoorFrontDrawing = "door.face.drawing",
        StandardDoorTopDrawing = "door.side.top.drawing"
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { LevelingCeilingNode } from "sk/data/scheme/database/pattern/node/LevelingCeilingNode";
    import { PelmetNode } from "sk/data/scheme/database/pattern/node/PelmetNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDrawingConverter";
    export enum LevelingCeilDrawingContentEnum {
        PelmetKeelOutlinePoints = 0
    }
    export class LevelingCeilingDrawingConverter extends BaseLevelingDrawingConverter {
        protected drawWorkDim: boolean;
        constructor(domain?: DrawingDomainNode);
        protected canConvertByName(node: BrepNode, name: string): boolean;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        protected getRoomCelings(context: IContext, room: RoomNode): ContentNode[];
        protected drawingRoomLingCeillings(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): void;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected computeDrawingAsync(context: DrawingNodeContext, levelingCeiling: ContentNode): Promise<void>;
        protected drawingBorderLine(document: DrawingDataDocument, container: WareNode): any[];
        protected drawingLineByVectors(document: DrawingDataDocument, begin: Vector3, end: Vector3): LineCurve2dDrawingNode;
        protected drawingLinkRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode, dimEnable?: boolean, dimBase?: number): Promise<void>;
        protected findLinkRoom(node: ContentNode): RoomNode;
        protected getCeilElementId(node: ContentNode): string;
        protected drawingRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, room: RoomNode, dimEnable?: boolean, dimBase?: number): Promise<void>;
        protected drawStartPointArrow(container: WareNode, style?: any): void;
        protected drawWallsCompleteSurfaceLines(node: ContentNode, style?: any, drawingLevel?: number, drawcontext?: DrawingNodeContext): LineCurve2dDrawingNode[];
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
        protected buildDimentionVectors(container: WareNode): Types<Vector3>;
        protected drawingDimentions(document: DrawingDataDocument, node: WareNode, otherPoints?: Vector3[], content?: ContentNode): LineCurveDimensionDrawingNode[];
        protected drawingAllDimentions(document: DrawingDataDocument, nodes: WareNode[]): LineCurveDimensionDrawingNode[];
        protected drawingCeilingLeaderNotes(document: DrawingDataDocument, nodes: ContentNode[]): void;
        protected createLeaderDrawingNode(document: DrawingDataDocument, linePositions: Array<Vector2>, pointCount: number, contentPosition: Vector2, content: string, style?: any): LeaderDrawingNode;
        protected getCeilingBorderPoints(node: ContentNode): Array<Vector3>;
        protected findFelmets(ceiling: LevelingCeilingNode): PelmetNode[];
        private drawingBeams;
        private createFillsByPolygon;
        protected computeContainerPolygon(container: WareNode, clazz: Function, showText?: boolean, showIdentifyCode?: boolean): Vector3[][];
        protected computeVectorsByBoundary(box: BoundaryBox): Vector3[];
        computeDomainBoundary(): void;
        protected sort: (a: {
            p: ContentNode;
            c: Vector3;
        }, b: {
            p: ContentNode;
            c: Vector3;
        }) => number;
        protected drawingDimentionsLine(pc: {
            p: ContentNode;
            c: Vector3;
        }[], factor?: number, textHeight?: number, content?: string): LeaderDrawingNode;
        protected dimensionNameAsync(context: IContext, nodes: Array<{
            p: ContentNode;
            c: Vector3;
        }>): Promise<void>;
        protected getBoundCenter(points: Types<Vector3>): Vector2;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingPlankDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { LevelingCeilingNode } from "sk/data/scheme/database/pattern/node/LevelingCeilingNode";
    import { DrawingNodeBorderOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { LevelingCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDrawingConverter";
    export class LevelingCeilingPlankDrawingConverter extends LevelingCeilingDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected drawingArrow(container: WareNode): void;
        protected drawingPlank(document: DrawingDataDocument, container: WareNode): void;
        protected drawingWallLines(document: DrawingDataDocument, cowalls: CowallNode[], workInstance?: boolean, dimEnable?: boolean, dimBase?: number): void;
        private drawingPlankInnerDimension;
        protected polygonPointsTodimesions(points: Array<Vector2>): Array<any>;
        protected buildDimentionVectors(container: WareNode): Types<Vector3>;
        protected drawingPelmetsPlank(ceiling: LevelingCeilingNode, containerName: string, keyPoints?: Vector3[]): void;
        protected drawingCompleteAndDimPoints(node: ContentNode): LineCurve2dDrawingNode[];
        protected createDimensionsByBox(box: Box2, distance: number, style?: any, option?: DrawingNodeBorderOption, drawingLevel?: number, checkcollider?: boolean, split?: boolean): LineCurveDimensionDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/base/BaseLevelingCeilingDrawingConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingPlankDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingPlankDrawingConverter";
    export class BaseLevelingCeilingDrawingConverter extends LevelingCeilingPlankDrawingConverter {
        canConvert(node: BrepNode, option?: any): boolean;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        protected drawingBaseLevelingCeilings(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): void;
        protected drawingBaseDimentions(document: DrawingDataDocument, nodes: ContentNode[]): LineCurveDimensionDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/base/BaseLevelingFloorDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { LevelingFloorNode } from "sk/data/scheme/database/pattern/node/LevelingFloorNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDrawingConverter";
    export class BaseLevelingFloorDrawingConverter extends BaseLevelingDrawingConverter {
        protected computeDrawingLevelingFloorAsync(context: DrawingNodeContext, levelingFloor: LevelingFloorNode, option?: any): Promise<void>;
        protected findAssembleDoorFloor(levelingFloor: ContentNode): ContentNode[];
        protected getDimensions(allFloors: Array<ContentNode>): Array<WareNode>;
        protected drawingLevelingFloor(context: DrawingNodeContext, document: DrawingDataDocument, node: DynamicWareNode, nameLast?: string): void;
        protected computeDrawingAsync(context: DrawingNodeContext, levelingFloor: DynamicWareNode): Promise<void>;
        protected drawingLinkRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode, drawcontext?: DrawingNodeContext): Promise<void>;
        protected getBound(points: Types<Vector3> | Types<Vector2>): Box2;
        protected buildDimensionVectors(container: WareNode, context?: DrawingNodeContext): Types<Vector3>;
        protected drawingDimensions(allFloors: ContentNode[], document: DrawingDataDocument, nodes: WareNode | Array<WareNode>, drawcontext?: DrawingNodeContext, contentNode?: ContentNode): void;
        protected drawingPlankSrialNumber(plank: PlankNode, distance: Vector3): void;
        protected computeContainerPolygon(container: WareNode, clazz: Function, showIdentifyCode?: boolean, nameLast?: string): Vector3[][];
        protected computeVectorsByBoundary(box: BoundaryBox): Vector3[];
        computeDomainBoundary(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/base/BaseLevelingWallDrawingConverter" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDrawingConverter";
    export type Plankgeos = {
        holegeos: GeometricNode[];
        plankgeos: GeometricNode[];
        textgeos: GeometricNode[];
    };
    export type CommonStyle = {
        linewidth: number;
        textheight: number;
        arrowsize: number;
        borderlength: number;
    };
    export class BaseLevelingWallDrawingConverter extends BaseLevelingDrawingConverter {
        protected computeDrawing(context: DrawingNodeContext, node: ContentNode, option?: any): any;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentNode, option?: any): Promise<any>;
        protected computeMovement(target: Box2, source: Box2, distance: number): Vector2;
        protected drawWall(node: ContentInstanceNode, matrixP: Matrix4, style?: any, drawingLevel?: number): GeometricNode;
        protected computePath3dTo2d(path: PathCurve2d): void;
        protected computeWallPolygonExcludeColumn(assemblewall: ContentNode, wallsurface: WallSurfaceNode, cowall: CowallNode, observeMatrix: Matrix4): Curve2d;
        protected computeIntersectionMax(containermaths: Curve2d[], paths: PathCurve2d[]): PathCurve2d;
        protected computeSurfaceArea(surface: Surface): number;
        protected computeSurfacesArea(surfaces: Surface[]): number;
        protected combineTwoPaths(paths: PathCurve2d[], targetpaths: PathCurve2d[]): PathCurve2d[];
        protected cutPathByLines(path: PathCurve2d, lines: LineCurve2d[]): PathCurve2d[];
        protected checkPathNearlyEqualsPaths(path: PathCurve2d, paths: PathCurve2d[]): boolean;
        protected findColumnsNextToSurface(wallsurface: WallSurfaceNode): ColumnNode[];
        protected checkPositionsIntersectionWithLine(positions: Vector2[], line: Line2): boolean;
        protected findColumnsNextToCowall(cowall: CowallNode): ColumnNode[];
        protected computeColumnsVerticalLines(columns: ColumnNode[], observeMatrix: Matrix4): LineCurve2d[];
        protected computeColumnVerticalLineCurves(column: ColumnNode): LineCurve2d[];
        protected getLineCurvesFromCurvesByDirection(curves: Curve2d[], directions: Vector3[]): Curve2d[];
        protected checkDirectionFromDirecions(direction: Vector3, directions: Vector3[]): boolean;
        protected drawColumns(node: ContentInstanceNode, matrixp: Matrix4, style?: any, textstyle?: any, drawingLevel?: number): GeometricNode[];
        protected drawTextFromNodes(pos: Vector2, textcontent: string, rotation: number, style?: any, drawingLevel?: number): GeometricNode;
        protected drawTextFromNode(node: GeometricNode, textcontent: string, rotation: number, style?: any, drawingLevel?: number): GeometricNode;
        protected drawStructure(node: ContentInstanceNode, matrixP: Matrix4, style?: any, drawingLevel?: number): GeometricNode[];
        protected drawPlankGeos(node: ContentInstanceNode, matrixP: Matrix4, levelname: string, plankstyle?: any, holestyle?: any, planktextstyle?: any, plankdrawingLevel?: number, holedrawingLevel?: number, planktextdrawingLevel?: number, holelinestyle?: any): Plankgeos;
        protected computePlankGeosTextPos(geos: Curve2dNode[]): Vector2;
        protected drawHoleAcross(hole: TechnologyHoleNode, matrixP: Matrix4, style?: any, drawingLevel?: number): void;
        protected drawDimensions(geonodes: GeometricNode[], center: GeometricNode, cellsize: number, style?: any, drawingLevel?: number, drawcenter?: boolean): LineCurveDimensionDrawingNode[];
        protected separateDimPoints(points: Vector2[], centerpoint: Vector2): Vector2[][];
        protected getEdgeValues(node: GeometricNode): Box2;
        protected getBoundaryRect(nodes: DataNode[]): Box2;
        protected clearBoundaryData(): void;
        protected findStructures(dynamic: ContentInstanceNode): ContentNode[];
        protected findHoles(plank: PlankNode): TechnologyHoleNode[];
        protected findPlanks(node: ContentInstanceNode, name: string): PlankNode[];
        protected getPathCurveByProjection(matrixw: Matrix4, matrixp: Matrix4, node: ContentNode): Curve2d[];
    }
}
declare module "sk/data/scheme/drawing/converter/beam/BeamDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class BeamDrawingConverter extends BaseDrawingConverter {
        private technologyModeCd;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, beam: BeamNode): Promise<ResultObject>;
        private computeDrawingAsync;
        private drawingNode;
        protected drawingBeamProfile(document: DrawingDataDocument, cowall: CowallNode, wallpoints: Array<Vector3>, beam: BeamNode, technology: DynamicWareNode, matrix: Matrix4, dimensionPoints2: Types<Vector3>): PolygonCurve2dDrawingNode;
        protected createBeamSurroundDimensionNode(cowall: CowallNode, wallpoints: Array<Vector3>, beam: BeamNode, technology: DynamicWareNode, box: Box2, matrix: Matrix4, isInwards?: boolean): void;
        protected drawingBeamTechnologys(document: DrawingDataDocument, beamPolygn: PolygonCurve2dDrawingNode, technology: DynamicWareNode, matrix: Matrix4): void;
        protected drawingBeamTechnology(document: DrawingDataDocument, node: ContentNode, matrix: Matrix4, boundBox: BoxSolid): Array<SectionSurface>;
        protected drawingDimensions(dimensionPoints: Types<Vector3>, distance: number, color?: string): void;
        private computeBox;
        private drawingOpenings;
        private drawingOpening;
        private drawingWallSurface;
        private buildMatrix;
    }
}
declare module "sk/data/scheme/drawing/converter/beam/BeamDynamicWareDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeBorderOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    interface BeamProfileTempInfo {
        beamProfileDrawingNode: PolygonCurve2dDrawingNode;
        beamProfileTopLeft: Vector3;
        beamProfileTopRight: Vector3;
        beamBoundBoxWorld: BoxSolid;
    }
    interface SectionSurrounds {
        left: Array<SectionSurface>;
        right: Array<SectionSurface>;
        top: Array<SectionSurface>;
        bottom: Array<SectionSurface>;
    }
    export class BeamDynamicWareDrawingConverter extends BaseDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, beamWare: ContentNode): Promise<ResultObject>;
        private computeDrawingAsync;
        private drawingNode;
        private drawingNodeByColumn;
        protected drawingBeamProfile(document: DrawingDataDocument, cowall: BrepNode, wallpoints: Array<Vector3>, beam: BeamNode, technology: ContentNode, matrix: Matrix4, dimensionPoints2: Types<Vector3>, surface?: WallSurfaceNode): BeamProfileTempInfo;
        protected createBeamSurroundDimensionNode(cowall: BrepNode, wallpoints: Array<Vector3>, beam: BeamNode, technology: ContentNode, box: Box2, matrix: Matrix4, isInwards?: boolean, surface?: WallSurfaceNode): void;
        protected drawingBeamTechnologysNew(document: DrawingDataDocument, beamProfileInfo: BeamProfileTempInfo, technology: ContentNode, matrix: Matrix4): void;
        protected makePointsOfBorder(section: SectionSurface, border: string): Array<Vector2>;
        protected makeBorderOptionOfBorder(border: string, visible: boolean, bound: boolean): DrawingNodeBorderOption;
        protected makeTechnologyDimensionDefaultStyle(): any;
        protected createPointNodes(pts: Array<Vector2>): Array<GeometricNode>;
        protected computeBeamTechnology(document: DrawingDataDocument, node: ContentNode, matrix: Matrix4, boundBox: BoxSolid): Array<SectionSurface>;
        protected drawingDimensions(dimensionPoints: Types<Vector3>, distance: number, color?: string): void;
        private computeBox;
        private drawingOpenings;
        private drawingOpening;
        private drawingWallSurface;
        private drawingColumn;
        private buildMatrix;
        protected computeProfileTopLeft(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3): Vector3;
        protected computeProfileTopRight(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3): Vector3;
        protected splitSectionsToPointInfosNew(rects: Array<SectionSurface>, boundBox: BoxSolid): SectionSurrounds;
        protected computeSectionBBoxCorners(section: SectionSurface): {
            topLeft: Vector2;
            topRight: Vector2;
            bottomLeft: Vector2;
            bottomRight: Vector2;
        };
        protected computeRectSurroundType(left: number, top: number, right: number, bottom: number, boundBox: BoxSolid): string;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter" {
    import { CoordService } from 'foundation/runtime/math/coord/CoordService';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    export class CanvasLevelingDimensionConverter extends BaseLevelingDynamicDrawingConverter {
        protected _coordService: CoordService;
        protected pointsConvertCoord(targets: Vector3[] | Vector2[]): Vector3[];
        protected pointConvertCoord(point: Vector3 | Vector2): any;
        protected createEditorDimensionStyle(boundary: Box2): any;
        protected buildHardwareDimensionPoints(node: ContentNode, isConvertCoord?: boolean): Vector3[];
        protected buildPlankDimensionPoints(node: DataNode, layers: string[], isConvertCoord?: boolean): any[];
        protected buildBoundaryFragmentPoints(node: ContentNode): Array<GeometricNode>;
        protected buildRoomInnerLineAndFloorOutLineDimension(node: ContentNode, room: RoomNode): any[];
        protected buildKeelDimensionPointsByLayers(node: ContentNode, layers: string[], isConvertCoord?: boolean, filter?: Function): Vector3[];
        protected getPlankPolygon(plank: PlankNode): Vector2[];
        protected getWarePolygonV3(ware: WareNode): Vector3[];
        protected computeNodesDimensionPoints(nodes: ContentNode[], matrixp: Matrix4): Vector2[];
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasAssembleCeilingDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CeilingSurfaceNode } from "sk/data/scheme/database/floorplan/model/CeilingSurfaceNode";
    import { BathroomCeilingNode } from "sk/data/scheme/database/pattern/node/BathroomCeilingNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasAssembleCeilingDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
        protected buildSurfacePlankDimensionPoints(integCeiling: CeilingSurfaceNode): Vector2[];
        protected getWarePolygon(contentNode: ContentNode): Vector2[];
        protected findChildrenByType<T>(dataNode: DataNode, typeName: {
            new (): T;
        }): Array<T>;
        protected findContainer(integCeiling: BathroomCeilingNode, containerName: string): ContainerNode;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasBathroomCeilingDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomCeilingNode } from "sk/data/scheme/database/pattern/node/BathroomCeilingNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasBathroomCeilingDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
        protected buildSurfacePlankDimensionPoints(integCeiling: BathroomCeilingNode): Vector2[];
        protected getWarePolygon(contentNode: ContentNode): Vector2[];
        protected findChildrenByType<T>(dataNode: DataNode, typeName: {
            new (): T;
        }): Array<T>;
        protected findContainer(integCeiling: BathroomCeilingNode, containerName: string): ContainerNode;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasBathroomFloorDimensionsConvert" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasBathroomFloorDimensionsConvert extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasBathroomFloorWetDimensionsConvert" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasBathroomFloorWetDimensionsConvert extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasBathroomWallDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasBathroomWallDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasDecorateWallDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasDecorateWallDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
        protected buildPlankDimensionPoints(node: DataNode, layers: string[], isConvertCoord?: boolean): any[];
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasFlatWallDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasFlatWallDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
        private keelFilter;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasFloorplanDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    export class CanvasFloorplanDimensionsConverter extends BaseLevelingDynamicDrawingConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasLevelingCeilingDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { LevelingCeilingNode } from "sk/data/scheme/database/pattern/node/LevelingCeilingNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasLevelingCeilingDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
        protected buildBasePlankDimensionPoints(levelingCeiling: LevelingCeilingNode): Vector2[];
        protected buildSurfacePlankDimensionPoints(levelingCeiling: LevelingCeilingNode): Vector2[];
        protected buildKeelLayerDimensionPoints(levelingCeiling: LevelingCeilingNode): Vector2[];
        protected buildKeelHangingDimensionPoints(levelingCeiling: LevelingCeilingNode): Vector2[];
        protected getWarePolygon(ware: WareNode): Vector2[];
        protected findContainer(levelingCeiling: LevelingCeilingNode, containerName: string): ContainerNode;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasLevelingFloorDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasLevelingFloorDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
    }
}
declare module "sk/data/scheme/drawing/converter/canvas/CanvasLevelingWallDimensionsConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { CanvasLevelingDimensionConverter } from "sk/data/scheme/drawing/converter/canvas/CanvasLevelingDimensionConverter";
    export class CanvasLevelingWallDimensionsConverter extends CanvasLevelingDimensionConverter {
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: BrepNode): ResultObject;
    }
}
declare module "sk/data/scheme/model/drawing/DrawingLinkNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingLinkTypeEnum } from 'sk/data/family/enumeration/drawing/DrawingLinkTypeEnum';
    export class DrawingLinkNode extends ContentNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_LINK_NODE: string;
        static FIELD_TYPE_CD: string;
        linkNode: DataNode;
        typeCd: DrawingLinkTypeEnum;
        constructor();
        dispose(): void;
        static create(document: Document): DrawingLinkNode;
    }
    export type DrawingLinkNodeMap = {
        [key: string]: DrawingLinkNode;
    };
}
declare module "sk/data/scheme/drawing/converter/common/DrawingConverter" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Circle2 } from 'foundation/runtime/math/Circle2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { BoundaryRect } from 'foundation/data/common/model/base/BoundaryRect';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentFlipTypeEnum } from 'foundation/data/common/enumeration/ContentFlipTypeEnum';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ISpecificationFamilyType } from 'sk/data/specification/base/ISpecificationFamilyType';
    import { CircleCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/CircleCurve2dDrawingNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { PolylineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolylineCurve2dDrawingNode';
    import { AlignLineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/AlignLineCurveDimensionDrawingNode';
    import { DiameterDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/DiameterDimensionDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { RadiusDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/RadiusDimensionDrawingNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { MemoControlNode } from 'sk/data/family/model/brep/frame/control/MemoControlNode';
    import { PictureControlNode } from 'sk/data/family/model/brep/frame/control/PictureControlNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { TechnologyCavityNode } from 'sk/data/family/database/technology/model/TechnologyCavityNode';
    import { Text2dNode } from 'sk/data/family/model/assistant/text/Text2dNode';
    import { FillDrawingNode } from 'sk/data/family/model/brep/drawing/FillDrawingNode';
    import { PointDrawingNode } from 'sk/data/family/model/brep/drawing/PointDrawingNode';
    import { DrawingFrameNode } from 'sk/data/family/drawing/model/DrawingFrameNode';
    import { DrawingStyleConverter } from 'sk/data/family/drawing/style/DrawingStyleConvter';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDocument } from 'sk/data/family/drawing/DrawingDocument';
    import { DrawingGraphDocument } from 'sk/data/family/drawing/DrawingGraphDocument';
    import { DrawingGraphDocumentService } from 'sk/data/family/service/DrawingGraphDocumentService';
    import { FamilyConfigService, FamilyFeatureInfo } from 'sk/data/family/service/FamilyConfigService';
    import { DrawingLinkNode } from "sk/data/scheme/model/drawing/DrawingLinkNode";
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    export type LineGroup = {
        top: Array<Line2>;
        left: Array<Line2>;
        right: Array<Line2>;
        bottom: Array<Line2>;
        top_list: Array<Array<Line2>>;
        left_list: Array<Array<Line2>>;
        bottom_list: Array<Array<Line2>>;
        right_list: Array<Array<Line2>>;
    };
    export type OutDimConfig = {
        space: number;
        float_space: number;
        content: string;
    };
    export type FramePropertyTexts = {
        [key: string]: string;
    };
    export type ProjectionInfo = {
        type: string;
        angle: number;
        width: number;
        height: number;
        position: Vector3;
    };
    export class DrawingConverter extends InstanceObject {
        protected _document: DrawingDocument;
        protected _drawingNode: DataNode;
        protected _boundaryRect: Box2;
        protected _context: IContext;
        protected drawingStyleConverter: DrawingStyleConverter;
        protected drawingGraphDocuments: Dictionary<DrawingGraphDocument>;
        protected _familyConfigService: FamilyConfigService;
        protected _schemeConfigService: SchemeConfigService;
        protected _drawingGraphDocumentService: DrawingGraphDocumentService;
        constructor(context: IContext, document: DrawingDocument, drawingNode: DataNode);
        convert(): void;
        computeBoundaryRect(): Box2;
        appendBoundaryRectByNodes(dataNodes: Array<DataNode>): void;
        appendBoundaryRectByNode(dataNode: DataNode): void;
        appendBoundaryRectByRectAngle(x: number, y: number, w: number, h: number, angle: number): void;
        appendBoundaryRect(point: PointNode): void;
        appendBoundaryRectValues(x: number, y: number): void;
        appendBoundaryRectValue(value: number): void;
        get boundaryRect(): Box2;
        addBoundaryRectLines(boundaryRect: BoundaryRect): void;
        createBox(min: Vector2, max: Vector2, contentCd?: string, content?: string): PolylineCurve2dDrawingNode;
        buildFrameBox(frame: DrawingFrameNode): void;
        createPolygon2d(drawpoints: Vector2[]): PolygonCurve2dDrawingNode;
        createBox2(pos: Vector2, width: number, height: number, contentCd?: string, content?: string): PolylineCurve2dDrawingNode;
        createCurves(curves: Array<Curve2d>, contentCd?: string, content?: string): Array<Curve2dNode>;
        createLine(from: Vector3, to: Vector3): Line2;
        createDrawingLine(line: Line2, contentCd?: string, content?: string): LineCurve2dDrawingNode;
        createDrawingLine2(from: Vector2, to: Vector2, contentCd?: string, content?: string): LineCurve2dDrawingNode;
        createDrawingLine3(line: LineCurve2d, contentCd?: string, content?: string): LineCurve2dDrawingNode;
        createDrawingLines(lines: Array<Line2>, contentCd?: string, content?: string): Array<LineCurve2dDrawingNode>;
        createDrawingCircle(circle: Circle2, contentCd?: string, content?: string): CircleCurve2dDrawingNode;
        createDrawingCircle2(center: Vector2, begin: Vector2, contentCd?: string, content?: string): CircleCurve2dDrawingNode;
        createDrawingCircle3(center: Vector2, radius: number, contentCd?: string, content?: string): CircleCurve2dDrawingNode;
        createDrawingPolyline(points: Array<Vector2>, contentCd?: string, content?: string): PolylineCurve2dDrawingNode;
        createDrawingPolylines(pointsArr: Array<Array<Vector2>>, contentCd?: string, content?: string): Array<PolylineCurve2dDrawingNode>;
        createDrawingPolyline2(polygon: Polygon, contentCd?: string, content?: string): PolylineCurve2dDrawingNode;
        createDrawingPolylines2(polygons: Array<Polygon>, contentCd?: string, content?: string): Array<PolylineCurve2dDrawingNode>;
        createMemo(x: number, y: number, w: number, h: number, content?: string): MemoControlNode;
        createMemoByContents(x: number, y: number, w: number, h: number, contents?: Array<string>): MemoControlNode;
        createText(x: number, y: number, w: number, h: number, content?: string): TextControlNode;
        createPicture(x: number, y: number, w: number, h: number, resourceId: string, resourceType: string, angle?: number): PictureControlNode;
        createPoint(x: number, y: number, z: number, round?: boolean): PointDrawingNode;
        createPoint2(p: Vector2, round?: boolean): PointDrawingNode;
        createPoint3(p: Vector3, round?: boolean): PointDrawingNode;
        createPoint4(p: PointNode, round?: boolean): PointDrawingNode;
        createPoints2(ps: Array<Vector2>, round?: boolean): Array<PointDrawingNode>;
        createPoints4(ps: Array<PointNode>, round?: boolean): Array<PointDrawingNode>;
        createLineDimByLine2(line: Line2, dim: Vector2, angle: number, content?: string): LineCurveDimensionDrawingNode;
        createAlignLineDimByLine2(line: Line2, dim: Vector2, content?: string): AlignLineCurveDimensionDrawingNode;
        createLineDimByLines(lines: Array<Line2>, length: number, content?: string): Array<LineCurveDimensionDrawingNode>;
        createAlignDimByLines(lines: Array<Line2>, length: number, content?: string): Array<AlignLineCurveDimensionDrawingNode>;
        createOutSideDimByLines2(lines: Array<Line2>, base: Vector2, lineDir: Vector2, length: number, dimDir: Vector2, angle: number, config: OutDimConfig, list?: Array<LineCurveDimensionDrawingNode>): Array<LineCurveDimensionDrawingNode>;
        createLineDim(from: Vector2, to: Vector2, dim: Vector2, angle: number, content?: string): LineCurveDimensionDrawingNode;
        createAlignLineDim(from: Vector2, to: Vector2, dim: Vector2, content?: string): AlignLineCurveDimensionDrawingNode;
        createLineOutSideDimByGroupList(group: LineGroup, config: OutDimConfig): Array<LineCurveDimensionDrawingNode>;
        createRadiusDimByCircle(circle: Circle2, dim: Vector2, content?: string): RadiusDimensionDrawingNode;
        createRadiusDim(center: Vector2, circlePoint: Vector2, leaderLength: number, content?: string): RadiusDimensionDrawingNode;
        createDiameterDimByCircle(circle: Circle2, dim: Vector2, content?: string): DiameterDimensionDrawingNode;
        createDiameterDim(center: Vector2, circlePoint: Vector2, leaderLength: number, content?: string): DiameterDimensionDrawingNode;
        createLeader(points: Array<Vector2>, count: number, contentPoint: Vector2, content: string): LeaderDrawingNode;
        setBrepContent(node: any, contentCd?: string, content?: string): void;
        appendChildNodes(children: Array<DataNode>, parent?: DataNode): void;
        createFill(): FillDrawingNode;
        appendChildNode(child: DataNode, parent?: DataNode): void;
        tidyLines2(lines: Array<Line2>): void;
        createLineGroup(): LineGroup;
        splitLines(lines: Array<Line2>, group: LineGroup): void;
        tidyGroup(group: LineGroup): void;
        tidyGroupList(group: LineGroup): void;
        tidyGroupListByName(group: LineGroup, name: string, cb: Function): void;
        num2InNum2(n1: number, n2: number, n3: number, n4: number): boolean;
        getFeathersByIdAsync(familyId: string): Promise<FamilyFeatureInfo[]>;
        getFeatherByIdCodeAsync(familyId: string, code: string): Promise<string>;
        getFramePropertyTexts(): FramePropertyTexts;
        createFramePropertyTexts(texts: FramePropertyTexts): string;
        isFamilyInstanceSubByIdAsync(node: FamilyInstanceNode, subTypeId: string): Promise<boolean>;
        isFamilyInstanceSubByCodeAsync(node: FamilyInstanceNode, code: string): Promise<boolean>;
        hasFeatureValueAsync(node: FamilyInstanceNode, code: string, value: string): Promise<Boolean>;
        hasFeatureValuesAsync(node: FamilyInstanceNode, code: string, values: Array<string>): Promise<string>;
        hasFeatureAsync(node: FamilyInstanceNode, code: string): Promise<boolean>;
        fetchChildHasFeatureAsync(node: DataNode, code: string, deep: boolean, includeSelf: boolean, ref?: Array<FamilyInstanceNode>): Promise<Array<FamilyInstanceNode>>;
        getFamilyInstanceTypeByNodeAsync(node: FamilyInstanceNode): Promise<ISpecificationFamilyType>;
        getFamilyInfoByNodeAsync(node: ContentInstanceNode): Promise<ISpecificationFamilyInfo>;
        computeNodeWorldNormal(node: ContentNode, normalize?: boolean): Vector3;
        computeNodeWorldVector(node: ContentNode, vector: Vector3, normalize?: boolean): Vector3;
        getObserverMatrix(position: Vector3, vx: Vector3, vy: Vector3, vz: Vector3): Matrix3d;
        computeNodeResourceTypeByObserverData(node: ContentNode, matrix: Matrix4): ProjectionInfo;
        fetchNodeByTypeCodeAsync(node: DataNode, code: string, force: boolean, list?: Array<FamilyInstanceNode>): Promise<Array<FamilyInstanceNode>>;
        findNodeByTypeCodeAsync(node: DataNode, code: string, force?: boolean): Promise<FamilyInstanceNode>;
        searchNodesByFunc<T extends ContentNode>(nodes: Array<T>, func: Function, list?: Array<T>): Array<T>;
        fetchFamilyInstanceByNode(node: DataNode, list?: Array<FamilyInstanceNode>): Array<FamilyInstanceNode>;
        fetchFamilyInstancesByNodeTypeAsync(node: DataNode, typeCode: string, list?: Array<FamilyInstanceNode>): Promise<Array<FamilyInstanceNode>>;
        fetchFamilyInstancesByNodeTypesAsync(node: DataNode, typeCodes: Array<string>, map?: Dictionary<Array<FamilyInstanceNode>>): Promise<Dictionary<Array<FamilyInstanceNode>>>;
        fetchChildFamilyInstancesByNodeTypesAsync(node: DataNode, typeCodes: Array<string>, force: boolean, map?: Dictionary<Array<FamilyInstanceNode>>): Promise<Dictionary<Array<FamilyInstanceNode>>>;
        fetchChildFamilyInstancesByNodeTypeAsync(node: DataNode, typeCode: string, force: boolean, list?: Array<FamilyInstanceNode>): Promise<Array<FamilyInstanceNode>>;
        fetchChildFamilyInstancesByNodeTypeFeatureAsync(node: DataNode, typeCode: string, featureCode: string, featureValue: string, force: boolean, list?: Array<FamilyInstanceNode>): Promise<Array<FamilyInstanceNode>>;
        fetchChildFamilyInstancesByNodeTypeFeaturesAsync(node: DataNode, typeCode: string, featureCode: string, featureValues: Array<string>, force: boolean, map?: Dictionary<Array<FamilyInstanceNode>>): Promise<Dictionary<Array<FamilyInstanceNode>>>;
        fetchFamilyInstancesByNodesTypeAsync(nodes: Array<FamilyInstanceNode>, typeCode: string, list?: Array<FamilyInstanceNode>): Promise<Array<FamilyInstanceNode>>;
        convertFamilyInstatnceGeomery(node: FamilyInstanceNode, observerMatrix: Matrix4, ref?: Array<BrepNode>): Array<BrepNode>;
        convertFamilyInstatncesGeomery(nodes: Array<FamilyInstanceNode>, observerMatrix: Matrix4, ref?: Array<BrepNode>): Array<BrepNode>;
        convertGraphByIdTypeAsync(context: IContext, graphId: string, viewType: string, position: Value2, size: Value2, angle: number, ref?: Array<BrepNode>, flipCd?: ContentFlipTypeEnum): Promise<Array<BrepNode>>;
        convertDomainGraphByIdTypeAsync(context: IContext, graphId: string, viewType: string, position: Value2, size: Value2, angle: number, ref?: Array<BrepNode>, flipCd?: ContentFlipTypeEnum): Promise<Array<BrepNode>>;
        textsApplyMatrix(texts: Array<Text2dNode>, matrix: Matrix4): void;
        convertFamilyInstatnceAsync(context: IContext, node: FamilyInstanceNode, observerMatrix: Matrix4, replace: boolean, ref?: Array<BrepNode>): Promise<Array<BrepNode>>;
        convertFamilyInstatncesAsync(context: ContextObject, nodes: Array<FamilyInstanceNode>, observerMatrix: Matrix4, replace: boolean, ref?: Array<BrepNode>): Promise<Array<BrepNode>>;
        fetchCavitiesByNode(node: DataNode, list?: Array<TechnologyCavityNode>): Array<TechnologyCavityNode>;
        fetchCavitiesByNodes(nodes: Array<DataNode>, list?: Array<TechnologyCavityNode>): Array<TechnologyCavityNode>;
        fetchChildLinkByType(link: DrawingLinkNode, type: string, ref?: Array<DrawingLinkNode>): Array<DrawingLinkNode>;
        findChildLinkByType(link: DrawingLinkNode, type: string): DrawingLinkNode;
        fetchChildLinkNodeByType(link: DrawingLinkNode, type: string, ref?: Array<DataNode>): Array<DataNode>;
        removeInvalidLines(lines: Array<Line2>, tolerance?: number): void;
        sortLine2Length(line1: Line2, line2: Line2): number;
        sortContnetsByPosition(contents: Array<ContentNode>, xs: Array<string>): string;
        sortContentsByPositionCode(x: string): any;
        getContentsPosition(contents: Array<ContentNode>, list?: Array<Vector3>): Array<Vector3>;
        getContentsSortType(contents: Array<ContentNode>, xs: Array<string>): string;
        getStyleByClazzCodeAsync(clazz: any, parentNode: BrepNode, code: string): Promise<string>;
        getGraphContentsAsync(context: IContext, graphId: string, type: string): Promise<DrawingGraphDocument>;
        nodeToDrawings(nodes: Array<BrepNode>, ref?: Array<BrepNode>): Array<BrepNode>;
        nodeToDrawing(node: BrepNode): BrepNode;
        getCurvesFromBreps(breps: Array<BrepNode>, curves?: Array<Curve2dNode>): Array<Curve2dNode>;
        splitBreps(breps: Array<BrepNode>): any;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbCustomXref" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { SkDbXref } from 'sk/data/family/drawing/skdbdatabase/dbobject/block/SkDbXref';
    export class SkDbCustomXref extends SkDbXref {
        _resId: string;
        _worldMatrix: Matrix4;
        _lengthX: number;
        _lengthY: number;
        constructor();
        createXref(observerMatrix: Matrix4): {
            isOk: boolean;
            xref: SkDbXref;
        };
        getProjectResByObserverMatrix(observerMatrix: Matrix4): {
            isOk: boolean;
            resType: string;
            position: Point3;
            angle: number;
        };
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbHole" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { SkDbCurve } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCurve';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    export class SkDbHole extends SkDbEntity {
        _outline: SkDbCurve;
        constructor(outline: SkDbCurve);
        getPositionDimPts(): Array<Point3>;
        getGeomExtents(): {
            isOk: boolean;
            ext: SkDbExtents;
        };
        static fromCircle(center: Point3, radius: number): SkDbHole;
        static fromPolyline(ptlist: Array<Point3>): SkDbHole;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardBase" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDbCurve } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCurve';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDbCustomXref } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbCustomXref";
    import { SkDbHole } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbHole";
    export class SkDbBoardBase extends SkDbEntity {
        _basePt: Point3;
        _yAxis: Vector3;
        _zAxis: Vector3;
        _xAxis: Vector3;
        _xSize: number;
        _ySize: number;
        _zSize: number;
        _path: SkDbCurve;
        _outline: SkDbCurve;
        _holes: Array<SkDbHole>;
        _xref: Array<SkDbCustomXref>;
        _code: string;
        constructor();
        getGeomExtents(): {
            isOk: boolean;
            ext: SkDbExtents;
        };
        toRightCoord(): void;
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
        draw2d(pcsOrigin: Vector3, pcsXAxis: Vector3, pcsYAxis: Vector3, commonDraw: SkGiCommonDraw): void;
        makeXYOutline(): SkDbCurve;
        makeXZOutline(): SkDbCurve;
        makeYZOutline(): SkDbCurve;
        getOutlinePoints(): Array<Point3>;
        getXrefObjectPos(): Array<Point3>;
        getDimPos(): Array<Point3>;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardHatch" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    import { SkDbBoardBase } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardBase";
    export class SkDbBoardHatch extends SkDbBoardBase {
        draw2d(pcsOrigin: Point3, pcsXAxis: Vector3, pcsYAxis: Vector3, commonDraw: SkGiCommonDraw): void;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/DfdUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Point2 } from 'foundation/runtime/math/Point2';
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { CircleArcCurve2dStructure } from 'foundation/data/common/structure/geometric/curve2d/CircleArcCurve2dStructure';
    import { PathCurve2dStructure } from 'foundation/data/common/structure/geometric/curve2d/PathCurve2dStructure';
    import { PointStructure } from 'foundation/data/common/structure/geometric/PointStructure';
    import { SkDbCurve } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCurve';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { DrawingLinkNode } from "sk/data/scheme/model/drawing/DrawingLinkNode";
    import { SchemeElementPerformerContext } from "sk/data/scheme/performer/element/SchemeElementPerformerContext";
    import { SkDbBoardBase } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardBase";
    import { SkDbBoardHatch } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardHatch";
    import { SkDbCustomXref } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbCustomXref";
    export class DfdUtil {
        constructor();
        static calculateBulge(arc: CircleArcCurve2dStructure): number;
        static calculateBulge2Arc(begin: Point3, end: Point3, bulge: number): {
            isPositive: boolean;
            radius: number;
        };
        static clonePoint3(pt: Point3): Point3;
        static movePoint3OnlyVector(pt: Point3, vector: Vector3): Point3;
        static movePoint3(pt: Point3, vector: Vector3, distance: number): Point3;
        static movePoint2(pt: Point2, vector: Vector3, distance: number): Point2;
        static negate(vector: Vector3): Vector3;
        static pointStructture3(pointStructture: PointStructure): Point3;
        static familyNode2CusomXrefaAsync(familyNode: FamilyInstanceNode, performerContext: SchemeElementPerformerContext): Promise<SkDbCustomXref>;
        static pathStructture2SkDbPolyline(path: PathCurve2dStructure): SkDbPolyline;
        static mergePolygonx(polygons: Array<SkDbPolyline>): {
            isOK: boolean;
            outline: SkDbPolyline;
            insidelines: Array<SkDbPolyline>;
        };
        static explodeEntity(ent: SkDbEntity): {
            isOk: boolean;
            entitySet: Array<SkDbEntity>;
        };
        static transforVector(vec: Vector3, mat: Matrix4): void;
        static getCoordSystem(mat: Matrix4): {
            origin: Point3;
            xAxis: Vector3;
            yAxis: Vector3;
            zAxis: Vector3;
        };
        static getResourceMatrix(mat: Matrix4): Matrix4;
        static deepSetEntityColor(ent: SkDbEntity, color: number): void;
        static dataLinkNode2SkBoard(node: DrawingLinkNode): SkDbBoardBase;
        static curve2d2SkCurve(cur2: Curve2d): {
            isOK: boolean;
            skCurve: SkDbCurve;
        };
        static wallEntity2SkDbBoardHatch(wall: WallNode): ResultObject<SkDbBoardHatch>;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeArea" {
    export class SkBeArea {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeBeam" {
    export class SkBeBeam {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeCeiling" {
    export class SkBeCeiling {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeCeilingFlat" {
    export class SkBeCeilingFlat {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeCeilingLadder" {
    export class SkBeCeilingLadder {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeColumn" {
    export class SkBeColumn {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkGeBox" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDbCurve } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCurve';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    export class SkGeBox extends SkDbEntity {
        _basePt: Point3;
        _yAxis: Vector3;
        _zAxis: Vector3;
        _xAxis: Vector3;
        _xSize: number;
        _ySize: number;
        _zSize: number;
        _observedOutline: SkDbCurve;
        constructor();
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
        makeObservedOutline(commonDraw: SkGiCommonDraw): void;
        makeXYOutline(): SkDbCurve;
        makeXZOutline(): SkDbCurve;
        makeYZOutline(): SkDbCurve;
    }
    export class SkGeBoxHatch extends SkGeBox {
        _patternName: string;
        _patternScale: number;
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeConnecterClose" {
    import { SkGeBoxHatch } from "sk/data/scheme/drawing/converter/common/skdb/element/SkGeBox";
    export class SkBeConnecterClose extends SkGeBoxHatch {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeConnecterOpen" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkGeBoxHatch } from "sk/data/scheme/drawing/converter/common/skdb/element/SkGeBox";
    export class SkBeConnecterOpen extends SkGeBoxHatch {
        _openDir: Vector3;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeDoor" {
    export class SkBeDoor {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeFloor" {
    export class SkBeFloor {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeFloorBoard" {
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    import { SkDbBoardBase } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardBase";
    export class SkBeFloorBoard extends SkDbBoardBase {
        makeBoardDim(commonDraw: SkGiCommonDraw): void;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkGeColumn" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDbCurve } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCurve';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    export class SkGeColumn extends SkDbEntity {
        _basePt: Point3;
        _heightAxis: Vector3;
        _diameter: number;
        _height: number;
        _observedOutline: SkDbCurve;
        constructor(bastPt?: Point3, heightAxis?: Vector3, diameter?: number, height?: number);
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
        makeUnderSurfaceOutline(): SkDbCurve;
        makeSideSurfaceOutline(commonDraw: SkGiCommonDraw): SkDbCurve;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeFloorBolt" {
    import { SkGeColumn } from "sk/data/scheme/drawing/converter/common/skdb/element/SkGeColumn";
    export class SkBeFloorBolt extends SkGeColumn {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeHouse" {
    export class SkBeHouse {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeKeel" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    export class SkBeKeel extends SkDbEntity {
        _startPt: Point3;
        _endPt: Point3;
        _openDir: Vector3;
        _width: number;
        _height: number;
        _type: number;
        constructor();
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
        drawFront(commonDraw: SkGiCommonDraw): void;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeLeveler" {
    export class SkBeLeveler {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeOpening" {
    export class SkBeOpening {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeRoom" {
    export class SkBeRoom {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeSpace" {
    export class SkBeSpace {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeSurface" {
    export class SkBeSurface {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeWall" {
    import { SkGeBoxHatch } from "sk/data/scheme/drawing/converter/common/skdb/element/SkGeBox";
    export class SkBeWall extends SkGeBoxHatch {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeWallLeveling" {
    export class SkBeWallLeveling {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkBeWallNewFlat" {
    export class SkBeWallNewFlat {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/element/SkGeSphere" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { SkDbCurve } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCurve';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    export class SkGeSphere extends SkDbEntity {
        _centerPt: Point3;
        _diameter: number;
        _height: number;
        _observedOutline: SkDbCurve;
        constructor();
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
        makeObservedOutline(): SkDbCurve;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardUBTop" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { SkDbXref } from 'sk/data/family/drawing/skdbdatabase/dbobject/block/SkDbXref';
    import { SkDbBoardBase } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbBoardBase";
    export class SkDbBoardUBTop extends SkDbBoardBase {
        _subObjects: Array<SkDbXref>;
        constructor();
        getSubObjectPos(): Array<Point3>;
        getDimPos(): Array<Point3>;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbLeveler" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkGiCommonDraw } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkGiCommonDraw';
    export class SkDbLeveler extends SkDbEntity {
        _position: Point3;
        _radius: number;
        constructor();
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
    }
    export class SkDbLevelerEx extends SkDbEntity {
        _basePt: Point3;
        _heightAxis: Vector3;
        _diameter: number;
        _height: number;
        constructor();
        worldDraw(context: any, commonDraw: SkGiCommonDraw): void;
        makeSurfaceOutline(commonDraw: SkGiCommonDraw): void;
        makeSideSurfaceOutline(commonDraw: SkGiCommonDraw): void;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbOpening" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    export class SkDbOpening extends SkDbEntity {
        _startPt: Point3;
        _endPt: Point3;
        _width: number;
        _height: number;
        _thickness: number;
        _bulge: number;
        constructor();
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbUBRegion" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDbHole } from "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbHole";
    export class SkDbUBRegion extends SkDbEntity {
        _outline: SkDbPolyline;
        _insideline: SkDbPolyline;
        _holes: Array<SkDbHole>;
        _code: string;
        constructor();
        fromOutlinePts(pts: Array<Point3>, thick: number): void;
        fromInsidelinePts(pts: Array<Point3>): void;
        getGeomExtents(): {
            isOk: boolean;
            ext: SkDbExtents;
        };
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/entity/SkDbWallProjectEntity" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    export class SkDbWallProjectEntity extends SkDbEntity {
        _outline: SkDbPolyline;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/frame/SkDbFrameBase" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    export class SkDbFrameBase extends SkDbEntity {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/frame/SkDbAutoFrame" {
    import { SkDbFrameBase } from "sk/data/scheme/drawing/converter/common/skdb/frame/SkDbFrameBase";
    export class SkDbAutoFrame extends SkDbFrameBase {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/frame/SkDbPreDefFrame" {
    import { SkDbFrameBase } from "sk/data/scheme/drawing/converter/common/skdb/frame/SkDbFrameBase";
    export class SkDbPreDefFrame extends SkDbFrameBase {
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/frame/SkFrameManager" {
    import { SkDbDatabase } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbDatabase';
    export class SkFrameManager {
        static _frameDb: SkDbDatabase;
        static insertFrame(destDb: SkDbDatabase, frameName: string): boolean;
        static loadFrameDoc(): boolean;
    }
}
declare module "sk/data/scheme/drawing/converter/common/skdb/SkDbConvertor" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { SkDbXref } from 'sk/data/family/drawing/skdbdatabase/dbobject/block/SkDbXref';
    import { SkDbDatabase } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbDatabase';
    import { SkDbArc } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbArc';
    import { SkDbCircle } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCircle';
    import { SkDbCurve } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCurve';
    import { SkDbLine } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbLine';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbAlignedDimension } from 'sk/data/family/drawing/skdbdatabase/dbobject/dimension/SkDbAlignedDimension';
    import { SkDbDiametricDimension } from 'sk/data/family/drawing/skdbdatabase/dbobject/dimension/SkDbDiametricDimension';
    import { SkDbRotatedDimension } from 'sk/data/family/drawing/skdbdatabase/dbobject/dimension/SkDbRotatedDimension';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbHatch } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbHatch';
    import { SkDbText } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbText';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { DrawingDocument } from 'sk/data/family/drawing/DrawingDocument';
    export class SkDbConvertor {
        static _ext: SkDbExtents;
        static _entityExt: SkDbExtents;
        static _mirrorY: boolean;
        static process(skDb: SkDbDatabase, drawingDoc: DrawingDocument, outNode?: DataNode, mirrorY?: boolean): boolean;
        static convertEntity(entity: SkDbEntity, drawingNode: any): void;
        static convertCurve(curve: SkDbCurve, drawingNode: any): void;
        static convertText(text: SkDbText, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertCircle(circle: SkDbCircle, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertArc(arc: SkDbArc, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertLine(skline: SkDbLine, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertDrawingNodes(drawingNodes: BrepNode[]): SkDbEntity[];
        static convertDrawingNode(drawingNode: BrepNode): SkDbEntity;
        static convertLineNode(lineNode: LineCurve2dDrawingNode): SkDbLine;
        static convertPolyline(skpoly: SkDbPolyline, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertAlignLineDim(skdim: SkDbAlignedDimension, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertRotatedDimension(skdim: SkDbRotatedDimension, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertDiametricDimension(ddim: SkDbDiametricDimension, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertXref(skxref: SkDbXref, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertHatch22(skHatch: SkDbHatch, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertHatch11(skHatch: SkDbHatch, drawingDoc: DrawingDocument, outNode?: DataNode): void;
        static convertHatch(skHatch: SkDbHatch, drawingDoc: DrawingDocument, outNode?: DataNode): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/FamilyDrawerAnnotation" {
    import { Annotation } from 'cross/runtime/lang/reflect/Annotation';
    export class FamilyDrawerAnnotation extends Annotation {
        typeCode: string;
        newInstance(): any;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuAvailablePlaceManager" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    export class SkAuAvailablePlaceManager {
        protected _extents: SkDbExtents;
        protected _cellWidth: number;
        protected _cellHeight: number;
        protected _data: boolean[];
        protected _rowCount: number;
        protected _columnCount: number;
        constructor();
        extents(): SkDbExtents;
        initFromObjects(ext: SkDbExtents, cellWidth: number, cellHeight: number, objects: SkDrObject[]): void;
        initFromPlacePoints(ext: SkDbExtents, cellWidth: number, cellHeight: number, placePoints: Vector2[], placeExts: SkDbExtents[]): void;
        protected calculateCellCount(ext: SkDbExtents, cellWidth: number, cellHeight: number): void;
        protected resetPlace(): void;
        isAvailable(ext: SkDbExtents): boolean;
        evaluationExtendss(exts: SkDbExtents[]): number;
        evaluationExtends(ext: SkDbExtents): number;
        addExtendss(exts: SkDbExtents[]): void;
        addExtends(ext: SkDbExtents): void;
        addPolyline(points: Vector2[], isClose?: boolean): void;
        addLine(pt1: Vector2, pt2: Vector2): void;
        hitCellIndexByPoint(pt: Vector2): number;
        coord2Index(rowIndex: number, columnIndex: number): number;
        hitCellCoordByPoint(pt: Vector2): {
            rowIndex: number;
            columnIndex: number;
        };
        hitCellByExtends(ext: SkDbExtents): number[];
        minCellSize(): number;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrViewport" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDbDatabase } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbDatabase';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkAuAvailablePlaceManager } from "sk/data/scheme/drawing/converter/drawer/SkAuAvailablePlaceManager";
    export class PushEntityContainer {
    }
    export class SkDrViewport {
        db: SkDbDatabase;
        contentExtents: SkDbExtents;
        placeholderExtents: SkDbExtents[];
        _xdata: {};
        entityContainers: SkDbEntity[][];
        entitys: SkDbEntity[];
        name: string;
        placeManager: SkAuAvailablePlaceManager;
        protected _observeMatrix: Matrix4;
        protected _eysDir: Vector3;
        protected _isXY: boolean;
        position: Vector3;
        extents: SkDbExtents;
        spreadFlag: boolean;
        moveDistanceX: number;
        constructor();
        setObserveCoord(origin: Vector3, axisX: Vector3, axisY: Vector3): void;
        observeMatrix(): Matrix4;
        eysDir(): Vector3;
        addEntity(entity: SkDbEntity): void;
        pushEntityContainer(entityContainer: SkDbEntity[]): void;
        popEntityContainer(): SkDbEntity[];
        getExtents(): SkDbExtents;
        initPlaceManager(cellWidth: number, cellHeight: number): void;
        protected getViewportPlacePoints(cellSize: number, outPoints?: Vector2[]): {
            outPoints: Vector2[];
            exts: SkDbExtents[];
        };
        static createEmptyViewport(db?: SkDbDatabase, observeMatrix?: Matrix4): SkDrViewport;
        zoomView(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrObject" {
    import { SkDbDatabase } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbDatabase';
    import { SkCmColor } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkCmColor';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrObject {
        db: SkDbDatabase;
        contentExtents: SkDbExtents;
        _xdata: {};
        drawingColor: SkCmColor;
        constructor();
        draw(viewport: SkDrViewport): void;
        xData(name: string): any;
        setXData(name: string, value: any): void;
        getGeomExtents(ext?: SkDbExtents): SkDbExtents;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDrawing" {
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDrawing extends SkDrObject {
        name: string;
        date: string;
        author: string;
        viewport: SkDrViewport;
        constructor();
        draw(viewport: SkDrViewport): void;
        setViewport(viewport?: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrBody" {
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrBody extends SkDrObject {
        drawing: SkDrDrawing;
        constructor(drawing?: SkDrDrawing);
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/CurveUtil" {
    import { Value2 } from 'cross/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { CircleArcCurve2d } from 'foundation/runtime/geometry/curve2d/CircleArcCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    export class CurveUtil {
        static calculateBulge(arc: CircleArcCurve2d): number;
        static createRectByCenterLW(center: Value2, lengthX: number, lengthY: number): SkDbPolyline;
        static createRectByExtents(ext: SkDbExtents): SkDbPolyline;
        static pathCurve2d2SkDbPolyline(path: PathCurve2d): SkDbPolyline;
        static vector2s2SkDbPolyline(points: Vector2[], isClosed?: boolean): SkDbPolyline;
        static vector3s2SkDbPolyline(points: Vector3[], isClosed?: boolean): SkDbPolyline;
        static offsetPoly(poly: SkDbPolyline, offset: number): SkDbPolyline;
        static mergePolygon(polygons: SkDbPolyline[]): SkDbPolyline[];
        static isCrossLine2(pt11: Vector2, pt12: Vector2, pt21: Vector2, pt22: Vector2): boolean;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/UnitBathroomPlanUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { HoleTypeEnum } from "sk/data/scheme/database/floorplan/model/util/OpeningNodeUtil";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { HoleNode } from "sk/data/scheme/database/floorplan/model/HoleNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    export class UnitBathroomPlanUtil {
        static calculateRoomExtends(room: RoomNode): SkDbExtents;
        static fetchRoomHole(room: RoomNode): {
            wallHoles: HoleNode[];
            flatWallHoles: HoleNode[];
        };
        static checkPolygonsIntersection(polygon: Vector2[], otherpolygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        static ptIsInFrame(frame: SkDbExtents, x: number, y: number): boolean;
        static boundIsInFrame(frame: SkDbExtents, bound: BoundaryBox): boolean;
        static isInRoom(room: RoomNode, instance: ContentNode, checkBox?: boolean, includeRoomOutline?: boolean): boolean;
        static findRelationElements(node: ContentNode, findslave?: boolean): InstanceElement[];
        static findNodeFromElementIdInNodes(id: string, nodes: DataNode[]): DataNode;
        static findNodeFromNodeIdInNodes(id: string, nodes: DataNode[]): DataNode;
        static calculateWallPolygonsWithoutOpening(walls: Array<WallNode> | Array<CowallNode>, wallPoints: Vector2[][], frame?: Vector2[]): Vector2[][];
        static getWallsPlaneExtents(walls: WallNode[]): SkDbExtents[];
        static getWallPlaneExtents(wall: WallNode): SkDbExtents;
        static calculateroomframeAllWallOutlines(roomnode: RoomNode, offset: number): {
            wall: {};
            flatWall: {};
            frame: SkDbExtents;
            sections: SkDbExtents[];
        };
        static calculateFrameAllWalls(frame: SkDbExtents, floorplan: FloorplanNode): {
            walls: WallNode[];
            flatWalls: FlatWallNode[];
        };
        static calculateFlatWallOutline(walls: Array<WallNode>, frame?: Vector2[]): Vector2[][];
        static calculateFlatWallOutline_(walls: Array<FlatWallNode>, frame?: Vector2[]): Vector2[][];
        static calculateWallOutline(walls: Array<WallNode>, frame?: Vector2[]): Vector2[][];
        static getHoleType(opening: ContentNode): HoleTypeEnum;
        static getNodeOutline(node: ContentNode): SkDbPolyline;
        static getBathroomWallBaseline(wall: BathroomWallNode): {
            begin: Vector3;
            end: Vector3;
        };
        protected findRoomContents(room: RoomNode): FamilyInstanceNode[];
        static getNodeRefTypeCode(node: FamilyInstanceNode): string;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEle" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Color4 } from 'foundation/runtime/math/Color4';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEle extends SkDrObject {
        node: ContentNode;
        entitys: SkDbEntity[];
        typeCode: string;
        protected _extents: SkDbExtents;
        protected _area: number;
        color: Color4;
        drawData: Array<BrepNode>;
        constructor();
        preDraw(node: ContentNode, viewport: SkDrViewport): void;
        initFromNode(node: ContentNode, viewport: SkDrViewport): void;
        protected transformDrawData2Viewport(viewport: SkDrViewport): void;
        loadResourceAsync(converter: BaseDrawingConverter, context: DrawingNodeContext, viewport: SkDrViewport, replace?: boolean): Promise<ResultObject>;
        draw(viewport: SkDrViewport): void;
        drawFrontView(entitys: SkDbEntity[]): void;
        drawBackView(entitys: SkDbEntity[]): void;
        drawLeftView(entitys: SkDbEntity[]): void;
        drawRightView(entitys: SkDbEntity[]): void;
        drawTopView(entitys: SkDbEntity[]): void;
        drawBottomView(entitys: SkDbEntity[]): void;
        getDimensionStrs(): string[];
        updateGeomExtents(): SkDbExtents;
        getGeomExtents(extt?: SkDbExtents): SkDbExtents;
        getArea(): number;
        static drawCircleNode(node: ContentNode, entitys: SkDbEntity[], withCross?: boolean): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleSet" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrSet extends SkDrObject {
        sset: SkDrEle[];
        clazzs: Function[];
        protected _clazzMap: {
            [key: string]: Function;
        };
        constructor();
        appendClazz(clazz: any): boolean;
        draw(viewport: SkDrViewport): void;
        initFromNodes(nodes: WareNode[], viewport: SkDrViewport): void;
        initFromRoomNode(room: RoomNode, viewport: SkDrViewport): void;
        initFromFloorplanNode(floorplanNode: FloorplanNode, viewport: SkDrViewport): void;
        loadResourceAsync(converter: BaseDrawingConverter, context: DrawingNodeContext, viewport: SkDrViewport, replace?: boolean): Promise<ResultObject>;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrOriginalFlatWall extends SkDrObject {
        wallOutline: Vector2[][];
        wallData: {};
        wallSectionIndexs: number[];
        draw(viewport: SkDrViewport): void;
        static createFromSingleRoomPlan(room: RoomNode, offset: number, viewport: SkDrViewport): SkDrOriginalFlatWall;
        static initFromFloorplanNode(floorplanNode: FloorplanNode, viewport: SkDrViewport): SkDrOriginalFlatWall;
        getGeomExtents(ext?: SkDbExtents): SkDbExtents;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole" {
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrOriginalFlatWallHole extends SkDrObject {
        static createFromSingleRoomPlan(room: RoomNode, offset: Number, viewport: SkDrViewport): SkDrOriginalFlatWallHole;
        static initFromFloorplanNode(floorplanNode: FloorplanNode, viewport: SkDrViewport): SkDrOriginalFlatWallHole;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleOriginalFlue" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleOriginalFlue extends SkDrObject {
        node: ColumnNode;
        originPt: Vector2;
        thickVec: Vector2;
        widthVec: Vector2;
        constructor(node?: ColumnNode);
        draw(viewport: SkDrViewport): void;
        drawBox(center: Vector2, halfw: number, halfh: number, viewport: SkDrViewport): void;
        drawFlueSym(center: Vector2, halfw: number, halfh: number, viewport: SkDrViewport): void;
        drawWindFlueSym(center: Vector2, halfw: number, halfh: number, viewport: SkDrViewport): void;
        drawFlue(viewport: SkDrViewport): void;
        drawWindFlue(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue" {
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrEleOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrEleOriginalFlue";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrOriginalFlue extends SkDrObject {
        flues: SkDrEleOriginalFlue[];
        constructor();
        static createFromSingleRoomPlan(room: RoomNode, viewport: SkDrViewport): SkDrOriginalFlue;
        static initFromFloorplanNode(floorplanNode: FloorplanNode, viewport: SkDrViewport): SkDrOriginalFlue;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrOriginalWall extends SkDrObject {
        wallOutline: Vector2[][];
        wallData: {};
        wallSectionIndexs: number[];
        frame: SkDbExtents;
        protected drawSection(): void;
        getGeomExtents(ext?: SkDbExtents): SkDbExtents;
        draw(viewport: SkDrViewport): void;
        static createFromSingleRoomPlan(room: RoomNode, offset: number, viewport: SkDrViewport): SkDrOriginalWall;
        static initFromFloorplanNode(floorplanNode: FloorplanNode, viewport: SkDrViewport): SkDrOriginalWall;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleOriginalHole" {
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleOriginalHole extends SkDrEle {
        hole: OpeningNode;
        constructor(hole?: OpeningNode);
        draw(viewport: SkDrViewport): void;
        drawDoor(viewport: SkDrViewport): void;
        drawWindow(viewport: SkDrViewport): void;
        getDimensionStrs(): string[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole" {
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrEleOriginalHole } from "sk/data/scheme/drawing/converter/drawer/SkDrEleOriginalHole";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrOriginalWallHole extends SkDrObject {
        holes: SkDrEleOriginalHole[];
        constructor();
        static createFromSingleRoomPlan(room: RoomNode, offset: Number, viewport: SkDrViewport): SkDrOriginalWallHole;
        static initFromFloorplanNode(floorplanNode: FloorplanNode, viewport: SkDrViewport): SkDrOriginalWallHole;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalBody" {
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrSet } from "sk/data/scheme/drawing/converter/drawer/SkDrEleSet";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrFloorPlanOriginalBody extends SkDrBody {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        flues: SkDrOriginalFlue;
        wareSet: SkDrSet;
        constructor(drawing?: SkDrDrawing);
        initFromFloorplanNode(floorplanNode: FloorplanNode): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    export class SkDrDimSegment {
        elevation: number;
        margin: number;
        begin: number;
        end: number;
        docked: boolean;
        beginDocked: boolean;
        endDocked: boolean;
        horizontal: boolean;
        splitable: boolean;
        normal: Vector2;
        dockFlag: number;
        constructor();
        clone(): SkDrDimSegment;
        split(value: number): SkDrDimSegment;
        splitByTwo(begin: number, end: number): {
            midSeg: SkDrDimSegment;
            endSeg: SkDrDimSegment;
        };
        swap(): void;
        static hitTestBegin(value1: SkDrDimSegment, value2: SkDrDimSegment): boolean;
        static hitTestEnd(value1: SkDrDimSegment, value2: SkDrDimSegment): boolean;
        static createFromTwoPoints(begin: Vector2, end: Vector2, normal?: Vector2, splitable?: boolean, ext?: SkDbExtents): SkDrDimSegment;
        static createFromTwoPointsXY(beginX: number, beginY: number, endX: number, endY: number, normal?: Vector2, splitable?: boolean, ext?: SkDbExtents): SkDrDimSegment;
        static createFromPolyline(poly: SkDbPolyline, ext: SkDbExtents, splitable?: boolean): SkDrDimSegment[];
        static pushSegment(dimSegments: SkDrDimSegment[], dimSegment: SkDrDimSegment, ext: SkDbExtents): void;
        static sameSegment(dimSegment1: SkDrDimSegment, dimSegment2: SkDrDimSegment, ext: SkDbExtents): number;
        static createFromExtends(ext: SkDbExtents, splitable?: boolean): SkDrDimSegment[];
        static createOnOutline(poly: SkDbPolyline, ext: SkDbExtents, outline: Array<Vector2>, splitable?: boolean): SkDrDimSegment[];
        static createFromExtendsLength(ext: SkDbExtents, splitable?: boolean): SkDrDimSegment[];
        static sortSegment(segment1: SkDrDimSegment, segment2: SkDrDimSegment): number;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimVertex" {
    export class SkDrDimVertex {
        value: number;
        elevation: number;
        splitable: boolean;
        constructor(value?: number, splitable?: boolean);
        hitTest(value: number): number;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimRow" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    import { SkDrDimVertex } from "sk/data/scheme/drawing/converter/drawer/SkDrDimVertex";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDimRow {
        segments: SkDrDimSegment[];
        splitSegments: Types<SkDrDimSegment>;
        vertexs: Types<SkDrDimVertex>;
        avgValue: number;
        elevation: number;
        leadlineVec: Vector2;
        constructor(min?: number, max?: number);
        draw(viewport: SkDrViewport): void;
        dockable(value: number): boolean;
        hitDockValue(value: number, low?: number): {
            hitFlag: number;
            index: number;
        };
        dockSegment(segment: SkDrDimSegment): boolean;
        dockSegment11(segment: SkDrDimSegment): boolean;
        static sortRow(row1: SkDrDimRow, row2: SkDrDimRow): number;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrOption" {
    export class SkDrOption {
        static txtHeight1: number;
        static txtHeight2: number;
        static txtHeight3: number;
        static txtHeight4: number;
        static txtHeight5: number;
        static txtHeight6: number;
        static txtHeight7: number;
        static txtHeight30_1: number;
        static txtHeight30_2: number;
        static txtHeight30_3: number;
        static txtHeight30_4: number;
        static txtHeight30_5: number;
        static txtHeight30_6: number;
        static txtHeight30_7: number;
        static dimTxtHeight: number;
        static leaderTxtHeight: number;
        static materialLeaderTxtHeight: number;
        static materialColorOderTxtHeight: number;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuDimInsideArrange" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbAlignedDimension } from 'sk/data/family/drawing/skdbdatabase/dbobject/dimension/SkDbAlignedDimension';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    class InsideDimSegmentGroup {
        hDimSegments: SkDrDimSegment[];
        begin: number;
        end: number;
        constructor(segment: SkDrDimSegment);
        merge(segment: SkDrDimSegment): boolean;
    }
    export class SkAuDimInsideArrange {
        outline: Vector2[];
        points: Vector2[];
        exts: SkDbExtents[];
        extPoints: SkDbExtents[];
        dimEntitys: SkDbAlignedDimension[];
        dimRows: SkDrDimRow[];
        hDimSegments: SkDrDimSegment[];
        nhDimSegments: SkDrDimSegment[];
        vDimSegments: SkDrDimSegment[];
        nvDimSegments: SkDrDimSegment[];
        bottomWeight: number;
        constructor();
        addPoint(pt: Vector2): void;
        addPoints(pts: Vector2[]): void;
        addExtentss(exts: SkDbExtents[]): void;
        addExtents(ext: SkDbExtents): void;
        addExtentsPoint(ext: SkDbExtents): void;
        addExtentsPoints(exts: SkDbExtents[]): void;
        arrange(): void;
        arrangeExtents(ext: SkDbExtents): void;
        arrangePoint(point: Vector2, ext?: SkDbExtents): void;
        createPointDim(pt: Vector2, refX: number, refY: number, ext?: SkDbExtents): void;
        createExtentDim(ext: SkDbExtents, refX: number, refY: number): void;
        static arrangeArrangers(arrangers: SkAuDimInsideArrange[]): SkDrDimRow[];
        static arrangeSegments(segments: SkDrDimSegment[]): SkDrDimRow[];
        static splitGroup(segments: SkDrDimSegment[]): InsideDimSegmentGroup[];
        static mergeSegments(segments: SkDrDimSegment[]): SkDrDimRow;
        createPointDim__(pt: Vector2, refX: number, refY: number, ext?: SkDbExtents): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/BathroomDesignDataToDrawingUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { BathroomFloorDryNode } from "sk/data/scheme/database/pattern/node/BathroomFloorDryNode";
    import { BathroomFloorWetNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetNode";
    import { BathroomFloorWetWareNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetWareNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    export class BathroomDesignDataToDrawingUtil {
        static floorWetEdgeThickness(node: BathroomFloorWetNode): number;
        static floorWetWareEdgeThickness(node: BathroomFloorWetWareNode): number;
        static floorDryEdgeThickness(node: BathroomFloorDryNode): number;
        static getDryFloorGapSet(node: BathroomNode): Array<Line2>;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleBathRoomArea" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { BathroomFloorDryNode } from "sk/data/scheme/database/pattern/node/BathroomFloorDryNode";
    import { BathroomFloorWetNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetNode";
    import { BathroomFloorWetWareNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetWareNode";
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleBathRoomArea extends SkDrEle {
        outline: SkDbPolyline;
        centerLine: SkDbPolyline;
        finishLine: SkDbPolyline;
        name: string;
        refName: string;
        onlyFinishLine: boolean;
        edgeThickness: number;
        constructor(name?: string, outline?: SkDbPolyline, centerLine?: SkDbPolyline, finishLine?: SkDbPolyline, onlyFinishLine?: boolean);
        static createFromAreaNode(areaNode: BathroomFloorDryNode | BathroomFloorWetNode | BathroomFloorWetWareNode, viewport: SkDrViewport, onlyFinishLine: boolean): SkDrEleBathRoomArea;
        static createFromAreaNode_(areaNode: BathroomFloorDryNode): SkDrEleBathRoomArea;
        static createFromAreaNode__(areaNode: BathroomFloorDryNode | BathroomFloorWetNode): SkDrEleBathRoomArea;
        draw(viewport: SkDrViewport): void;
        getDimensionStrs(): string[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElePlank" {
    import { Color4 } from 'foundation/runtime/math/Color4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbCircle } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCircle';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElePlank extends SkDrEle {
        outline: SkDbPolyline;
        circleHoles: SkDbCircle[];
        polyHoles: SkDbPolyline[];
        materialColor: string;
        materialColorPos: Vector2;
        order: string;
        holeColor: Color4;
        constructor();
        initFromNode(node: ContentNode, viewport: SkDrViewport): void;
        drawTopView(entitys: SkDbEntity[]): void;
        drawHole(techHoleNode: TechnologyHoleNode, entitys: SkDbEntity[]): void;
        getMaterialColorPos(): Vector2;
        getPolygonGeomExtents(extt?: SkDbExtents): SkDbExtents;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimensionInside" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorPlanOriginalBody } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalBody";
    export class SkDrFloorPlanOriginalDimensionInside extends SkDrObject {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        hDimRows: SkDrDimRow[];
        vDimRows: SkDrDimRow[];
        dimRows: SkDrDimRow[];
        entitys: SkDbEntity[];
        body: SkDrFloorPlanOriginalBody;
        constructor(body: SkDrFloorPlanOriginalBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrFloorPlanOriginalBody): void;
        initHoleDimForDesign(body: SkDrFloorPlanOriginalBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow" {
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    export class SkDrDimensionRow extends SkDrObject {
        drawing: SkDrDrawing;
        rowDimExt: SkDbExtents;
        innerExtents: SkDbExtents;
        outExtents: SkDbExtents;
        hDimRows: SkDrDimRow[];
        vDimRows: SkDrDimRow[];
        constructor(drawing: SkDrDrawing);
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbText } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbText';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkAuAvailablePlaceManager } from "sk/data/scheme/drawing/converter/drawer/SkAuAvailablePlaceManager";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleLeader extends SkDrObject {
        upString: string[];
        downString: string[];
        targetPoint: Vector2;
        attachedPoints: Vector2[];
        leadlinePoint1: Vector2;
        baselineDir: Vector2;
        hasArrow: boolean;
        arrowSize: number;
        textHeight: number;
        scale: number;
        placeManager: SkAuAvailablePlaceManager;
        static dirOptions: Vector2[];
        static baselineDirOptions: Vector2[];
        constructor();
        draw(viewport: SkDrViewport): void;
        protected createTextEntitys(): SkDbText[];
        maxTime(): number;
        arrange(pm: SkAuAvailablePlaceManager, drDimRow: SkDrDimensionRow): void;
        getTextExtends(cellSize: number): SkDbExtents[];
        getPositionByIndex(index: number, drDimRow: SkDrDimensionRow): {
            leadlinePoint1: Vector2;
            baselineDir: Vector2;
        };
        getDirOptions(): Vector2[];
        getBaselineDirOptions(): Vector2[];
        static initDirOptions(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimensionRow" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorPlanOriginalBody } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalBody";
    export class SkDrFloorPlanOriginalDimensionRow extends SkDrDimensionRow {
        body: SkDrFloorPlanOriginalBody;
        leaders: SkDrEleLeader[];
        entitys: SkDbEntity[];
        constructor(body: SkDrFloorPlanOriginalBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrFloorPlanOriginalBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimNotes" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDimNotes extends SkDrObject {
        notes: string[];
        name: string;
        entitys: SkDbEntity[];
        constructor();
        draw(viewport: SkDrViewport): void;
        initFromNotes(notes: string[], dimRow: SkDrDimensionRow): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimPlankOrder" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrElePlank } from "sk/data/scheme/drawing/converter/drawer/SkDrElePlank";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDimPlankOrder extends SkDrObject {
        planks: SkDrElePlank[];
        entitys: SkDbEntity[];
        constructor();
        draw(viewport: SkDrViewport): void;
        initFromPlanks(planks: SkDrElePlank[]): void;
        fetchInfo(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleLeaderMaterial" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    export class SkDrEleLeaderMaterial extends SkDrEleLeader {
        constructor();
        maxTime(): number;
        getPositionByIndex(index: number, drDimRow: SkDrDimensionRow): {
            leadlinePoint1: Vector2;
            baselineDir: Vector2;
        };
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbText } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbText';
    import { SkAuAvailablePlaceManager } from "sk/data/scheme/drawing/converter/drawer/SkAuAvailablePlaceManager";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrDimNotes } from "sk/data/scheme/drawing/converter/drawer/SkDrDimNotes";
    import { SkDrDimPlankOrder } from "sk/data/scheme/drawing/converter/drawer/SkDrDimPlankOrder";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrEleLeaderMaterial } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeaderMaterial";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDimensionText extends SkDrObject {
        drawing: SkDrDrawing;
        texts: SkDbText[];
        leaders: SkDrEleLeader[];
        materialLeaders: SkDrEleLeaderMaterial[];
        plankOrder: SkDrDimPlankOrder;
        notes: SkDrDimNotes;
        entitys: SkDbEntity[];
        constructor(drawing: SkDrDrawing);
        draw(viewport: SkDrViewport): void;
        arrangeLeaders(leaders: SkDrEleLeader[], drDimRow: SkDrDimensionRow): void;
        arrangeLeader(pm: SkAuAvailablePlaceManager, leader: SkDrEleLeader, drDimRow: SkDrDimensionRow): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimensionText" {
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorPlanOriginalBody } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalBody";
    import { SkDrFloorPlanOriginalDimensionRow } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimensionRow";
    export class SkDrFloorPlanOriginalDimensionText extends SkDrDimensionText {
        body: SkDrFloorPlanOriginalBody;
        dimRow: SkDrFloorPlanOriginalDimensionRow;
        constructor(body: SkDrFloorPlanOriginalBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrFloorPlanOriginalBody, dimRow: SkDrFloorPlanOriginalDimensionRow): void;
        fetchInfo(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimension" {
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorPlanOriginalBody } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalBody";
    import { SkDrFloorPlanOriginalDimensionInside } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimensionInside";
    import { SkDrFloorPlanOriginalDimensionRow } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimensionRow";
    import { SkDrFloorPlanOriginalDimensionText } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimensionText";
    export class SkDrFloorPlanOriginalDimension extends SkDrObject {
        body: SkDrFloorPlanOriginalBody;
        dimRow: SkDrFloorPlanOriginalDimensionRow;
        dimInside: SkDrFloorPlanOriginalDimensionInside;
        dimText: SkDrFloorPlanOriginalDimensionText;
        constructor(body: SkDrFloorPlanOriginalBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrFloorPlanOriginalBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDrawing" {
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorPlanOriginalBody } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalBody";
    import { SkDrFloorPlanOriginalDimension } from "sk/data/scheme/drawing/converter/drawer/floorplan/SkDrFloorPlanOriginalDimension";
    export class SkDrFloorPlanOriginalDrawing extends SkDrDrawing {
        body: SkDrFloorPlanOriginalBody;
        dim: SkDrFloorPlanOriginalDimension;
        constructor();
        initFromFloorplanNode(floorplanNode: FloorplanNode): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuDimLayout" {
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    export class SkAuDimLayout {
        hSegments: SkDrDimSegment[];
        vSegments: SkDrDimSegment[];
        hRows: SkDrDimRow[];
        vRows: SkDrDimRow[];
        constructor();
        addSegment(segment: SkDrDimSegment): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuDimRowArrange" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbCircle } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCircle';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    export class SkAuDimRowArrange {
        hRows: SkDrDimRow[];
        vRows: SkDrDimRow[];
        hSegments: SkDrDimSegment[];
        vSegments: SkDrDimSegment[];
        vSegments2: SkDrDimSegment[];
        extents: SkDbExtents;
        outExtents: SkDbExtents;
        offset: number;
        dimExtents: SkDbExtents;
        drDimRow: SkDrDimensionRow;
        needTotalRow: boolean;
        constructor(drDimRow: SkDrDimensionRow);
        addHPoint(pt: Vector2): void;
        addVPoint(pt: Vector2): void;
        addPoint(pt: Vector2): void;
        addSegment(segment: SkDrDimSegment): void;
        addSegments(segments: SkDrDimSegment[]): void;
        addExtendss(exts: SkDbExtents[], normal?: Vector2, splitable?: boolean): void;
        addExtends(ext: SkDbExtents, normal?: Vector2, splitable?: boolean): void;
        addCirclePositons(circles: SkDbCircle[], normal?: Vector2, splitable?: boolean): void;
        addCirclePositon(circle: SkDbCircle, normal?: Vector2, splitable?: boolean): void;
        addEntityExtend(entity: SkDbEntity, normal?: Vector2, splitable?: boolean): void;
        addEntitysExtend(entitys: SkDbEntity[], normal?: Vector2, splitable?: boolean): void;
        addEntitysEachExtend(entitys: SkDbEntity[], normal?: Vector2, splitable?: boolean): void;
        addEntityssExtend(entityss: SkDbEntity[][], normal?: Vector2, splitable?: boolean): void;
        arrange(): void;
        arrangeSegment(): void;
        arrange2(): void;
        colculateRowsAvgValue(rows: SkDrDimRow[]): void;
        colculateRowAvgValue(row: SkDrDimRow): void;
        addTotalDimRow(rows: SkDrDimRow[]): SkDrDimRow[];
        layout(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationHole" {
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class ElevationHoleType extends EnumerationObject {
        static DoorHole: number;
        static WindowHole: number;
        static StructureHole: number;
        static TechnologyHole: number;
    }
    export class SkDrEleElevationHole extends SkDrEle {
        holeType: ElevationHoleType;
        protected static _frame: SkDbExtents;
        name: string;
        constructor();
        preDraw(node: ContentInstanceNode, viewport: SkDrViewport): void;
        initFromNode(node: ContentNode, viewport: SkDrViewport): void;
        drawFrontView(entitys: SkDbEntity[]): void;
        drawTopView(entitys: SkDbEntity[]): void;
        technologyHoleSectin(hole: TechnologyHoleNode, entitys: SkDbEntity[]): void;
        drawDoorSym(center: Vector3, halfw: number, halfh: number, entitys: SkDbEntity[]): void;
        drawWindowSym(center: Vector3, halfw: number, halfh: number, entitys: SkDbEntity[]): void;
        drawDoor(entitys: SkDbEntity[]): void;
        drawWindow(entitys: SkDbEntity[]): void;
        isCircleHole(): {
            center: Vector2;
            r: number;
        };
        isRectHole(): {
            lengthX: number;
            lengthY: number;
            center: Vector3;
        };
        getDimensionStrs(): string[];
        static startFrame(frame: SkDbExtents): void;
        static endFrame(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleStruct" {
    import { Color4 } from 'foundation/runtime/math/Color4';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleStruct extends SkDrObject {
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        worldMatrix: Matrix4;
        entitys: SkDbEntity[];
        isCircle: boolean;
        color: Color4;
        constructor();
        setWorldMatrixFromParentAndLocal(parentMatrix: Matrix4, holeData: HoleStructure): void;
        draw(viewport: SkDrViewport): void;
        drawFrontView(entitys: SkDbEntity[]): void;
        drawBackView(entitys: SkDbEntity[]): void;
        drawLeftView(entitys: SkDbEntity[]): void;
        drawRightView(entitys: SkDbEntity[]): void;
        drawTopView(entitys: SkDbEntity[]): void;
        drawBottomView(entitys: SkDbEntity[]): void;
        getDimensionStrs(): string[];
        getGeomExtents(extt?: SkDbExtents): SkDbExtents;
        isCircleHole(): {
            center: Vector2;
            r: number;
        };
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleStructHole" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { ElevationHoleType } from "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationHole";
    import { SkDrEleStruct } from "sk/data/scheme/drawing/converter/drawer/SkDrEleStruct";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleStructHole extends SkDrEleStruct {
        holeType: ElevationHoleType;
        name: string;
        constructor();
        initFromStructData(parentMatrix: Matrix4, holeName: string, holeData: HoleStructure, viewport: SkDrViewport): void;
        drawTopView(entitys: SkDbEntity[]): void;
        drawDoorSym(center: Vector3, halfw: number, halfh: number, entitys: SkDbEntity[]): void;
        drawWindowSym(center: Vector3, halfw: number, halfh: number, entitys: SkDbEntity[]): void;
        drawDoor(entitys: SkDbEntity[]): void;
        drawWindow(entitys: SkDbEntity[]): void;
        getDimensionStrs(): string[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElevationHole" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { SkDrEleElevationHole } from "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationHole";
    import { SkDrEleStructHole } from "sk/data/scheme/drawing/converter/drawer/SkDrEleStructHole";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElevationHole extends SkDrObject {
        nodeHoles: SkDrEleElevationHole[];
        structHoles: SkDrEleStructHole[];
        constructor();
        draw(viewport: SkDrViewport): void;
        addOpeningNodes(openings: Types<OpeningNode>, viewport: SkDrViewport): void;
        addTechHoleNodes(parentNode: ContentInstanceNode, openingHole: SkDrElevationHole, viewport: SkDrViewport): void;
        addOpeningFromBRWall(bathroomWallNode: BathroomWallNode, viewport: SkDrViewport): void;
        addStructHolets(parentMatrix: Matrix4, holeDatas: Types<{
            name: string;
            hole: HoleStructure;
        }>, viewport: SkDrViewport, isCircleHole?: boolean): void;
        addStructHoles(parentMatrix: Matrix4, holeDatas: {
            name: string;
            hole: HoleStructure;
        }[], viewport: SkDrViewport, isCircleHole?: boolean): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuDimTextCreater" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDbCircle } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbCircle';
    import { SkDbLine } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbLine';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbText } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbText';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrEleElevationHole } from "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationHole";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrEleLeaderMaterial } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeaderMaterial";
    import { SkDrElePlank } from "sk/data/scheme/drawing/converter/drawer/SkDrElePlank";
    import { SkDrEleStruct } from "sk/data/scheme/drawing/converter/drawer/SkDrEleStruct";
    import { SkDrElevationHole } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationHole";
    export class SkAuDimTextCreater {
        node: ContentInstanceNode;
        entity: SkDbEntity;
        upStrs: string[];
        downStrs: string[];
        constructor(entity?: SkDbEntity, upStrs?: string[], downStrs?: string[], node?: ContentInstanceNode);
        static maxExt(entitys: SkDbEntity[]): SkDbExtents;
        static createOnlyTxt(ele: SkDrEle, str: string): SkDbText;
        static createOnlyTxtForElement(element: SkDrEle | SkDrEleStruct): SkDbText[];
        static createOnlyTxtForElements(elements: SkDrEle[] | SkDrEleStruct[]): SkDbText[];
        static create(entitys: SkDbEntity[], upStrs: string[], downStrs: string[], txtHeight: number): {
            drObject: SkDrEleLeader;
            texts: SkDbText[];
        };
        static createFromSmallHoles(elevationHoles: SkDrElevationHole): SkDrEleLeader[];
        static createFromSmallHole(elevationHole: SkDrEleElevationHole): SkDrEleLeader;
        static createFromSmallStructHole(name: string, elevationHole: SkDrEleStruct): SkDrEleLeader;
        private static createFromStructHoles;
        private static filterStructCircleHoles;
        static createFromCircles(circles: Array<SkDbCircle>): SkDrEleLeader[];
        static createFromPolyholes(polyholes: Array<SkDbPolyline>): SkDrEleLeader[];
        private static filterCircle;
        private static filterPolyhole;
        static createFromCircle(circle: SkDbCircle): SkDrEleLeader;
        static createFromPolyline(polyline: SkDbPolyline): SkDrEleLeader;
        static createFromline(line: SkDbLine): SkDrEleLeader;
        static createLeaderMaterial(name: string, targetExt: SkDbExtents, outExt: SkDbExtents): SkDrEleLeaderMaterial;
        static createLeaderMaterialByPt(name: string, targetPoint: Vector2): SkDrEleLeaderMaterial;
        static needSwapMateriaPosition(src: Vector3, other: Vector3, outExt: SkDbExtents, mcolorMap: {}, materialColor: string): boolean;
        static createMaterialLeaderByPlanks(planks: SkDrElePlank[], rowDimExt: SkDbExtents, leaders: SkDrEleLeader[]): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrFrame" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbDatabase } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbDatabase';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrFrame extends SkDrObject {
        name: string;
        date: string;
        author: string;
        frame: string;
        frameEntitys: string;
        contentEntitys: string;
        position: Vector2;
        viewports: SkDrViewport[];
        constructor();
        setPosition(position: Vector2): void;
        getPosition(): Vector2;
        primaryViewport(): SkDrViewport;
        addViewport(observeMatrix?: Matrix4): void;
        static autoFitFrame(contentExt: SkDbExtents): SkDrFrame;
        static createDefaultFrame(): SkDrFrame;
        static createEmptyFrame(db?: SkDbDatabase, observeMatrix?: Matrix4): SkDrFrame;
        static createLeftAndRightFrame(): SkDrFrame;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuLeaderLayout" {
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrFrame } from "sk/data/scheme/drawing/converter/drawer/SkDrFrame";
    export class SkAuLeaderLayout {
        frame: SkDrFrame;
        body: SkDrBody;
        dimRows: SkDrDimRow[];
        leaders: SkDrEleLeader[];
        constructor();
        evaluation(): void;
        search(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuLeaderModify" {
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    export class SkAuLeaderLayout {
        leaderEntity: SkDrEleLeader;
        maxLineLength: number;
        minLineLength: number;
        maxLineAngle: number;
        minLineAngle: number;
        firstLineLength: number;
        firstLineAngle: number;
        score: number;
        constructor();
        evaluation(): void;
        search(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuPlaceArrange" {
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    export class SkAuPlaceArrange {
        dimInsideExtents: SkDbExtents;
        dimPositionExtents: SkDbExtents;
        dimExtents: SkDbExtents;
        constructor();
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkAuRemoveDuplicates" {
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    export class SkAuRemoveDuplicates {
        extents: SkDbExtents;
        leftSegments: SkDrDimSegment[];
        rightSegments: SkDrDimSegment[];
        topSegments: SkDrDimSegment[];
        bottomSegments: SkDrDimSegment[];
        constructor(extents: SkDbExtents);
        pushSegment(segment: SkDrDimSegment): void;
        pushValue(value: number, horizontal: boolean): void;
        pushExtends(ext: SkDbExtents): void;
        createSegments(): SkDrDimSegment[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/DrNodeUtil" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SchemeConfigDecorateInfo } from "sk/data/scheme/config/SchemeConfigDecorateInfo";
    export class DrNodeUtil {
        static searchChildNodeByFieldName(node: DataNode, name: string, value: any, recursive?: boolean, targets?: DataNode[]): DataNode[];
        static setPlankDeocrateName(context: any, node: ContentNode): Promise<void>;
        static setWareDeocrateName(context: any, node: ContentNode): Promise<void>;
        static getPlanksColorName(node: ContainerNode, sourceMap: any): any;
        static getBathroomFloorPlanksColorName(node: BathroomNode): any;
        static getBathroomCeilingPlanksColorName(node: BathroomNode): any;
        static fetchBindingDecorateAsync(context: any, planNode: PlankNode): Promise<void>;
        static fetchWareBindingDecorateAsync(context: any, wareNode: WareNode): Promise<void>;
        static getDecorateByElementAsync(context: any, bindingDecorate: DecorateValueStructure): Promise<SchemeConfigDecorateInfo[]>;
        static searchChildNodeByTypeCode(node: DataNode, typeCode: string, onlyFirst?: boolean, recursive?: boolean, targets?: DataNode[]): DataNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea" {
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrEleBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrEleBathRoomArea";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrBathRoomArea extends SkDrObject {
        areas: SkDrEleBathRoomArea[];
        style: number;
        constructor(style?: number);
        draw(viewport: SkDrViewport): void;
        drawStyle0(viewport: SkDrViewport): void;
        drawStyle1(viewport: SkDrViewport): void;
        drawStyle2(viewport: SkDrViewport): void;
        static createFromAssembleBathroomNode(bathroom: BathroomNode, viewport: SkDrViewport, onlyFinishLine: boolean, style?: number): SkDrBathRoomArea;
        static createFromFloorPlan(floorplan: FloorplanNode): SkDrBathRoomArea;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleBathRoomSubArea" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleBathRoomSubArea extends SkDrEle {
        name: string;
        constructor(name?: string);
        static initFromAreaNode(areaNode: ContentNode, viewport: SkDrViewport): SkDrEleBathRoomSubArea;
        drawTopView(entitys: SkDbEntity[]): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomSubArea" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrEleBathRoomSubArea } from "sk/data/scheme/drawing/converter/drawer/SkDrEleBathRoomSubArea";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrBathRoomSubArea extends SkDrObject {
        areas: SkDrEleBathRoomSubArea[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static createFromAssembleBathroomNode(room: RoomNode, bathroom: BathroomNode, viewport: SkDrViewport): SkDrBathRoomSubArea;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrCeilingPlank" {
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrElePlank } from "sk/data/scheme/drawing/converter/drawer/SkDrElePlank";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrCeilingPlank extends SkDrObject {
        surfacePlanks: SkDrElePlank[];
        basePlanks: SkDrElePlank[];
        refName: string;
        isManufacture: boolean;
        constructor();
        draw(viewport: SkDrViewport): void;
        static createFloorTilePlanks(bathroom: BathroomNode, viewport: SkDrViewport): SkDrCeilingPlank;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDimension" {
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    export class SkDrDimension extends SkDrObject {
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDrawData" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    export class SkDrDrawData {
        lines: {
            startPt: {
                x: number;
                y: number;
            };
            endPt: {
                x: number;
                y: number;
            };
        }[];
        arcs: {
            center: {
                x: number;
                y: number;
            };
            startPt: {
                x: number;
                y: number;
            };
            radius: number;
            startAngle: number;
            endAngle: number;
        }[];
        circles: {
            center: {
                x: number;
                y: number;
            };
            radius: number;
        }[];
        ext: {
            minPt: {
                x: number;
                y: number;
            };
            maxPt: {
                x: number;
                y: number;
            };
        };
        constructor();
        toOrigin(): void;
        createDbObject(lengthX: number, lengthY: number): Array<SkDbEntity>;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDryFloorGap" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDryFloorGap extends SkDrObject {
        begin: Vector3;
        end: Vector3;
        constructor();
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrDryFloorGapSet" {
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrDryFloorGap } from "sk/data/scheme/drawing/converter/drawer/SkDrDryFloorGap";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDryFloorGapSet extends SkDrObject {
        dryFloorGaps: SkDrDryFloorGap[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static createDryFloorGaps(bathroom: BathroomNode, viewport: SkDrViewport): SkDrDryFloorGapSet;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleCeilingComponent" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrCeilingComponent extends SkDrObject {
        ceilingComponents: SkDrEleCeilingComponent[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrCeilingComponent;
    }
    export class SkDrEleCeilingComponent extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleCeilingComponent;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleDoor" {
    import { DoorNode } from "sk/data/scheme/database/floorplan/model/DoorNode";
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleDoor extends SkDrEle {
        door: DoorNode;
        constructor(hole?: DoorNode);
        draw(viewport: SkDrViewport): void;
        drawSingleDoor(viewport: SkDrViewport): void;
        drawDoubleDoor(viewport: SkDrViewport): void;
        getDimensionStrs(): string[];
        getDoorType(): string;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleDrainVerticalBranch" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDrainVerticalBranch extends SkDrObject {
        drainVerticalBranchs: SkDrEleDrainVerticalBranch[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrDrainVerticalBranch;
    }
    export class SkDrEleDrainVerticalBranch extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleDrainVerticalBranch;
        drawTopView(entitys: SkDbEntity[]): void;
        getDimensionStrs(): string[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleDrainBranch" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEleDrainVerticalBranch } from "sk/data/scheme/drawing/converter/drawer/SkDrEleDrainVerticalBranch";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDrainBranch extends SkDrObject {
        drainBranchs: SkDrEleDrainBranch[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrDrainBranch;
    }
    export class SkDrEleDrainBranch extends SkDrEleDrainVerticalBranch {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleDrainBranch;
        drawTopView(entitys: SkDbEntity[]): void;
        getDimensionStrs(): string[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleDrainFloor" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrDrainFloor extends SkDrObject {
        drainFloors: SkDrEleDrainFloor[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrDrainFloor;
    }
    export class SkDrEleDrainFloor extends SkDrEle {
        protected static drawData: any[][];
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleDrainFloor;
        draw(viewport: SkDrViewport): void;
        drawTopView(entitys: SkDbEntity[]): void;
        getDimensionStrs(): string[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationWallBoundSymbol" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleElevationWallBoundSymbol extends SkDrEle {
        position: Vector2;
        constructor();
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationWallTile" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleElevationWallTile extends SkDrObject {
        node: PlankNode;
        outline: SkDbPolyline;
        draw(viewport: SkDrViewport): void;
        getGeomExtents(ext?: SkDbExtents): SkDbExtents;
        static initFromWallTileNode(tile: PlankNode, viewport: SkDrViewport): SkDrEleElevationWallTile;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationWallTileHole" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleElevationWallTileHole extends SkDrObject {
        outline: SkDbPolyline;
        draw(viewport: SkDrViewport): void;
        static initFromBackPlankNode(backPlank: PlankNode, viewport: SkDrViewport): SkDrEleElevationWallTileHole[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleHeating" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrHeating extends SkDrObject {
        heatings: SkDrEleHeating[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrHeating;
    }
    export class SkDrEleHeating extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleHeating;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleHeatingWaterInlet" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrHeatingWaterInlet extends SkDrObject {
        heatingWaterInlets: SkDrEleHeatingWaterInlet[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrHeatingWaterInlet;
    }
    export class SkDrEleHeatingWaterInlet extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleHeatingWaterInlet;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleHeatingWaterOutlet" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrHeatingWaterOutlet extends SkDrObject {
        heatingWaterOutlets: SkDrEleHeatingWaterOutlet[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrHeatingWaterOutlet;
    }
    export class SkDrEleHeatingWaterOutlet extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleHeatingWaterOutlet;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleLEB" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrLEB extends SkDrObject {
        lebs: SkDrEleLEB[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrLEB;
    }
    export class SkDrEleLEB extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleLEB;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/BathroomBaseDesignData" {
    export class BathroomBaseDesignData {
        static DEFAULT_FLOOR_EDGE_THICKNESS: number;
        static DEFAULT_SURFACE_THICKNESS: number;
        static DEFAULT_BASE_HEIGHT: number;
    }
    export class PlankTypeEnum {
        static Tile: string;
        static Iron: string;
        static Stone: string;
    }
    export class PlankTypeCode {
        static wallCode: number;
        static doorCode: number;
        static windowUpCode: number;
        static windowDownCode: number;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/BathroomCreateDesignData" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class BathroomFamilyInfoDesignData {
        floorData: FloorFamilyInfoData;
        wallData: WallFamilyInfoData;
        ceilingData: CeilingFamilyInfoData;
        constructor();
    }
    export class FloorFamilyInfoData {
        floorDryFamilyInfoId: string;
        floorDryFamilyInfo?: any;
        floorWetFamilyInfoId: string;
        floorWetFamilyInfo?: any;
        floorWetSymbolFamilyInfoId: string;
        floorWetSymbolFamilyInfo?: any;
        tileFamilyInfoId: string;
        tileFamilyInfo?: any;
    }
    export class WallFamilyInfoData {
        wallFamilyInfoId: string;
        wallFamilyInfo?: any;
        tileFamilyInfoId: string;
        tileFamilyInfo?: any;
    }
    export class CeilingFamilyInfoData {
        ceilingSymbolFamilyInfoId: string;
        tileceilingSymbolFamilyInfo?: any;
        tileFamilyInfoId: string;
        tileFamilyInfo?: any;
    }
    export class BathroomCreateDesignData {
        ceilingDownHeight: number;
        floorData: FloorCreateDataInfo;
        wallData: WallCreateDataInfo;
        ceilingData: CeilingCreateDataInfo;
        bathroomData: BathroomData;
        static doorCenter: Vector2[];
        outerDoorData: Array<DoorHoleInfo>;
        constructor();
        getHoleCenter(createData: BathroomCreateDesignData): void;
    }
    export class ContentBase {
        name: string;
        type: string;
        x: number;
        y: number;
        lengthX: number;
        lengthY: number;
        rotation: number;
        doorFlag: boolean;
        constructor();
        getPoints(): Array<Vector2>;
    }
    export class BathroomData extends ContentBase {
        z: number;
        height: number;
        floorFnish: number;
        ceilingSpace: number;
        constructor();
        setBathroomData(x: number, y: number, lenghtX: number, lengthY: number): void;
    }
    export class FloorCreateDataInfo {
        lengthZ: number;
        z: number;
        symbolWetPlanks: Array<SymbolWetPlank>;
        wetArea: Array<AreaInfo>;
        dryArea: Array<AreaInfo>;
        waterBar: Array<WaterInterBarLayoutData>;
        baseTthickness: number;
        surfaceThickness: number;
        floorEdgeThickness: number;
        constructor();
    }
    export class SymbolWetPlank extends ContentBase {
        edgeThickness?: number;
        edgeHeight?: number;
        code?: string;
        floorWetPlankPatternInfoId?: string;
        floorWetPlankFamilyInfoId?: string;
        floorWetId?: string;
    }
    export class FloorWetTile extends ContentBase {
        edgeThickness?: number;
        edgeHeight?: number;
        code?: string;
        floorWetTilePatternInfoId?: string;
        floorWetTileFamilyInfoId?: string;
        floorWetId?: string;
    }
    export class AreaLayoutData {
        name: string;
        type: AreaType;
        outline: Array<AreaSingleLine>;
        constructor(name?: string, type?: AreaType, outline?: AreaSingleLine[]);
        setOutline(outline: AreaSingleLine[]): void;
        getPoints(): Array<Vector2>;
    }
    export class AreaInfo extends ContentBase {
        outline: Array<Vector2>;
        constructor();
    }
    export enum WaterInterBarType {
        doorBar = "doorBar",
        dryWetConnectBar = "dryWetConnectBar"
    }
    export class AreaType {
        static wetArea: string;
        static dryArea: string;
        static wallArea: string;
        static ceilingArea: string;
    }
    export class AreaLineType {
        static wetOutline: string;
        static dryOutline: string;
        static WaterInterBar: string;
        static outerWllOutline: string;
        static inerWllOutline: string;
        static ceilingOutline: string;
    }
    export class WaterInletType {
        static showerInlet: string;
        static closestoolInlet: string;
        static basinInlet: string;
    }
    export class WaterInterBarLayoutData extends AreaInfo {
        waterIntertype: WaterInterBarType;
        z: number;
        constructor();
    }
    export class WallCreateDataInfo {
        wallOutlines: Array<WallAreaLine>;
        indoorHoles: Array<WallHoleData>;
        lines: Array<AreaSingleLine>;
        z: number;
        thickness: number;
        height: number;
        baseTthickness: number;
        surfaceThickness: number;
        floorEdgeThickness: number;
        constructor();
    }
    export class WallAreaLine {
        outline: Array<AreaSingleLine>;
        constructor();
    }
    export class AreaSingleLine {
        lineName: string;
        lineType: AreaLineType;
        line: Line2;
        prevLine: AreaSingleLine;
        nextLine: AreaSingleLine;
        hole: Array<WallHoleData>;
        inletWaterHole: Array<WallWaterInletData>;
        constructor();
    }
    export class WallHoleData extends ContentBase {
        holeType: string;
        z: number;
        line: Line2;
        center: Vector2;
        constructor();
    }
    export class WallWaterInletData {
        type: string;
        x: number;
        height: number;
        radius: number;
        space: number;
        constructor();
    }
    export class CeilingCreateDataInfo {
        ceilingSpace: number;
        lengthZ: number;
        area: Array<AreaInfo>;
        z: number;
        baseThickness: number;
        surfaceThickness: number;
        floorEdgeThickness: number;
        arrangeDirection: string;
        constructor();
    }
    export class DoorHoleInfo {
        center: Vector2;
        from: Vector2;
        to: Vector2;
        constructor();
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/BathroomLayoutConvertUtil" {
    import { Bound2 } from 'foundation/runtime/math/Bound2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { BathroomLayoutAreaElement } from 'sk/data/family/element/instance/BathroomLayoutAreaElement';
    import { BathroomLayoutAreaNode } from 'sk/data/family/model/instance/BathroomLayoutAreaNode';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SchemeWorkflowOptions } from "sk/data/scheme/service/SchemeDocumentService";
    export class BathroomLayoutConvertUtil {
        static createAreaContainer(parent: InstanceElement, name: string, code: string): BathroomLayoutAreaElement;
        static getBathroomLayout(room: RoomNode): BathroomLayoutAreaNode;
        static convertPointsRelativeOrigin(points: Array<Vector2>, origin: Vector2): Array<Vector2>;
        static convertSinglePointReleativeOrigin(point: Vector2, origin: Vector2): Vector2;
        static getBound2OfPolygon(points: Vector2[]): Bound2;
        static getCompleteLineNode(room: RoomNode): AreaPolygonNode;
        static createCompleteLinesNode(room: RoomNode): AreaPolygonNode;
        static createCompleteLinesPolygon(room: RoomNode): Array<Vector2>;
        static computeWorkflowVison(element?: BrepElement, options?: SchemeWorkflowOptions): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/BathroomLayoutInfoConvert" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomWallElement } from "sk/data/scheme/database/pattern/element/BathroomWallElement";
    import { BathroomCreateDesignData } from "sk/data/scheme/drawing/converter/drawer/util/BathroomCreateDesignData";
    export class BathroomDesignSetupParams {
        floorFinish: number;
        ceilingSpace: number;
        constructor(floorFinish: number, ceilingSpace: number);
    }
    export class BathroomLayoutInfoConvert {
        private wetAreaNodes;
        private userdefinedAreaNodes;
        private waterBarNodes;
        private wallNodes;
        private showerNodes;
        private closestoolNodes;
        private basinNodes;
        private completeLines;
        private bound2Completelines;
        private bathroomPosition;
        private floorOutlines;
        private wetOutlines;
        private waterBarOutlines;
        private dryOutlines;
        private wallPlaceholderOutlines;
        private room;
        private floorSink;
        private floorFnish;
        private ceilingSpace;
        private tolerance;
        private showerInletOffset;
        private holeRaidus;
        constructor();
        convertLayoutInfoToCreateData(room: RoomNode, params?: BathroomDesignSetupParams): BathroomCreateDesignData;
        getWallHoleDataByBathroomWallElment(wall: BathroomWallElement): Array<{
            name: string;
            hole: HoleStructure;
        }>;
        getPreAndNextWallElement(wall: BathroomWallElement): {
            preWall: BathroomWallElement;
            nextWall: BathroomWallElement;
        };
        private getBathroomWallOutline;
        private getRoomByBathroomWall;
        private getHoleDataFromOutLine;
        private isSameSegment;
        private getCurWallLine;
        private getWallByWallLine;
        private setParms;
        static convertPositionWorldToAssembleBathroom(entity: WareNode): Vector2;
        private findAllAreaNode;
        private createBathroomData;
        private createBathroomDataBylines;
        private getZBySinkHeight;
        private getSinkHeight;
        private getValidSpaceHeight;
        private getCeilingPartHeight;
        private getCeilingParts;
        private getMaxHeightCeilingPart;
        private createFloorData;
        private createWallData;
        private createCeilingData;
        private createDataFromAreaNode;
        private createDataFromUserAreaNode;
        private createWetData;
        private createWaterBarData;
        private createDryData;
        private createAreaDataFromOutlines;
        private createWaterBarDataFromAreaNode;
        private createWaterBarDataFromDoorHole;
        private createWallLinesFromOutline;
        private isInnerLine;
        private createHoleDataFromRoomNode;
        private mapHoleDataToWallLine;
        private storeOutDoorHoleData;
        private adjustHoleDirection;
        private createHoleDataFromWallAreaNode;
        private createShowerInletHole;
        private createToiletInletHole;
        private createBasinInletHole;
        private dealWithInletWaterHoleInfo;
        private createIndoorHoles;
        private createIndoorHolesDataFromDoorNode;
        private getFaucetPartEntity;
        private getInletHorizenPosition;
        private findWallLineWithPartArea;
        private findLinePart;
        private makePointsClockwiseAndLeftUpFirst;
        private swapArrayVector2;
        private segmentInSegment;
        private parraPointToWallLine;
        private getInletOffsetInfoFromPartArea;
        private getInletRadiusInfoFromPartArea;
        private getInletSpacetInfoFromPartArea;
        private getInletHeightInfoFromPartArea;
        private createInletHoleData;
        private getHoleType;
        private createHoleData;
        private getHoleCenterLine;
        private convertLine2ToLocalPosition;
        private getParrallelAreaLines;
        private discardOutofProjectionOfCenterLine;
        private isPointProjectionBetweenSegment;
        private findClosetWallLineFromHole;
        private getPointProjectionToLine;
        private computeSegmentIntersection;
        private checkPointBetweenLine;
        private static getDistancePointToLine;
        private creatDoorHoleTowall;
        private buildDoorLines;
        private findWallLineContainsDoor;
        private setDoorHoleData;
        private filterDoorLines;
        private fixedOutlineDataPresice;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleLevelingWall" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrElePlank } from "sk/data/scheme/drawing/converter/drawer/SkDrElePlank";
    import { SkDrElevationHole } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleLevelingWall extends SkDrEle {
        wallOrderCode: string;
        refName: string;
        surfacePlanks: SkDrElePlank[];
        hole: SkDrElevationHole;
        openingHole: SkDrElevationHole;
        center: Vector3;
        normal: Vector3;
        begin: Vector2;
        end: Vector2;
        constructor();
        initFromNode(node: ContentNode, viewport: SkDrViewport): void;
        draw(viewport: SkDrViewport): void;
        getGeomExtents(extt?: SkDbExtents): SkDbExtents;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleMeasure" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrMeasure extends SkDrEle {
        measures: SkDrEleMeasure[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrMeasure;
    }
    export class SkDrEleMeasure extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleMeasure;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleSecurityAlertor" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrSecurityAlertor extends SkDrObject {
        securityalertors: SkDrEleSecurityAlertor[];
        constructor();
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrSecurityAlertor;
    }
    export class SkDrEleSecurityAlertor extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleSecurityAlertor;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWithDrawData" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDrawData } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawData";
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleWithDrawData extends SkDrEle {
        topData: SkDrDrawData;
        bottomData: SkDrDrawData;
        leftData: SkDrDrawData;
        rightData: SkDrDrawData;
        frontData: SkDrDrawData;
        backData: SkDrDrawData;
        initFromNode(node: ContentNode, viewport: SkDrViewport): void;
        protected setupDrawData(): void;
        protected releaseDrawData(): void;
        drawFrontView(entitys: SkDbEntity[]): void;
        drawBackView(entitys: SkDbEntity[]): void;
        drawLeftView(entitys: SkDbEntity[]): void;
        drawRightView(entitys: SkDbEntity[]): void;
        drawTopView(entitys: SkDbEntity[]): void;
        drawBottomView(entitys: SkDbEntity[]): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleToiletClosestool" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrDrawData } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawData";
    import { SkDrEleWithDrawData } from "sk/data/scheme/drawing/converter/drawer/SkDrEleWithDrawData";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleToiletClosestool extends SkDrEleWithDrawData {
        protected static _topData: SkDrDrawData;
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleToiletClosestool;
        protected setupDrawData(): void;
        protected releaseDrawData(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleToiletPit" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrToiletPit extends SkDrObject {
        toiletPits: SkDrEleToiletPit[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrToiletPit;
    }
    export class SkDrEleToiletPit extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleToiletPit;
        draw(viewport: SkDrViewport): void;
        drawTopView(entitys: SkDbEntity[]): void;
        getDimensionStrs(): string[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElevationPlaceholder" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElevationPlaceholder extends SkDrObject {
        outlines: Vector2[][];
        constructor(node?: ContentInstanceNode);
        draw(viewport: SkDrViewport): void;
        static initPlaceholder(cowall: CowallNode, viewport: SkDrViewport): SkDrElevationPlaceholder;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElevationWallTile" {
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { SkDrEleLevelingWall } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLevelingWall";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElevationWallTile extends SkDrObject {
        refName: string;
        walls: SkDrEleLevelingWall[];
        spreadFlag: boolean;
        bathWallArr: BathroomWallNode[];
        constructor(hole?: OpeningNode);
        draw(viewport: SkDrViewport): void;
        static doseNeedSpread(wallNodes: BathroomWallNode[]): boolean;
        static initFromWallNode(wallNodes: BathroomWallNode[], viewport: SkDrViewport): SkDrElevationWallTile;
        static transformX(wall: SkDrEleLevelingWall, distance: number): void;
        static sortByX(wall1: SkDrEleLevelingWall, wall2: SkDrEleLevelingWall): number;
        sortByX(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElevationFrame" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { SkDrElevationHole } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationHole";
    import { SkDrElevationPlaceholder } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationPlaceholder";
    import { SkDrElevationWallTile } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationWallTile";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElevationFrame extends SkDrObject {
        leftWall: SkDrOriginalWall | SkDrOriginalFlatWall;
        rightWall: SkDrOriginalWall | SkDrOriginalFlatWall;
        ceiling: SkDrOriginalWall;
        floor: SkDrOriginalWall;
        placeholder: SkDrElevationPlaceholder;
        elevatioHole: SkDrElevationHole;
        openingHole: SkDrElevationHole;
        objects: Array<SkDrObject>;
        constructor();
        draw(viewport: SkDrViewport): void;
        getGeomExtents(ext?: SkDbExtents): SkDbExtents;
        getInnerGeomExtents(ext: SkDbExtents): void;
        static initFromRoomAndWallNode(room: RoomNode, walls: BathroomWallNode[], wallTile: SkDrElevationWallTile, viewport: SkDrViewport): SkDrElevationFrame;
        static initCowallNode(cowall: CowallNode, viewport: SkDrViewport): SkDrOriginalWall | SkDrOriginalFlatWall;
        static initFloor(room: RoomNode, leftWall: SkDrOriginalWall | SkDrOriginalFlatWall, rightWall: SkDrOriginalWall | SkDrOriginalFlatWall, viewport: SkDrViewport): SkDrOriginalWall;
        static initCeiling(room: RoomNode, leftWall: SkDrOriginalWall | SkDrOriginalFlatWall, rightWall: SkDrOriginalWall | SkDrOriginalFlatWall, viewport: SkDrViewport): SkDrOriginalWall;
        static initHoles(room: RoomNode, leftWall: SkDrOriginalWall | SkDrOriginalFlatWall, rightWall: SkDrOriginalWall | SkDrOriginalFlatWall): SkDrElevationHole;
        static isPlaceholder(room: RoomNode, node: ContentNode, walls: BathroomWallNode[]): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrElevationFrame } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationFrame";
    import { SkDrElevationUnderstructure } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationUnderstructure";
    import { SkDrElevationWallTile } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationWallTile";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWallTileLayoutElevationBody extends SkDrBody {
        elevationFrame: SkDrElevationFrame;
        wallTile: SkDrElevationWallTile;
        understructure: SkDrElevationUnderstructure;
        constructor(drawing?: SkDrDrawing);
        initFromRoomAndWallNode(room: RoomNode, walls: BathroomWallNode[]): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElevationUnderstructureBolt" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElevationUnderstructureBolt extends SkDrObject {
        position: Vector2;
        height: number;
        diameter: number;
        topNutHeight: number;
        topNutWidth: number;
        bottomNutHeight: number;
        bottomNutWidth: number;
        constructor(pos: Vector2, height: number);
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElevationUnderstructure" {
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { SkDrWallTileLayoutElevationBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody";
    import { SkDrElevationUnderstructureBolt } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationUnderstructureBolt";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElevationUnderstructure extends SkDrObject {
        hole: OpeningNode;
        thickness: number;
        edgeToPlankDis: number;
        edgeHeight: number;
        edgeWidth: number;
        tileExt: SkDbExtents;
        bolts: SkDrElevationUnderstructureBolt[];
        constructor(hole?: OpeningNode);
        draw(viewport: SkDrViewport): void;
        static initFromWallNode(body: SkDrWallTileLayoutElevationBody, viewport: SkDrViewport): SkDrElevationUnderstructure;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrElevationWallBoundSymbol" {
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { SkDrWallTileLayoutElevationBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody";
    import { SkDrEleElevationWallBoundSymbol } from "sk/data/scheme/drawing/converter/drawer/SkDrEleElevationWallBoundSymbol";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrElevationWallBoundSymbol extends SkDrObject {
        boundSymbols: SkDrEleElevationWallBoundSymbol[];
        constructor(hole?: OpeningNode);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrWallTileLayoutElevationBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWallCode" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleWallCode extends SkDrObject {
        wallCode: string;
        position: Vector2;
        constructor();
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWallCodeForRoom" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleWallCodeForRoom extends SkDrObject {
        wallCode: string;
        position: Vector2;
        beginIndex: number;
        suffixNum: number;
        constructor();
        draw(viewport: SkDrViewport): void;
        getIndexCode(index: number): string;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWashCabinet" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrDrawData } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawData";
    import { SkDrEleWithDrawData } from "sk/data/scheme/drawing/converter/drawer/SkDrEleWithDrawData";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleWashCabinet extends SkDrEleWithDrawData {
        protected static _topData: SkDrDrawData;
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleWashCabinet;
        protected setupDrawData(): void;
        protected releaseDrawData(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWaterInlet" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWaterInlet extends SkDrObject {
        waterInlets: SkDrEleWaterInlet[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrWaterInlet;
    }
    export class SkDrEleWaterInlet extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleWaterInlet;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWaterMeter" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWaterMeter extends SkDrObject {
        waterMeters: SkDrEleWaterMeter[];
        constructor();
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrWaterMeter;
    }
    export class SkDrEleWaterMeter extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleWaterMeter;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWaterOutlet" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWaterOutlet extends SkDrObject {
        waterOutlets: SkDrEleWaterOutlet[];
        constructor();
        static initFromNodes(nodes: WareNode[], viewport: SkDrViewport): SkDrWaterOutlet;
    }
    export class SkDrEleWaterOutlet extends SkDrEle {
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleWaterOutlet;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrEleWetShowe" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrDrawData } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawData";
    import { SkDrEleWithDrawData } from "sk/data/scheme/drawing/converter/drawer/SkDrEleWithDrawData";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrEleWetShowe extends SkDrEleWithDrawData {
        protected static _topData: SkDrDrawData;
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrEleWetShowe;
        protected setupDrawData(): void;
        protected releaseDrawData(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFilesFrame" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbBlueprint } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbBlueprint';
    import { SkDbDatabase } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbDatabase';
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrFrame } from "sk/data/scheme/drawing/converter/drawer/SkDrFrame";
    export enum PageSizeEnum {
        A0 = "A0",
        A1 = "A1",
        A2 = "A2",
        A3 = "A3",
        A4 = "A4",
        A5 = "A5"
    }
    export class SkDrFilesFrame extends SkDrFrame {
        pageSize: PageSizeEnum;
        pageScale: number;
        gap: number;
        drawings: SkDrDrawing[];
        constructor(pageSize?: PageSizeEnum, pageScale?: number);
        setupViewportForDrawings(db: SkDbDatabase): void;
        drawFrame(blueprint: SkDbBlueprint): void;
        drawDefaultFrame(blueprint: SkDbBlueprint): void;
        drawFrameSymble(blueprint: SkDbBlueprint): void;
        getPageSize(): {
            sizeX: number;
            sizeY: number;
        };
        static getPageSize(type: PageSizeEnum, scale?: number): {
            sizeX: number;
            sizeY: number;
        };
        setPosition(position: Vector2): void;
        calculateViewportExtents(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrTitlePage" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbBlueprint } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbBlueprint';
    import { PageSizeEnum } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFilesFrame";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    export class SkDrTitlePage extends SkDrObject {
        pageSize: PageSizeEnum;
        pageScale: number;
        blueprint: SkDbBlueprint;
        position: Vector2;
        constructor(pageSize?: PageSizeEnum, pageScale?: number);
        setPosition(position: Vector2): void;
        getPosition(): Vector2;
        verticalArrange(): void;
        holizontalArrange(): void;
        drawTitlePage(blueprint: SkDbBlueprint): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrFiles" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PageSizeEnum, SkDrFilesFrame } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFilesFrame";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrTitlePage } from "sk/data/scheme/drawing/converter/drawer/SkDrTitlePage";
    export class SkDrFiles extends SkDrObject {
        name: string;
        date: string;
        author: string;
        position: Vector2;
        frames: SkDrFilesFrame[];
        titlePage: SkDrTitlePage;
        pageSize: PageSizeEnum;
        pageScale: number;
        constructor();
        setPosition(position: Vector2): void;
        getPosition(): Vector2;
        verticalArrange(): void;
        holizontalArrange(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrFloorTile" {
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrElePlank } from "sk/data/scheme/drawing/converter/drawer/SkDrElePlank";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrFloorTile extends SkDrObject {
        tiles: SkDrElePlank[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static createFloorSurfaceTilePlanks(bathroom: BathroomNode, viewport: SkDrViewport): SkDrFloorTile;
        static createFloorBaseTilePlanks(bathroom: BathroomNode, viewport: SkDrViewport): SkDrFloorTile;
        static createFloorTilePlanks(bathroom: BathroomNode, viewport: SkDrViewport): SkDrFloorTile;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkElePlaneLevelingWall" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { SkDrEleLevelingWall } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLevelingWall";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkElePlaneLevelingWall extends SkDrEleLevelingWall {
        constructor();
        initFromNode(node: ContentNode, viewport: SkDrViewport): void;
        draw(viewport: SkDrViewport): void;
        getGeomExtents(extt?: SkDbExtents): SkDbExtents;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrLevelingWall" {
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrEleLevelingWall } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLevelingWall";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrLevelingWall extends SkDrObject {
        levelingWalls: SkDrEleLevelingWall[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static createLevelingWall(bathroom: BathroomNode, viewport: SkDrViewport): SkDrLevelingWall;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrNewPlan" {
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrOriginalPlan extends SkDrObject {
        walls: WallNode;
        doorHoles: FlatWallNode;
        windowHoles: FlatWallNode;
        limitExtents: SkDbExtents;
        static createSingleRoomPlan(room: RoomNode, offset?: Number): SkDrOriginalPlan;
        static createFloorPlan(floorplan: FloorplanNode): SkDrOriginalPlan;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorConfigurableSecondarySlot" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWetFloorConfigurableSecondarySlot extends SkDrEle {
        outLine: SkDbPolyline;
        constructor();
        static initFromNode(node: WareNode, viewport: SkDrViewport): SkDrWetFloorConfigurableSecondarySlot;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorConfigurableSecondary" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { BathroomFloorWetSlotNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetSlotNode";
    import { SkDrElePlank } from "sk/data/scheme/drawing/converter/drawer/SkDrElePlank";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWetFloorConfigurableSecondarySlot } from "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorConfigurableSecondarySlot";
    export class SkDrWetFloorConfigurableSecondary extends SkDrObject {
        outLine: SkDbPolyline;
        innerOutLine: SkDbPolyline;
        designThickness: number;
        slotDis: Array<number>;
        lcMaterial: string;
        outMaterial: string;
        floorDrain: WareNode;
        slotStones: SkDrWetFloorConfigurableSecondarySlot[];
        tiles: SkDrElePlank[];
        constructor();
        static initFromNode(wetFloorSlot: BathroomFloorWetSlotNode, viewport: SkDrViewport): SkDrWetFloorConfigurableSecondary;
        private static getInnerOutline;
        draw(viewport: SkDrViewport): void;
        private drawText;
        private drawFloorDrain;
        private arrangePts;
        private getDrariCenterPosition;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorConfigurableSecondaryFloorDrain" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { BathroomFloorWetNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWetFloorConfigurableSecondaryFloorDrain extends SkDrObject {
        outLine: SkDbPolyline;
        constructor();
        static initFromNode(wetFloor: BathroomFloorWetNode, viewport: SkDrViewport): SkDrWetFloorConfigurableSecondaryFloorDrain;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorConfigurableSecondaryTile" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { SkDrEle } from "sk/data/scheme/drawing/converter/drawer/SkDrEle";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWetFloorConfigurableSecondaryTile extends SkDrEle {
        outLine: SkDbPolyline;
        constructor();
        static initFromNode(plank: PlankNode, viewport: SkDrViewport): SkDrWetFloorConfigurableSecondaryTile;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorSecondary" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { BathroomFloorWetNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWetFloorSecondary extends SkDrObject {
        outLine: SkDbPolyline;
        startIndex: number;
        innerGap: number;
        innerWidth: number;
        slopeGap: number;
        lcWidth: number;
        lcGap: number;
        floorDrainWidth: number;
        lcMaterial: string;
        outMaterial: string;
        lastLCWidth: number;
        errorInfor: string;
        constructor();
        static initFromNode(wetFloor: BathroomFloorWetNode, wareNode: WareNode, viewport: SkDrViewport): SkDrWetFloorSecondary;
        draw(viewport: SkDrViewport): void;
        private static arrangePts;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorSecondarySet" {
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWetFloorConfigurableSecondary } from "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorConfigurableSecondary";
    import { SkDrWetFloorSecondary } from "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorSecondary";
    export class SkDrWetFloorSecondarySet extends SkDrObject {
        wetFloorSecondarys: SkDrWetFloorSecondary[];
        wetFloorConfigurableSecondarys: SkDrWetFloorConfigurableSecondary[];
        constructor();
        draw(viewport: SkDrViewport): void;
        static createWetFloorSecondarySet(bathroom: BathroomNode, viewport: SkDrViewport): SkDrWetFloorSecondarySet;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/SkFinishOutline" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkFinishOutline extends SkDrObject {
        outline: Array<Vector2>;
        edgeThickness: number;
        constructor();
        static initFromFloorplanNode(room: RoomNode, viewport: SkDrViewport, bathroom?: BathroomNode): SkFinishOutline;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanBody" {
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrBathRoomSubArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomSubArea";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrSet } from "sk/data/scheme/drawing/converter/drawer/SkDrEleSet";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrAreaLayoutPlanBody extends SkDrBody {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        flues: SkDrOriginalFlue;
        area: SkDrBathRoomArea;
        subArea: SkDrBathRoomSubArea;
        ceilingComponent: WareNode;
        waterInlet: WareNode;
        drainBranch: WareNode;
        toiletPit: WareNode;
        leb: WareNode;
        waterMeter: WareNode;
        drainVerticalBranch: WareNode;
        drainFloor: WareNode;
        securityAlertor: WareNode;
        heating: WareNode;
        heatingWaterInlet: WareNode;
        heatingWaterOutlet: WareNode;
        measures: SkDrSet;
        wareSet: SkDrSet;
        constructor(drawing?: SkDrDrawing);
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimensionInside" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrAreaLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanBody";
    export class SkDrAreaLayoutPlanDimensionInside extends SkDrObject {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        hDimRows: SkDrDimRow[];
        vDimRows: SkDrDimRow[];
        dimRows: SkDrDimRow[];
        entitys: SkDbEntity[];
        body: SkDrAreaLayoutPlanBody;
        constructor(body: SkDrAreaLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrAreaLayoutPlanBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimensionRow" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrAreaLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanBody";
    export class SkDrAreaLayoutPlanDimensionRow extends SkDrDimensionRow {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        leaders: SkDrEleLeader[];
        entitys: SkDbEntity[];
        body: SkDrAreaLayoutPlanBody;
        constructor(body: SkDrAreaLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, drArea: SkDrBathRoomArea, offset?: number): SkDrAreaLayoutPlanDimensionRow;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimensionText" {
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrAreaLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanBody";
    import { SkDrAreaLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimensionRow";
    export class SkDrAreaLayoutPlanDimensionText extends SkDrDimensionText {
        body: SkDrAreaLayoutPlanBody;
        dimRow: SkDrAreaLayoutPlanDimensionRow;
        constructor(body: SkDrAreaLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        init(body: SkDrAreaLayoutPlanBody, dimRow: SkDrAreaLayoutPlanDimensionRow): void;
        fetchInfo(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimension" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrAreaLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanBody";
    import { SkDrAreaLayoutPlanDimensionInside } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimensionInside";
    import { SkDrAreaLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimensionRow";
    import { SkDrAreaLayoutPlanDimensionText } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimensionText";
    export class SkDrAreaLayoutPlanDimension extends SkDrObject {
        body: SkDrAreaLayoutPlanBody;
        dimRow: SkDrAreaLayoutPlanDimensionRow;
        dimInside: SkDrAreaLayoutPlanDimensionInside;
        dimText: SkDrAreaLayoutPlanDimensionText;
        constructor(body: SkDrAreaLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, drArea: SkDrBathRoomArea, offset?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrBathroomWallNumAnalysis" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    class BathroomSpace {
        walls: Array<BathroomWallNode>;
        tWalls: Array<BathroomWallNode>;
        rWalls: Array<BathroomWallNode>;
        bWalls: Array<BathroomWallNode>;
        lWalls: Array<BathroomWallNode>;
        startDir: Vector2;
        startNormal: Vector2;
        num: number;
        constructor();
        getNumberNameByIndex(index: number): string;
        getWallsByNumberName(name: string): Array<BathroomWallNode>;
        compute(): void;
        getWalls(dir: Vector2): Array<BathroomWallNode>;
        sortLines(outline: Array<Vector2>): Array<Array<Line2>>;
        private arrayLinesSort;
        isOverlaped(outline: Array<Vector2>, start: Vector2, end: Vector2): boolean;
    }
    export class SkDrBathroomWallNumAnalysis {
        room: RoomNode;
        bathroom: BathroomNode;
        spaces: Array<BathroomSpace>;
        constructor(room: RoomNode, bathroomNode: BathroomNode);
        setSpaces(room: RoomNode, bathroomNode: BathroomNode): void;
        getDoorIndex(room: RoomNode, space: BathroomSpace): number;
        getStartWallDirection(room: RoomNode, space: BathroomSpace): Vector2;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanBody" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrCeilingPlank } from "sk/data/scheme/drawing/converter/drawer/SkDrCeilingPlank";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrSet } from "sk/data/scheme/drawing/converter/drawer/SkDrEleSet";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkFinishOutline } from "sk/data/scheme/drawing/converter/drawer/SkFinishOutline";
    export class SkDrCeilingLayoutPlanBody extends SkDrBody {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        flues: SkDrOriginalFlue;
        ceilingPlank: SkDrCeilingPlank;
        area: SkDrBathRoomArea;
        wareSet: SkDrSet;
        isManufacture: boolean;
        finishLines: SkFinishOutline;
        constructor(drawing?: SkDrDrawing);
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimensionInside" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrCeilingLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanBody";
    export class SkDrCeilingLayoutPlanDimensionInside extends SkDrObject {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        hDimRows: SkDrDimRow[];
        vDimRows: SkDrDimRow[];
        dimRows: SkDrDimRow[];
        entitys: SkDbEntity[];
        body: SkDrCeilingLayoutPlanBody;
        isManufacture: boolean;
        constructor(body: SkDrCeilingLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrCeilingLayoutPlanBody): void;
        initHoleDimForDesign(body: SkDrCeilingLayoutPlanBody): void;
        initHoleDimForManufacture(body: SkDrCeilingLayoutPlanBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimensionRow" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrCeilingLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanBody";
    export class SkDrCeilingLayoutPlanDimensionRow extends SkDrDimensionRow {
        body: SkDrCeilingLayoutPlanBody;
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        leaders: SkDrEleLeader[];
        entitys: SkDbEntity[];
        constructor(body: SkDrCeilingLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, body: SkDrCeilingLayoutPlanBody, offset?: number): SkDrCeilingLayoutPlanDimensionRow;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimensionText" {
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrCeilingLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanBody";
    import { SkDrCeilingLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimensionRow";
    export class SkDrCeilingLayoutPlanDimensionText extends SkDrDimensionText {
        body: SkDrCeilingLayoutPlanBody;
        dimRow: SkDrCeilingLayoutPlanDimensionRow;
        constructor(body: SkDrCeilingLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        init(body: SkDrCeilingLayoutPlanBody, dimRow: SkDrCeilingLayoutPlanDimensionRow): void;
        fetchInfo(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimension" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrCeilingLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanBody";
    import { SkDrCeilingLayoutPlanDimensionInside } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimensionInside";
    import { SkDrCeilingLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimensionRow";
    import { SkDrCeilingLayoutPlanDimensionText } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimensionText";
    export class SkDrCeilingLayoutPlanDimension extends SkDrObject {
        body: SkDrCeilingLayoutPlanBody;
        dimRow: SkDrCeilingLayoutPlanDimensionRow;
        dimInside: SkDrCeilingLayoutPlanDimensionInside;
        dimText: SkDrCeilingLayoutPlanDimensionText;
        constructor(body: SkDrCeilingLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, offset?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingAreaLayoutPlan" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrAreaLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanBody";
    import { SkDrAreaLayoutPlanDimension } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrAreaLayoutPlanDimension";
    export class SkDrDrawingAreaLayoutPlan extends SkDrDrawing {
        body: SkDrAreaLayoutPlanBody;
        dim: SkDrAreaLayoutPlanDimension;
        constructor();
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingCeilingLayoutPlan" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrCeilingLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanBody";
    import { SkDrCeilingLayoutPlanDimension } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrCeilingLayoutPlanDimension";
    export class SkDrDrawingCeilingLayoutPlan extends SkDrDrawing {
        body: SkDrCeilingLayoutPlanBody;
        dim: SkDrCeilingLayoutPlanDimension;
        isManufacture: boolean;
        constructor();
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
        setManufacture(isManufacture: boolean): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanBody" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrDryFloorGapSet } from "sk/data/scheme/drawing/converter/drawer/SkDrDryFloorGapSet";
    import { SkDrSet } from "sk/data/scheme/drawing/converter/drawer/SkDrEleSet";
    import { SkDrFloorTile } from "sk/data/scheme/drawing/converter/drawer/SkDrFloorTile";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWetFloorSecondarySet } from "sk/data/scheme/drawing/converter/drawer/SkDrWetFloorSecondarySet";
    import { SkFinishOutline } from "sk/data/scheme/drawing/converter/drawer/SkFinishOutline";
    export class SkDrFloorTileLayoutPlanBody extends SkDrBody {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        flues: SkDrOriginalFlue;
        area: SkDrBathRoomArea;
        tile: SkDrFloorTile;
        surfaceTiles: SkDrFloorTile;
        baseTiles: SkDrFloorTile;
        dryFloorGaps: SkDrDryFloorGapSet;
        wetFloorSecondarySet: SkDrWetFloorSecondarySet;
        measures: SkDrSet;
        wareSet: SkDrSet;
        finishLines: SkFinishOutline;
        constructor(drawing?: SkDrDrawing);
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimensionInside" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorTileLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanBody";
    export class SkDrFloorTileLayoutPlanDimensionInside extends SkDrObject {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        hDimRows: SkDrDimRow[];
        vDimRows: SkDrDimRow[];
        dimRows: SkDrDimRow[];
        entitys: SkDbEntity[];
        body: SkDrFloorTileLayoutPlanBody;
        isManufacture: boolean;
        constructor(body: SkDrFloorTileLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrFloorTileLayoutPlanBody): void;
        initHoleDimForDesign(body: SkDrFloorTileLayoutPlanBody): void;
        initHoleDimForManufacture(body: SkDrFloorTileLayoutPlanBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimensionRow" {
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorTileLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanBody";
    export class SkDrFloorTileLayoutPlanDimensionRow extends SkDrDimensionRow {
        body: SkDrFloorTileLayoutPlanBody;
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        leaders: SkDrEleLeader[];
        entitys: SkDbEntity[];
        constructor(body: SkDrFloorTileLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, body: SkDrFloorTileLayoutPlanBody, offset?: number): SkDrFloorTileLayoutPlanDimensionRow;
        createFromPolyline(poly: SkDbPolyline, ext: SkDbExtents, splitable?: boolean): SkDrDimSegment[];
        private getProjectDir;
        private isInArea;
        private getAreaIndex;
        removeDuplicateSegments(ext: SkDbExtents, segments: SkDrDimSegment[]): SkDrDimSegment[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimensionText" {
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorTileLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanBody";
    import { SkDrFloorTileLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimensionRow";
    export class SkDrFloorTileLayoutPlanDimensionText extends SkDrDimensionText {
        body: SkDrFloorTileLayoutPlanBody;
        dimRow: SkDrFloorTileLayoutPlanDimensionRow;
        constructor(body: SkDrFloorTileLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        init(body: SkDrFloorTileLayoutPlanBody, dimRow: SkDrFloorTileLayoutPlanDimensionRow): void;
        fetchInfo(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimension" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorTileLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanBody";
    import { SkDrFloorTileLayoutPlanDimensionInside } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimensionInside";
    import { SkDrFloorTileLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimensionRow";
    import { SkDrFloorTileLayoutPlanDimensionText } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimensionText";
    export class SkDrFloorTileLayoutPlanDimension extends SkDrObject {
        body: SkDrFloorTileLayoutPlanBody;
        dimRow: SkDrFloorTileLayoutPlanDimensionRow;
        dimInside: SkDrFloorTileLayoutPlanDimensionInside;
        dimText: SkDrFloorTileLayoutPlanDimensionText;
        constructor(body: SkDrFloorTileLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, offset?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingFloorTileLayoutPlan" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrFloorTileLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanBody";
    import { SkDrFloorTileLayoutPlanDimension } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFloorTileLayoutPlanDimension";
    export class SkDrDrawingFloorTileLayoutPlan extends SkDrDrawing {
        body: SkDrFloorTileLayoutPlanBody;
        dim: SkDrFloorTileLayoutPlanDimension;
        constructor();
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/util/BathroomFloorPlanUtil" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { WallAreaLine } from "sk/data/scheme/drawing/converter/drawer/util/BathroomCreateDesignData";
    export class BathroomFloorPlanUtil {
        static getRoomHeight(room: RoomNode): number;
        static getDoorIndex(room: RoomNode, wallOutline: WallAreaLine): number;
        static getFirstSurfaceWithDoor(room: RoomNode): WallSurfaceNode;
        static getFirstSurfaceWithDoorIndex(room: RoomNode): number;
        static getValidSpaceHeight(room: RoomNode): number;
        private static getCeilingPartHeight;
        private static getCeilingParts;
        private static getMaxHeightCeilingPart;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanBody" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrSet } from "sk/data/scheme/drawing/converter/drawer/SkDrEleSet";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrOriginalPlanBody extends SkDrBody {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        flues: SkDrOriginalFlue;
        wareSet: SkDrSet;
        floorZ: number;
        roomOutline: Vector2[];
        roomHeight: number;
        validSpaceHeight: number;
        constructor(drawing?: SkDrDrawing);
        initFromSingleRoomNode(node: RoomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimensionInside" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrOriginalPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanBody";
    export class SkDrOriginalPlanDimensionInside extends SkDrObject {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        hDimRows: SkDrDimRow[];
        vDimRows: SkDrDimRow[];
        dimRows: SkDrDimRow[];
        entitys: SkDbEntity[];
        body: SkDrOriginalPlanBody;
        constructor(body: SkDrOriginalPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrOriginalPlanBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimensionRow" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrOriginalPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanBody";
    export class SkDrOriginalPlanDimensionRow extends SkDrDimensionRow {
        body: SkDrOriginalPlanBody;
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        constructor(body: SkDrOriginalPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan__(room: RoomNode, offset?: number): SkDrOriginalPlanDimensionRow;
        initFromSingleRoomPlan(room: RoomNode, offset?: number): SkDrOriginalPlanDimensionRow;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimensionText" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrOriginalPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanBody";
    import { SkDrOriginalPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimensionRow";
    export class SkDrOriginalPlanDimensionText extends SkDrDimensionText {
        body: SkDrOriginalPlanBody;
        dimRow: SkDrOriginalPlanDimensionRow;
        constructor(body: SkDrOriginalPlanBody);
        draw(viewport: SkDrViewport): void;
        init(body: SkDrOriginalPlanBody, dimRow: SkDrOriginalPlanDimensionRow): void;
        fetchInfo(): void;
        protected getRoomCenter(outline: Vector2[]): Vector3;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimension" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrOriginalPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanBody";
    import { SkDrOriginalPlanDimensionInside } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimensionInside";
    import { SkDrOriginalPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimensionRow";
    import { SkDrOriginalPlanDimensionText } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimensionText";
    export class SkDrOriginalPlanDimension extends SkDrObject {
        body: SkDrOriginalPlanBody;
        dimRow: SkDrOriginalPlanDimensionRow;
        dimInside: SkDrOriginalPlanDimensionInside;
        dimText: SkDrOriginalPlanDimensionText;
        constructor(body: SkDrOriginalPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, offset?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingOriginalPlan" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrOriginalPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanBody";
    import { SkDrOriginalPlanDimension } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrOriginalPlanDimension";
    export class SkDrDrawingOriginalPlan extends SkDrDrawing {
        body: SkDrOriginalPlanBody;
        dim: SkDrOriginalPlanDimension;
        constructor();
        initFromSingleRoomNode(node: RoomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanBody" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrLevelingWall } from "sk/data/scheme/drawing/converter/drawer/SkDrLevelingWall";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkFinishOutline } from "sk/data/scheme/drawing/converter/drawer/SkFinishOutline";
    export class SkDrWallLayoutPlanBody extends SkDrBody {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        flues: SkDrOriginalFlue;
        area: SkDrBathRoomArea;
        levelingWall: SkDrLevelingWall;
        finishLines: SkFinishOutline;
        constructor(drawing?: SkDrDrawing);
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanDimensionRow" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrEleLevelingWall } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLevelingWall";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanBody";
    export class SkDrWallLayoutPlanDimensionRow extends SkDrDimensionRow {
        body: SkDrWallLayoutPlanBody;
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        leaders: SkDrEleLeader[];
        entitys: SkDbEntity[];
        constructor(body: SkDrWallLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, body: SkDrWallLayoutPlanBody, offset?: number): SkDrWallLayoutPlanDimensionRow;
        setNoNearBahthroomOutlineSegemenet(levelingWall: SkDrEleLevelingWall): void;
        reviseAreaSegments(areaSegments: Array<SkDrDimSegment>, tol?: number): Array<SkDrDimSegment>;
        isNearBahthroomOutlineSegemenet(wall: SkDrEleLevelingWall, outlines: Array<Line2>): boolean;
        isIncludeInnerLine(wall: SkDrEleLevelingWall, outline: Array<Vector2>): boolean;
        getOutLines(outline: Array<Vector2>): Array<Line2>;
        isOverlaped(outline: Array<Vector2>, start: Vector2, end: Vector2): boolean;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanDimensionText" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrWallLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanBody";
    import { SkDrWallLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanDimensionRow";
    import { FloorCreateDataInfo, WallAreaLine } from "sk/data/scheme/drawing/converter/drawer/util/BathroomCreateDesignData";
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrEleWallCodeForRoom } from "sk/data/scheme/drawing/converter/drawer/SkDrEleWallCodeForRoom";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    export class SkDrWallLayoutPlanDimensionText extends SkDrDimensionText {
        body: SkDrWallLayoutPlanBody;
        dimRow: SkDrWallLayoutPlanDimensionRow;
        codeBlocks: Types<SkDrEleWallCodeForRoom>;
        constructor(body: SkDrWallLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        init(room: RoomNode, body: SkDrWallLayoutPlanBody, dimRow: SkDrWallLayoutPlanDimensionRow): void;
        private getCodeBlocksInfo;
        getAreaOutlinePoints(wallOutline: WallAreaLine, floorData: FloorCreateDataInfo): Array<Vector2>;
        private getBathRoomTransForm;
        private getBlockPosition;
        private isBlockIn;
        fetchInfo(): void;
        fetchInfo__(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanDimension" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanBody";
    import { SkDrWallLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanDimensionRow";
    import { SkDrWallLayoutPlanDimensionText } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanDimensionText";
    export class SkDrWallLayoutPlanDimension extends SkDrObject {
        body: SkDrWallLayoutPlanBody;
        dimRow: SkDrWallLayoutPlanDimensionRow;
        dimText: SkDrWallLayoutPlanDimensionText;
        constructor(body: SkDrWallLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, offset?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWallLayoutPlan" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanBody";
    import { SkDrWallLayoutPlanDimension } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallLayoutPlanDimension";
    export class SkDrDrawingWallLayoutPlan extends SkDrDrawing {
        body: SkDrWallLayoutPlanBody;
        dim: SkDrWallLayoutPlanDimension;
        constructor();
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimensionInside" {
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDrDimRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimRow";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallTileLayoutElevationBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody";
    export class SkDrWallTileLayoutElevationDimensionInside extends SkDrObject {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        hDimRows: SkDrDimRow[];
        vDimRows: SkDrDimRow[];
        dimRows: SkDrDimRow[];
        entitys: SkDbEntity[];
        body: SkDrWallTileLayoutElevationBody;
        isManufacture: boolean;
        constructor(body: SkDrWallTileLayoutElevationBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrWallTileLayoutElevationBody): void;
        initFromBody_(body: SkDrWallTileLayoutElevationBody): void;
        initHoleDimForDesign(body: SkDrWallTileLayoutElevationBody): void;
        private initHoleUpDownDim;
        initHoleDimForManufacture(body: SkDrWallTileLayoutElevationBody): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimensionRow" {
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallTileLayoutElevationBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody";
    export class SkDrWallTileLayoutElevationDimensionRow extends SkDrDimensionRow {
        body: SkDrWallTileLayoutElevationBody;
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        constructor(body: SkDrWallTileLayoutElevationBody);
        draw(viewport: SkDrViewport): void;
        initFromBody(body: SkDrWallTileLayoutElevationBody): SkDrWallTileLayoutElevationDimensionRow;
        private isHoleUpDownPlank;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimensionText" {
    import { SkDrWallTileLayoutElevationDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimensionRow";
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallTileLayoutElevationBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody";
    export class SkDrWallTileLayoutElevationDimensionText extends SkDrDimensionText {
        body: SkDrWallTileLayoutElevationBody;
        dimRow: SkDrWallTileLayoutElevationDimensionRow;
        constructor(body: SkDrWallTileLayoutElevationBody);
        draw(viewport: SkDrViewport): void;
        init(body: SkDrWallTileLayoutElevationBody, dimRow: SkDrWallTileLayoutElevationDimensionRow): void;
        getNotes(): string[];
        fetchInfo(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimension" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrElevationWallBoundSymbol } from "sk/data/scheme/drawing/converter/drawer/SkDrElevationWallBoundSymbol";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallTileLayoutElevationBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody";
    import { SkDrWallTileLayoutElevationDimensionInside } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimensionInside";
    import { SkDrWallTileLayoutElevationDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimensionRow";
    import { SkDrWallTileLayoutElevationDimensionText } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimensionText";
    export class SkDrWallTileLayoutElevationDimension extends SkDrObject {
        body: SkDrWallTileLayoutElevationBody;
        dimRow: SkDrWallTileLayoutElevationDimensionRow;
        dimInside: SkDrWallTileLayoutElevationDimensionInside;
        dimText: SkDrWallTileLayoutElevationDimensionText;
        boundSymbol: SkDrElevationWallBoundSymbol;
        constructor(body: SkDrWallTileLayoutElevationBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, offset?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWallTileLayoutElevation" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWallTileLayoutElevationBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationBody";
    import { SkDrWallTileLayoutElevationDimension } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWallTileLayoutElevationDimension";
    export class SkDrDrawingWallTileLayoutElevation extends SkDrDrawing {
        body: SkDrWallTileLayoutElevationBody;
        dim: SkDrWallTileLayoutElevationDimension;
        isManufacture: boolean;
        constructor();
        initFromRoomAndWallNodes(room: RoomNode, walls: BathroomWallNode[]): void;
        initViewportFromWallNode(wall: BathroomWallNode): void;
        draw(viewport: SkDrViewport): void;
        setManufacture(isManufacture: boolean): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWallTileLayoutElevationEx" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { SkDrDrawingWallTileLayoutElevation } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWallTileLayoutElevation";
    export class SkDrDrawingWallTileLayoutElevationEx extends SkDrDrawingWallTileLayoutElevation {
        constructor();
        initFromRoomAndWallNode(room: RoomNode, bathroomNode: BathroomNode, bathroomWallNode: BathroomWallNode): void;
        initViewportFromWallNode(node: BathroomWallNode): void;
        initFromRoomAndSurfaceIndex(room: RoomNode, wallNodes: Array<BathroomWallNode>, index: number, drawingNum?: number): void;
        initDrawingName(index: number, drawingNum?: number): void;
        getWallIndex(wall: BathroomWallNode): number;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanBody" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrBathRoomSubArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomSubArea";
    import { SkDrBody } from "sk/data/scheme/drawing/converter/drawer/SkDrBody";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrSet } from "sk/data/scheme/drawing/converter/drawer/SkDrEleSet";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalFlue } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlue";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkFinishOutline } from "sk/data/scheme/drawing/converter/drawer/SkFinishOutline";
    export class SkDrWareLayoutPlanBody extends SkDrBody {
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        flues: SkDrOriginalFlue;
        area: SkDrBathRoomArea;
        subArea: SkDrBathRoomSubArea;
        wareSet: SkDrSet;
        finishLines: SkFinishOutline;
        constructor(drawing?: SkDrDrawing);
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanDimensionRow" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SkDbPolyline } from 'sk/data/family/drawing/skdbdatabase/dbobject/curve/SkDbPolyline';
    import { SkDbEntity } from 'sk/data/family/drawing/skdbdatabase/dbobject/SkDbEntity';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkAuDimRowArrange } from "sk/data/scheme/drawing/converter/drawer/SkAuDimRowArrange";
    import { SkDrBathRoomArea } from "sk/data/scheme/drawing/converter/drawer/SkDrBathRoomArea";
    import { SkDrDimensionRow } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionRow";
    import { SkDrDimSegment } from "sk/data/scheme/drawing/converter/drawer/SkDrDimSegment";
    import { SkDrEleBathRoomSubArea } from "sk/data/scheme/drawing/converter/drawer/SkDrEleBathRoomSubArea";
    import { SkDrEleLeader } from "sk/data/scheme/drawing/converter/drawer/SkDrEleLeader";
    import { SkDrOriginalFlatWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWall";
    import { SkDrOriginalFlatWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalFlatWallHole";
    import { SkDrOriginalWall } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWall";
    import { SkDrOriginalWallHole } from "sk/data/scheme/drawing/converter/drawer/SkDrOriginalWallHole";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWareLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanBody";
    export class SkDrWareLayoutPlanDimensionRow extends SkDrDimensionRow {
        body: SkDrWareLayoutPlanBody;
        wall: SkDrOriginalWall;
        flatWall: SkDrOriginalFlatWall;
        wallHole: SkDrOriginalWallHole;
        flatWallHole: SkDrOriginalFlatWallHole;
        leaders: SkDrEleLeader[];
        entitys: SkDbEntity[];
        constructor(body: SkDrWareLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, drArea: SkDrBathRoomArea, offset?: number): SkDrWareLayoutPlanDimensionRow;
        createFromPolyline(poly: SkDbPolyline, ext: SkDbExtents, splitable?: boolean): SkDrDimSegment[];
        setNearBahthroomOutlineSegemenet(subArea: SkDrEleBathRoomSubArea, dimRowArrange: SkAuDimRowArrange, segmentedLines: any): Array<any>;
        setNoNearBahthroomOutlineSegemenet(subArea: SkDrEleBathRoomSubArea, segmented: Array<Array<Vector2>>): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanDimensionText" {
    import { SkDrDimensionText } from "sk/data/scheme/drawing/converter/drawer/SkDrDimensionText";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWareLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanBody";
    import { SkDrWareLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanDimensionRow";
    export class SkDrWareLayoutPlanDimensionText extends SkDrDimensionText {
        body: SkDrWareLayoutPlanBody;
        dimRow: SkDrWareLayoutPlanDimensionRow;
        constructor(body: SkDrWareLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        init(body: SkDrWareLayoutPlanBody, dimRow: SkDrWareLayoutPlanDimensionRow): void;
        fetchInfo(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanDimension" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { SkDrObject } from "sk/data/scheme/drawing/converter/drawer/SkDrObject";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWareLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanBody";
    import { SkDrWareLayoutPlanDimensionRow } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanDimensionRow";
    import { SkDrWareLayoutPlanDimensionText } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanDimensionText";
    export class SkDrWareLayoutPlanDimension extends SkDrObject {
        body: SkDrWareLayoutPlanBody;
        dimRow: SkDrWareLayoutPlanDimensionRow;
        dimText: SkDrWareLayoutPlanDimensionText;
        constructor(body: SkDrWareLayoutPlanBody);
        draw(viewport: SkDrViewport): void;
        initFromSingleRoomPlan(room: RoomNode, offset?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWareLayoutPlan" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { SkDrViewport } from "sk/data/scheme/drawing/converter/drawer/SkDrViewport";
    import { SkDrWareLayoutPlanBody } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanBody";
    import { SkDrWareLayoutPlanDimension } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrWareLayoutPlanDimension";
    export class SkDrDrawingWareLayoutPlan extends SkDrDrawing {
        body: SkDrWareLayoutPlanBody;
        dim: SkDrWareLayoutPlanDimension;
        constructor();
        initFromSingleRoomNode(node: RoomNode, bathroom: BathroomNode, offset?: number): void;
        draw(viewport: SkDrViewport): void;
    }
}
declare module "sk/data/scheme/drawing/data/DrawingNodeStyle" {
    export type DrawingUnitBathroomStyleInfo = {
        colorDark: string;
        wetPlateColor: string;
        dryPlateColor: string;
        familyColorLight: string;
        familyColorDark: string;
        familyNameColor: string;
        familyNameTextH: number;
        dimColor: string;
        dimTextH: number;
        dimBorderLength: number;
        plankColor: string;
        plankColorDark: string;
        tileColor: string;
        holeColor: string;
        groupCodeColor: string;
        groupCodeTextH: number;
        groupCodeSpace: number;
        groupSpace: number;
        outDimSpace: number;
        wallSurfaceLineColor: string;
    };
}
declare module "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { Fill2dDrawingNode } from 'sk/data/family/model/brep/drawing/Fill2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { AssembleRoomNode } from "sk/data/scheme/database/pattern/node/AssembleRoomNode";
    import { DecorateLayerNode } from "sk/data/scheme/database/pattern/node/DecorateLayerNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { BaseDrawingConverter, WallSurfaceLineAndPath } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    export type ComputeNearestPointResult = {
        p: Vector2;
        b: Vector2;
        i: number;
    };
    export enum LevelingDrawingContentEnum {
        wallsCompleteLinesGeos = 0,
        wallCompletePoitns = 1
    }
    export type WallCompleteInfo = {
        completeInnerLine: Line2;
        completePoints: Vector2[];
    };
    export type WallBaseInfo = {
        baseOuterLine: Line2;
        basePoints: Vector2[];
    };
    export class BaseFinishLineDrawingConverter extends BaseDrawingConverter {
        protected graphicFormMap: Map<BrepNode[], string>;
        protected keelsMap: Map<string, string>;
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        protected wallsFilterInvalid(walls: WallNode[]): WallNode[];
        protected cowallsFilterInvalid(cowalls: CowallNode[]): CowallNode[];
        protected findAssembelRoomByAssembelWall(wallnode: ContentNode): ContentNode;
        protected fetchFloorplanAllWalls(floorplan: FloorplanNode): DataNode[];
        protected isInRoom(room: RoomNode, instance: ContentNode, checkBox?: boolean, includeRoomOutline?: boolean): boolean;
        protected checkPointsInRoomFlatWalls(room: RoomNode, points: Vector2[], includeedge: boolean): boolean;
        protected checkPointsInRoomCowalls(room: RoomNode, points: Vector2[], includeedge: boolean): boolean;
        protected checkPointsInPolygon(points: Vector2[], polygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        protected checkPolygonsIntersection(polygon: Vector2[], otherpolygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        protected checkCurveLinecurve(curve2d: Curve2d, tolerance?: number): boolean;
        protected checksectionSurfaceIntersectSectionSurface(section: SectionSurface, othersection: SectionSurface): boolean;
        protected findRoomContents(room: RoomNode, excludearray?: Array<Function>, onlyincludearray?: Array<Function>): FamilyInstanceNode[];
        protected findAssembledRooms(floorplan: FloorplanNode): ContentNode[];
        protected findAssembledRoomByRoomNode(room: RoomNode): AssembleRoomNode;
        protected _room: RoomNode;
        protected getLevelWalls(assembledRoom: ContentNode): ContentNode[];
        protected getMarkPoints(floorNode: BrepNode): ContentNode[];
        protected getLevelBeams(assembledRoom: ContentNode): ContentNode[];
        protected findBeam(node: ContentNode): ContentNode;
        protected drawDynamicRoom(roomdynamicware: ContentNode, drawcontext?: DrawingNodeContext): void;
        protected findCowallFromDynamicwall(node: DynamicWareNode): CowallNode;
        protected findRoomFromAssembledRoom(node: ContentNode): RoomNode;
        protected computeNodeStartDirection(node: BrepNode): Vector2;
        protected buildFloorplanDimensions(node: BrepNode, style?: any): void;
        protected computeAssemledBoundary(node: BrepNode, box?: Box2): Box2;
        protected createBeamsInfos(instances: FamilyInstanceNode[], pos?: Vector2, textHeight?: number): void;
        protected drawWallsCavityAndDims(walls: DynamicWareNode[], style?: any, drawingLevel?: number): void;
        protected drawWallCavityAndDims(wall: ContentNode, planks: ContentNode[], style?: any, drawingLevel?: number): void;
        protected drawForm(): void;
        private drawTextForm;
        private drawGraphicForm;
        protected drawKeelText(textpos: Vector2, rotationZ: number, keel: ContentInstanceNode, needserialNumber: boolean, needProcessNumber: boolean, keeltypecodedict: Map<string, string>, replacetypecodearray: Array<string>, keepmaptext?: Map<string, string>, style?: any, drawingLevel?: number): BrepNode;
        protected createKeelText(textpos: Vector2, rotationZ: number, keel: ContentInstanceNode, needserialNumber: boolean, needProcessNumber: boolean, keeltypecodedict: Map<string, string>, replacetypecodearray: Array<string>, keepmaptext?: Map<string, string>, style?: any, drawingLevel?: number): BrepNode;
        protected computeKeelMapText(keel: ContentInstanceNode, code: string, textmap: Map<string, string>): void;
        protected computeKeelCode(keel: ContentInstanceNode, typedict: Map<string, string>, replacetypecodearray: Array<string>): string;
        protected drawFlatWall(flatwall: FlatWallNode): BrepNode[];
        protected drawingWallLines(document: DrawingDataDocument, cowalls: CowallNode[], workInstance?: boolean, dimEnable?: boolean, dimBase?: number): void;
        protected checkCeilOrFloorTouchWall(ceil: ContentNode, wall: ContentNode, tolerance?: number): boolean;
        protected checkCurvesIntersection(curves: Curve2d[], othercurves: Curve2d[]): boolean;
        protected drawWallsCompleteLines(walls: ContentNode[], style?: any, drawingLevel?: number, context?: DrawingNodeContext): void;
        protected computeDecorateSurfaceInnerLineAndPath(decorateLayer: DecorateLayerNode): WallSurfaceLineAndPath;
        protected computeWallLineAndBox(levelingWall: ContentNode, isOuterLine?: boolean): WallSurfaceLineAndPath;
        protected computeWallLineAndBoxNew(levelingWall: ContentNode, isOuterLine?: boolean): WallSurfaceLineAndPath;
        protected computeNearestPointInLinecurve(linecurve: LineCurve2d, point: Vector3): Vector3;
        protected computeDynamicWallSurfaceLine(dynamicwall: ContentNode): Line2;
        protected getLinesPoints(lines: Line2[]): Vector2[];
        protected computePlankDirectionTopView(plank: PlankNode): Vector2;
        protected computeWallsZindex(walls: Array<WallNode>, observeMatrix?: Matrix4): number;
        protected drawingRoomCowalls(room: RoomNode, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected drawingCoWalls(document: DrawingDataDocument, cowalls: Array<CowallNode>, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected computeDirectionPolygons(polygons: Vector2[][], positive?: boolean): Vector2[][];
        protected computeDirectionPolygon(points: Vector2[], positive?: boolean): Vector2[];
        protected computePolygonDirection(polygon: Vector2[]): boolean;
        protected getAngleFromVector2s(v1: Vector2, v2: Vector2): number;
        protected drawLineArrow(point1: Vector2, point2: Vector2, style: any, drawingLevel?: number): void;
        protected drawingWalls(document: DrawingDataDocument, walls: Array<WallNode>, fillEnable: boolean, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean): void;
        protected createWallPolygonsWithoutOpening(document: DrawingDataDocument, walls: Array<WallNode> | Array<CowallNode>, wallPoints: Vector2[][], observeMatrix?: Matrix4): PolygonCurve2dDrawingNode[];
        protected createFillsByWall(document: DrawingDataDocument, dpolygons: PolygonCurve2dDrawingNode[], id: string): Fill2dDrawingNode[];
        protected drawFlatWallsAsync(flatwalls: FlatWallNode[], observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwallsoutlines?: Array<Vector2>): Promise<BrepNode[]>;
        protected drawFloorplanFlatWallsText(flatwalls: FlatWallNode[], textHeight?: number, dimBoxs?: Box2[]): void;
        protected flatwallTextOffset(flatwallAndNames: {
            flatwall: FlatWallNode;
            leader: LeaderDrawingNode;
        }[], textHeight?: number, dimBoxs?: Box2[]): void;
        protected computeLeaderTextBox(point: Value2, text: string, textHeight: number): Box2;
        protected offsetFlatWallText(curLeaderAndBox: {
            leader: LeaderDrawingNode;
            box: Box2;
        }, offsetDir: Vector2, offsetStep: number, leaderAndBoxs: {
            leader: LeaderDrawingNode;
            box: Box2;
        }[], boxs: Box2[], textHeight: number, offsetArr?: Vector2[], curOffsetCount?: number, originPoint?: Value2): void;
        protected computeOffsetArr(offsetDir: Value2, offsetCount: number): Array<any>;
        protected drawFlatwallCodeForm(flatwalls: FlatWallNode[]): void;
        protected drawFlatWallAsync(flatwall: FlatWallNode, observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwalloutlines?: Array<Vector2>, cutsurface?: SectionSurface, roomnode?: RoomNode): Promise<BrepNode[]>;
        protected computeFlatwallGeosExcludeDoors(geos: Curve2dNode[], openings: OpeningNode[]): BrepNode[];
        protected computeFlatWallOpenings(flatwall: FlatWallNode): OpeningNode[];
        protected drawFlatWallPlanks(flatwall: FlatWallNode, observeMatrix?: Matrix4, cutsurface?: SectionSurface): BrepNode[];
        protected drawFlatWallCode(flatwall: FlatWallNode, textHeight?: number, cutsurface?: SectionSurface, roomnode?: RoomNode): {
            codeText: BrepNode[];
            nameText: LeaderDrawingNode[];
        };
        protected drawFlatWallCodeText(flatwallnode: FlatWallNode, innerdirection: Vector2, cutsurface?: SectionSurface, roomnode?: RoomNode, textHeight?: number): LeaderDrawingNode[];
        protected drawFlatWallOuterKeelCode(outercontainer: ContainerNode, flatwallinnerdirection: Vector2, cutsurface?: SectionSurface): BrepNode;
        protected drawFlatWallInnerKeelCode(innercontainer: ContainerNode, flatwallinnerdirection: Vector2, cutsurface?: SectionSurface): BrepNode;
        protected drawRoomFlatWallAsync(roomnode: RoomNode, observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, flatwallsoutlines?: Array<Vector2>): Promise<void>;
        protected checkFlatWallOverRoom(flatwall: FlatWallNode, room: RoomNode): boolean;
        protected getRoomFlatWalls(roomnode: RoomNode): FlatWallNode[];
        protected findWallsFromCowalls(cowalls: CowallNode[]): WallNode[];
        protected findNodeFromNodeIdInNodes(id: string, nodes: DataNode[]): DataNode;
        protected findNodeFromElementIdInNodes(id: string, nodes: DataNode[]): DataNode;
        protected isElementIdInNodes(id: string, nodes: DataNode[]): boolean;
        protected drawFloorplanFlatWallAsync(floorplan: FloorplanNode, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean, breakbyopening?: boolean): Promise<void>;
        protected drawWallAndLineDistanceDim(line: Line2, dynamicware: ContentNode, dimstyle?: any, drawingLevel?: number): void;
        protected computeOGWallFromAssemblewall(assemblewall: ContentNode): CowallNode[];
        protected computeOGWallNearestInnerLine(cowall: CowallNode, innerline: Line2): Line2;
        protected computeOGWallInnerLine(assembledWall: ContentNode): Line2;
        protected findSurfaceNodeByElementId(floorplannode: FloorplanNode, elementid: string): WallSurfaceNode;
        protected createCompleteDistanceDims(completeline: Line2, distance: number, centerposoffset: number, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[];
        protected getInnerEdgeFromColumnInnerDirection(columnNode: ColumnNode, direction: Vector2): Line2;
        protected findUpAssemledRoom(node: DataNode): ContentNode;
        protected findChildrenAssemledRoom(node: DataNode): BrepNode;
        protected findNodeRelationContent(node: ContentNode, findslave?: boolean): InstanceElement;
        protected findNodeRelationElementId(node: ContentNode, findslave?: boolean): string;
        protected findBindValue(node: ContentNode, parameterCode: string, findslave?: boolean): string;
        protected findRelationElements(node: ContentNode, findslave?: boolean): InstanceElement[];
        protected getCowallById(id: string, cowalls: Types<CowallNode>): CowallNode;
        protected getColumnByAssembelColumnWall(wall: ContentNode): ColumnNode;
        protected getColumnByIdFromCowalls(id: string, cowalls: Types<CowallNode>): ColumnNode;
        protected checkColumn(node: ContentNode): boolean;
        protected computeWallCavityLine(dynamicware: DynamicWareNode, base: WareNode): Line2;
        protected computeWallCompleteLineFromAssembleWall(dynamicWare: ContentNode): Line2;
        protected computeWallInnerDirection(dynamiware: ContentNode): Vector2;
        protected computeWallInnerLine(dynamiware: ContentNode): Line2;
        protected computeWallBaseInfo(dynamicware: ContentNode, base: ContentNode): WallBaseInfo;
        protected computeSurfaceContainerInnerLine(dynamicware: ContentNode, surface: WareNode): Line2;
        protected findChildContainerByName(node: DynamicWareNode, name: string): DataNode;
        protected getRoomWorkPoints(): Types<Vector3>;
        protected getRoomInnerPoints(): Types<Vector3>;
        protected getRoomBeamPoints(): Array<Vector3>;
        protected drawingRoomInstancesAsync(context: DrawingNodeContext, room: RoomNode, openingEnable?: boolean, beamEnable?: boolean, columnEnable?: boolean): Promise<void>;
        protected getBreakOpeningFlagByCode(context: DrawingNodeContext): boolean;
        protected drawingOpenings(document: DrawingDataDocument, room: RoomNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingOpening(document: DrawingDataDocument, opening: OpeningNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingOpeningCode(opening: OpeningNode, matrix?: Matrix4): void;
        protected drawOpeningNodeText(node: ContentNode, startX: number, startY: number, content: string, offset: number): void;
        protected computeVectorsByBoundary(box: BoundaryBox, matrix?: Matrix4): Vector3[];
        textBoxs: Box2[];
        protected isCollision(textBox: Box2): boolean;
        protected getTextOffsetPoint(textStr: string, textHeight: number, originPoint: Vector2, offsetY?: number): Vector2;
        protected textStrIsCollision(textStr: string, textHeight: number, originPoint: Value2): boolean;
        protected getAssembleWallBox(node: ContentNode): Box2;
        protected drawStartPoint(points: Vector2[], borders: Vector2[], path: PathCurve2d, style?: any): void;
        protected computeNearestPoint(points: Vector2[], borders: Vector2[]): ComputeNearestPointResult;
        protected getBeamClipPoints(beam: BeamNode, roomPoints: Vector2[]): Array<Vector2>;
        protected createInstanceInfos(instances: FamilyInstanceNode[], code?: string, textHeight?: number): void;
        protected computeCurve2dNodeCutBySurface(curve2dNode: Curve2dNode, cutsurface: SectionSurface, keepstyleanddrawinglevel?: boolean, includeedge?: boolean): Curve2dNode[];
        protected computeCurve2dNodesCutBySurface(curve2dNodes: Curve2dNode[], cutsurface: SectionSurface, keepstyleanddrawinglevel?: boolean, includeedge?: boolean): Curve2dNode[];
        createNodesProjections(matrixp: Matrix4, nodes: GeometricNode[], style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption): GeometricNode[];
        protected findFlatWallDrawNode(flatwall: FlatWallNode): HardwareNode[];
        protected computeSectionSurfaceByPoints(points: Vector2[]): SectionSurface;
        protected computeLineCurvesFromOrderPoints2d(points: Vector2[]): LineCurve2d[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomFloorDryPlankNode } from "sk/data/scheme/database/assemble/node/BathroomFloorDryPlankNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { BathroomAreaNode } from "sk/data/scheme/database/pattern/node/BathroomAreaNode";
    import { BathroomFloorDryNode } from "sk/data/scheme/database/pattern/node/BathroomFloorDryNode";
    import { BathroomFloorWetNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeBorderOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { WallSurfaceLineAndPath } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { BaseFinishLineDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDrawingConverter";
    export type BathRoomBoundaryLines = {
        topLine: Line2;
        bottomLine: Line2;
        leftLine: Line2;
        rightLine: Line2;
    };
    export type FloorGroup = {
        dryFloor: WareNode;
        dryTiles: WareNode[];
        dryPlate: WareNode;
        dryBox: BoxSolid;
        drySupports: WareNode[];
        wetFloor: WareNode;
        wetPlate: WareNode;
        wetBox: BoxSolid;
        holes: TechnologyHoleNode[];
        code: string;
        others: FamilyInstanceNode[];
    };
    export type FloorGroupInfo = {
        area: BathroomAreaNode;
        dryFloor: BathroomFloorDryNode;
        wetFloor: BathroomFloorWetNode;
        dryFloorPlanks: BathroomFloorDryPlankNode[];
        dryFloorTiles: ContentNode[];
        holes: TechnologyHoleNode[];
        others: ContentNode[];
        supports: ContentNode[];
        wetothers: FamilyInstanceNode[];
    };
    export type CeilingGroupInfo = {
        planks: PlankNode[];
        others: ContentNode[];
    };
    export type CeilingGroup = {
        planks: WareNode[];
        holes: TechnologyHoleNode[];
        code: string;
        others: FamilyInstanceNode[];
        ceilingBox: BoxSolid;
    };
    export type WallInfo = {
        wall: WareNode;
        planks: ContentNode[];
        tiles: ContentNode[];
        holes: TechnologyHoleNode[];
        others: FamilyInstanceNode[];
    };
    export type WallGroup = {
        wallMap: Map<string, WallInfo[]>;
        code: string;
    };
    export type BathroomAllSplitInfo = {
        style: DrawingUnitBathroomStyleInfo;
        floorGroups: FloorGroupInfo[];
        ceilGroups: CeilingGroupInfo[];
        completeDis: number;
    };
    export type BathroomSplitInfo = {
        style: DrawingUnitBathroomStyleInfo;
        floor: WareNode;
        floorGroups: FloorGroup[];
        walls: WareNode[];
        wallInfos: WallInfo[];
        wallGroups: WallGroup[];
        ceiling: WareNode;
        ceilingGroups: CeilingGroup[];
        linkRoom: RoomNode;
        measures: FamilyInstanceNode[];
        completeDis: number;
        others: FamilyInstanceNode[];
        contentRotation: number;
        ceilingBoxHeight: number;
    };
    export class UnitBathroomDesignDrawingConverter extends BaseFinishLineDrawingConverter {
        processAsync(context: DrawingNodeContext, node: BathroomNode): Promise<ResultObject<DrawingDataDocument>>;
        protected findHoles(plank: ContentNode): ContentNode[];
        protected checkCornerPlank(plank: PlankNode): boolean;
        protected createEmptyBathroomSplitInfoNew(): BathroomAllSplitInfo;
        protected createEmptyBathroomSplitInfo(): BathroomSplitInfo;
        protected createEmptyCeilingGroupInfo(): CeilingGroupInfo;
        protected createEmptyFloorGroupInfo(): FloorGroupInfo;
        protected createEmptyFloorGroup(): FloorGroup;
        protected createEmptyWallGroup(): WallGroup;
        protected createEmptyWallInfo(): WallInfo;
        protected createEmptyCeilingGroup(): CeilingGroup;
        protected createDefaultStyle(): DrawingUnitBathroomStyleInfo;
        protected getOpeningInstance(floorplan: BrepNode): FamilyInstanceNode[];
        protected findBathroomInstanceFamilyInstanceNode(instance: DataNode): FamilyInstanceNode;
        protected findBathroomInstancesFamilyInstancesNodes(instances: DataNode[]): FamilyInstanceNode[];
        protected findWetFloorNode(bathroom: BathroomNode): ContentNode;
        protected findPlanksFromFloor(floornode: ContentNode): ContentNode[];
        protected othersSplit(info: BathroomSplitInfo): void;
        protected getWallInfoByNodeAsync(context: DrawingNodeContext, wall: WareNode): Promise<WallInfo>;
        protected deleteNullForSplitInfo(info: BathroomSplitInfo): void;
        protected deleteNullForArray(arr: Array<any>): void;
        findLinkRoom(node: BathroomNode): RoomNode;
        protected findBindValue(node: ContentNode, parameterCode: string, findslave?: boolean): string;
        protected drawingLinkRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, unitBathroom: BathroomNode): Promise<void>;
        protected buildRoomDimensions(node: BrepNode, observerMatrix?: Matrix4): void;
        protected drawReduceGeoNodeArray(nodes: Curve2dNode[], distance: number): GeometricNode[];
        protected drawReduceGeoNode(node: Curve2dNode, distance: number): GeometricNode;
        protected drawingOpening(document: DrawingDataDocument, opening: OpeningNode, matrix?: Matrix4): void;
        protected drawBathroomSurFaceLines(bathroom: BathroomNode | BathroomAreaNode, style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected drawBathroomCavityLines(bathroom: BathroomNode, style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected drawBathroomDryFloorOutline(bathroomfloor: ContentNode): GeometricNode[];
        protected drawBathroomWetFloorOutline(bathroomfloor: ContentNode): GeometricNode[];
        protected drawFloorNodeOutline(bathroomfloor: ContentNode, observerMatrix: Matrix4, style?: any, drawingLevel?: number): Curve2dNode;
        protected drawBathroomFloorOutline(bathroomfloor: ContentNode, style?: any, drawingLevel?: number): GeometricNode[];
        protected drawLine2s(lines: Line2[], style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected findWholePlanksFromBathroomWall(bathroomwall: BathroomWallNode): ContentNode[];
        protected findPlanksFromBathroomWall(bathroomwall: BathroomWallNode): ContentNode[];
        protected computeWallLineAndBox(assembelwall: ContentNode, isouterLine?: boolean): WallSurfaceLineAndPath;
        protected convertlines2linecurves(lines: Line2[]): LineCurve2d[];
        protected computeWallInnerLineDirection(bathroomwall: BathroomWallNode): Vector2;
        protected fetchAllWallsFromBathroom(bathroom: BathroomNode | BathroomAreaNode): BathroomWallNode[];
        protected fetchPlanksFromWall(wall: BathroomWallNode): PlankNode[];
        protected fetchPlanksFromBathroomWall(bathroomwall: BathroomWallNode): WareNode[];
        protected computeContainerPolygon(container: WareNode, clazz: Function, showIdentifyCode?: boolean): Vector3[][];
        protected computeVectorsByBoundary(box: BoundaryBox, matrix?: Matrix4): Vector3[];
        protected createOpeningDimpoints(bathroom: BathroomNode, isDrawOpenline?: boolean): Vector2[];
        protected computeOpeningLine(node: ContentNode, dir: Vector2): Line2;
        protected computeOpeningClosedRoomLine(open: ContentNode, orderLines: Line2[]): Line2;
        private findClosedLine;
        protected drawOpenNodeCode(node: ContentNode, line: Line2, index: number): void;
        protected drawingOpeningElement(document: DrawingDataDocument, opening: OpeningNode, matrix: Matrix4, geoStyle?: any, drawomgLevel?: number): PolygonCurve2dDrawingNode;
        protected createDefaultFirstUseBorderOption(borderEnable?: boolean, boxEnable?: boolean, ignoreNoPoints?: boolean): DrawingNodeBorderOption;
        protected drawNodesInnerDimensions(nodes: GeometricNode[], dimdistance?: number, style?: any, drawingLevel?: number): BrepNode[];
        protected drawNodeInnerDimension(node: GeometricNode, dimdistance?: number, style?: any, drawingLevel?: number): BrepNode[];
        protected computeLinesFromPoints(points: Vector2[] | Vector3[]): Line2[];
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFrameForUBR" {
    import { SkDbBlueprint } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbBlueprint';
    import { SkDrDrawing } from "sk/data/scheme/drawing/converter/drawer/SkDrDrawing";
    import { PageSizeEnum, SkDrFilesFrame } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFilesFrame";
    export class SkDrFrameForUBR extends SkDrFilesFrame {
        constructor(pageSize?: PageSizeEnum, pageScale?: number);
        drawFrame(blueprint: SkDbBlueprint): void;
        addDrawing(drawing: SkDrDrawing): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrTitlePageForUBR" {
    import { SkDbBlueprint } from 'sk/data/family/drawing/skdbdatabase/dbobject/container/SkDbBlueprint';
    import { SkDrTitlePage } from "sk/data/scheme/drawing/converter/drawer/SkDrTitlePage";
    import { PageSizeEnum } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFilesFrame";
    export class SkDrTitlePageForUBR extends SkDrTitlePage {
        constructor(pageSize?: PageSizeEnum, pageScale?: number);
        drawTitlePage(blueprint: SkDbBlueprint): void;
    }
}
declare module "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFilesForUBR" {
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { SkDrFiles } from "sk/data/scheme/drawing/converter/drawer/SkDrFiles";
    import { SkDrDrawingAreaLayoutPlan } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingAreaLayoutPlan";
    import { SkDrDrawingCeilingLayoutPlan } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingCeilingLayoutPlan";
    import { SkDrDrawingFloorTileLayoutPlan } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingFloorTileLayoutPlan";
    import { SkDrDrawingOriginalPlan } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingOriginalPlan";
    import { SkDrDrawingWallLayoutPlan } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWallLayoutPlan";
    import { SkDrDrawingWallTileLayoutElevation } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWallTileLayoutElevation";
    import { SkDrDrawingWareLayoutPlan } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrDrawingWareLayoutPlan";
    import { SkDrFrameForUBR } from "sk/data/scheme/drawing/converter/drawer/unitbathroom/SkDrFrameForUBR";
    export class SkDrFilesForUBR extends SkDrFiles {
        originalPlanFrame: SkDrFrameForUBR;
        originalPlanDrawing: SkDrDrawingOriginalPlan;
        areaLayoutPlanFrame: SkDrFrameForUBR;
        areaLayoutPlanDrawing: SkDrDrawingAreaLayoutPlan;
        wareLayoutPlanFrame: SkDrFrameForUBR;
        wareLayoutPlanDrawing: SkDrDrawingWareLayoutPlan;
        floorTileLayoutPlanFrame: SkDrFrameForUBR;
        floorTileLayoutPlanDrawing: SkDrDrawingFloorTileLayoutPlan;
        wallLayoutPlanFrame: SkDrFrameForUBR;
        wallLayoutPlanDrawing: SkDrDrawingWallLayoutPlan;
        ceilingLayouPlanFrame: SkDrFrameForUBR;
        ceilingLayoutPlanDrawing: SkDrDrawingCeilingLayoutPlan;
        wallTileLayoutElevations: SkDrFrameForUBR[];
        wallTileLayoutElevationDrawing: SkDrDrawingWallTileLayoutElevation[];
        bathroomWallNodess: BathroomWallNode[][];
        constructor();
        draw(): void;
        initFromNode(node: BathroomNode): void;
        protected setupFiles(bathroomNode: BathroomNode, holizontal?: boolean): void;
        protected splitWallTileLayoutElevation(bathroomNode: BathroomNode): BathroomWallNode[][];
        protected initOriginalPlan(bathroomNode: BathroomNode): void;
        protected initAreaLayoutPlan(bathroomNode: BathroomNode): void;
        protected initCeilingLayouPlan(bathroomNode: BathroomNode): void;
        protected initFloorTileLayoutPlan(bathroomNode: BathroomNode): void;
        protected initWareLayoutPlan(bathroomNode: BathroomNode): void;
        protected initWallTileLayoutElevation(bathroomNode: BathroomNode): void;
        protected initWallLayoutPlan(bathroomNode: BathroomNode): void;
        protected calculateScale(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingWallDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingWallDrawingConverter";
    export enum WallFaceDrawingContentEnum {
        WallGeo = 0,
        HoleGeos = 1,
        PlankGeos = 2,
        OpeningGeos = 3,
        FinnishLineGeos = 4,
        ColumnGeos = 5
    }
    export class LevelingWallFaceDrawingConverter extends BaseLevelingWallDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): void;
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): void;
    }
}
declare module "sk/data/scheme/drawing/converter/flatwall/FlatWallDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingWallDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingWallDrawingConverter";
    export class FlatWallDrawingConverter extends BaseLevelingWallDrawingConverter {
        process(context: DrawingNodeContext, node: FlatWallNode, option?: any): ResultObject<DrawingDataDocument>;
        protected buildContextObserveMatrix(context: DrawingNodeContext, node: BrepNode): void;
        protected computeDrawing(context: DrawingNodeContext, node: ContentNode, option?: any): ResultObject;
        protected computeDrawingDimensions(context: DrawingNodeContext, curPos: number, distance: number): void;
        protected getExpandBox(box2: Box2): Box2;
        protected createBoundBoxPoints(box: Box2): Vector2[];
        computeDomainBoundary(): void;
        protected drawStartDirection(box: Box2, distance: number, arrowWidth: number, arrowHeight: number, arrowstyle?: any, drawingLevel?: number): void;
        protected drawWallByPlank(node: ContentInstanceNode, matrixP: Matrix4, levelname: string, wallstyle: any, wallDrawingLevel?: number): GeometricNode;
    }
}
declare module "sk/data/scheme/drawing/converter/flatwall/FlatWallBaseLayerDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeConverterOption } from "sk/data/scheme/drawing/config/DrawingNodeConverterConfig";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FlatWallDrawingConverter } from "sk/data/scheme/drawing/converter/flatwall/FlatWallDrawingConverter";
    export enum FlatWallDrawingContentEnum {
        KeelDimensionPoints = 0,
        PlankOutlinePoints = 1,
        SteeveOutlinePoints = 2
    }
    export class FlatWallBaseLayerDrawingConverter extends FlatWallDrawingConverter {
        canConvert(node: BrepNode, option?: DrawingNodeConverterOption): boolean;
        processAsync(context: DrawingNodeContext, node: FlatWallNode, option?: DrawingNodeConverterOption): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentNode, option?: any): Promise<ResultObject>;
    }
}
declare module "sk/data/scheme/drawing/converter/flatwall/FlatWallKeelDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Text2dDrawingNode } from 'sk/data/family/model/brep/drawing/text2d/Text2dDrawingNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FlatWallDrawingConverter } from "sk/data/scheme/drawing/converter/flatwall/FlatWallDrawingConverter";
    export class FlatWallKeelDrawingConverter extends FlatWallDrawingConverter {
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computePlanksOutline(context: DrawingNodeContext, node: BrepNode): void;
        protected drawPlanksOutlines(context: DrawingNodeContext, planks: PlankNode[]): void;
        protected findInnerOuterPlanks(context: DrawingNodeContext, node: BrepNode): PlankNode[];
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, curpos: number, distance: number): ResultObject;
        protected computeKeelDrawingAsync(flatWall: ContentNode, drawcontext: DrawingNodeContext, option?: any): Promise<ResultObject>;
        protected drawHardwaresAsync(node: ContentNode, matrixP: Matrix4, style: any, context: DrawingNodeContext): Promise<void>;
        protected computeKeelsDimensionPoints(keels: ContentNode[], matrixp: Matrix4): Vector2[];
        protected computeNodesDimensionPoints(nodes: ContentNode[], matrixp: Matrix4): Vector2[];
        protected findJointerHardwares(node: ContentNode): Array<FamilyInstanceNode>;
        protected findKeelContainer(node: ContentNode, context?: DrawingNodeContext): ContainerNode;
        protected findHardwares(node: ContentNode, context?: DrawingNodeContext): Array<FamilyInstanceNode>;
        protected findSteeves(node: ContentNode, context?: DrawingNodeContext): Array<FamilyInstanceNode>;
        protected findChildren(name: string, node: any, col: Types<any>): void;
        protected drawHardwaresByGraphicIdAsync(context: DrawingNodeContext, hardwares: Array<FamilyInstanceNode>, matrixP: Matrix4): Promise<any>;
        protected isProcessedProductsAsync(context: IContext, node: FamilyInstanceNode): Promise<boolean>;
        protected drawNodeLeadText(node: ContentNode, content: string, contentoffset: Vector2, matrixP?: Matrix4): void;
        protected createKeelNodeTextAsync(context: IContext, keel: any, matrixP: Matrix4, typedict: Map<string, string>, replacetypearray: Array<string>): Promise<Array<BrepNode>>;
        protected doTextOffset(textNodes: Array<Array<Text2dDrawingNode>>, keelTextNode: Array<Text2dDrawingNode>): void;
        protected createTextDimension(text: string, position: Vector2, style?: any): Text2dDrawingNode;
    }
}
declare module "sk/data/scheme/drawing/converter/floorplan/FloorplanDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    export class FloorplanDrawingConverter extends BaseLevelingDynamicDrawingConverter {
        processAsync(context: DrawingNodeContext, node: FloorplanNode): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
    }
}
declare module "sk/data/scheme/drawing/converter/room/RoomSmallBoxDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { Fill2dDrawingNode } from 'sk/data/family/model/brep/drawing/Fill2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    export class RoomSmallBoxDrawingConverter extends BaseLevelingDynamicDrawingConverter {
        protected cowallMaps: any;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: BrepNode): Promise<any>;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawDynamicRoom(context: DrawingNodeContext, roomdynamicware: ContentNode): void;
        protected drawLevelingStartWallDirection(levelNode: LevelingWallNode): void;
        protected lineGetSameDirectionCoinsideLineFromLines(line: LineCurve2d, lines: LineCurve2d[]): Vector3[];
        protected drawWallStartDirection(wall: DynamicWareNode, lines: LineCurve2d[]): void;
        protected drawWallsCavityAndDims(walls: ContentNode[], style?: any, drawingLevel?: number): void;
        protected drawWallsCompleteLines(context: DrawingNodeContext, walls: ContentNode[], style?: any, drawingLevel?: number): void;
        protected getExtendLine(line: LineCurve2d, length: number): LineCurve2d;
        protected getLineMathNodesFromDrawNodes(lines: LineCurve2dDrawingNode[]): LineCurve2d[];
        protected drawDynamicWallCode(wall: ContentNode, distance: number, code: string, style?: any, drawingLevel?: number): void;
        private drawWallCode;
        protected drawCompleteLineDistanceDim(to: Vector2, from: Vector2): void;
        protected drawLevelingWallPlanks(wallnode: ContentNode): void;
        protected drawPlank(container: WareNode): void;
        protected computeVectorsByBoundary(box: BoundaryBox): Vector3[];
        private createCoWallPolygonsWithoutOpening;
        protected createFillsByWall(document: DrawingDataDocument, dpolygons: PolygonCurve2dDrawingNode[], id: string): Fill2dDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/floorplan/FloorplanSmallBoxDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { RoomSmallBoxDrawingConverter } from "sk/data/scheme/drawing/converter/room/RoomSmallBoxDrawingConverter";
    export class FloorplanSmallBoxDrawingConverter extends RoomSmallBoxDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: BrepNode): Promise<any>;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected drawDynamicRoom(context: DrawingNodeContext, roomdynamicware: ContentNode): void;
        protected drawWallsCompleteLines(context: DrawingNodeContext, walls: ContentNode[], style?: any, drawingLevel?: number): void;
        protected getExtendLine(line: LineCurve2d, length: number): LineCurve2d;
        protected drawBeamsCompleteLines(beams: ContentNode[], style?: any, drawingLevel?: number): void;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawShareDoorRoomsCompleteLineDistanceDim(floorplan: FloorplanNode, style?: any, drawingLevel?: number): void;
        protected findDynamicWareWallFromCowall(cowall: CowallNode, floorplan: FloorplanNode): LevelingWallNode;
        private buildCowallMap;
        protected computeVectorsByBoundary(box: BoundaryBox): Vector3[];
    }
}
declare module "sk/data/scheme/drawing/converter/floorplan/FloorplanStructureDrawingConverter" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Geometric } from 'foundation/runtime/geometry/Geometric';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { AlignLineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/AlignLineCurveDimensionDrawingNode';
    import { CurveDimensionNode } from 'sk/data/family/model/assistant/dimension/CurveDimensionNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { AssembleBeamNode } from "sk/data/scheme/database/pattern/node/AssembleBeamNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { LevelingCeilingNode } from "sk/data/scheme/database/pattern/node/LevelingCeilingNode";
    import { LevelingFloorNode } from "sk/data/scheme/database/pattern/node/LevelingFloorNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FloorplanNoInstanceDrawingConverter } from "sk/data/scheme/drawing/converter/floorplan/FloorplanNoInstanceDrawingConverter";
    export class FloorplanStructureDrawingConverter extends FloorplanNoInstanceDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        canConvertAsync(context: DrawingNodeContext, node: FloorplanNode, option?: any): Promise<boolean>;
        protected computeDrawingDetailAsync(context: DrawingNodeContext, floorplan: FloorplanNode): Promise<void>;
        protected drawNodesByCodeAsync(context: DrawingNodeContext, code: string, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        private dimIsOffset;
        protected drawFlatWallSurveysAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix: Matrix4): Promise<void>;
        protected offsetDimsTextDir(surveyDims: {
            keelDims: AlignLineCurveDimensionDrawingNode[];
            keelDimsOrigin: Value2[];
            lengthDims: AlignLineCurveDimensionDrawingNode[];
            lengthDimsOrigin: Value2[];
            containerDims: AlignLineCurveDimensionDrawingNode[];
            flatwall: FlatWallNode;
        }[]): void;
        protected flatWallsText(flatwalls: FlatWallNode[], surveyDims: any[]): void;
        protected offsetDimsByIntersectCount(targetOffsetDims: any[], surveyDims: any[]): any;
        protected tryOffsetDims(surveyDims: any, tryCount: number, offsetStep: number, excludeDims?: any[]): any[];
        protected checkAndOffsetKeelDims(dims: AlignLineCurveDimensionDrawingNode[], surveyDims: any[], curSurveyDim: any, offsetStep: number): boolean;
        protected moveDims(dims: AlignLineCurveDimensionDrawingNode[], offset: number, flatwall: FlatWallNode): void;
        protected mergeLine(lines: AlignLineCurveDimensionDrawingNode[]): AlignLineCurveDimensionDrawingNode;
        protected checkDimsIntersect(offsetTarget: AlignLineCurveDimensionDrawingNode, dim: AlignLineCurveDimensionDrawingNode): boolean;
        protected drawFlatWallSurvey(context: DrawingNodeContext, flatwall: FlatWallNode, observeMatrix: Matrix4): any;
        protected checkDimensionsEquals(dims1: CurveDimensionNode[], dims2: CurveDimensionNode[], line: Line2): boolean;
        protected checkPointsEquals(point1s: Vector2[], point2s: Vector2[]): boolean;
        protected computeDimensionPointsOnLine(dims: CurveDimensionNode[], line: Line2): Vector2[];
        protected drawContainersSurveyDimensions(containers: ContentNode[], flatwallinnerlinedirection: Vector2, distance: number, observeMatrix: Matrix4, style?: any, drawingLevel?: number): BrepNode[];
        protected createOuterKeelSurveyDimensions(keelouterline: Line2, keels: HardwareNode[], distance: number, observeMatrix?: Matrix4, style?: any, drawingLevel?: number): BrepNode[];
        protected createInnerKeelSurveyDimensions(keelinnerline: Line2, keels: HardwareNode[], distance: number, observeMatrix?: Matrix4, style?: any, drawingLevel?: number): BrepNode[];
        protected computeCurve2dsBoxTopView(curve2ds: Curve2d[]): Box2;
        protected curve2dsApplyMatrix(curve2ds: Curve2d[], matrix: Matrix4): void;
        protected computeInnerKeelInnerLine(innerlinedirection: Vector2, innerkeelcontainer: ContainerNode, observeMatrix: Matrix4): Line2;
        protected computeOuterKeelOuterLine(innerlinedirection: Vector2, outerkeelcontainer: ContainerNode, observeMatrix: Matrix4): Line2;
        protected findSurveyKeels(node: DataNode): HardwareNode[];
        protected drawNodesForFamilyInstancesAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleGroundAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleFloorAsync(context: DrawingNodeContext, floor: LevelingFloorNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleTopAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawBoardsAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4, isTop?: boolean): Promise<void>;
        protected drawNodeForAssembleBeamAsync(context: DrawingNodeContext, beam: AssembleBeamNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleWallAsync(context: DrawingNodeContext, wall: LevelingWallNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembelCeilAsync(context: DrawingNodeContext, ceil: LevelingCeilingNode, observeMatrix?: Matrix4): Promise<void>;
        protected createGeometricProjectionMathLines(matrixw: Matrix4, matrixp: Matrix4, geometric: Geometric): Curve2d[];
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureBaseConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Line3 } from 'foundation/runtime/math/Line3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepEdge, BrepFace } from 'foundation/runtime/geometry/brep/Brep';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { CurveProjectStruct } from 'foundation/runtime/geometry/relation/BrepRelationUtil';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d, SingleCurve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Curve3d } from 'foundation/runtime/geometry/Curve3d';
    import { Ray3 } from 'foundation/runtime/geometry/Ray3';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { Triangle3 } from 'foundation/runtime/geometry/Triangle3';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    export type SubGraphicsResult = {
        graphics: BrepNode[];
        dimpoints: Vector2[];
        curves: Array<CurveProjectStruct>;
    };
    export type WholeGraphicsResult = {
        graphics: BrepNode[];
        wholeBox: Box2;
        graphicBox: Box2;
    };
    export class FurnitureBaseConverter extends BaseDrawingConverter {
        protected formconvert: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        protected get childsBrep(): Array<BrepBody>;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
        isOutputHardware(node: FamilyInstanceNode): boolean;
        isDoor(node: FamilyInstanceNode): boolean;
        protected computeBrepProjectCurves(brep: BrepBody, projMatrix: Matrix4, visibles: Array<SingleCurve2d>, invisibles: Array<SingleCurve2d>): Array<CurveProjectStruct>;
        protected computeEdgeProjectCurves(edges: Array<BrepEdge>, faces: Array<BrepFace>, projMatrix: Matrix4, visibles: Array<SingleCurve2d>, invisibles: Array<SingleCurve2d>): Array<CurveProjectStruct>;
        protected drawDimpoints(cubenode: BrepNode, matrixp: Matrix4, distance: number, geos: any[], subresult: SubGraphicsResult, graogstyle: any, dimstyle: any): WholeGraphicsResult;
        protected drawFormAsync(node: BrepNode, startPos: Vector2, context: DrawingNodeContext, distance?: number): Promise<void>;
        protected createNodeMainGraphics(node: BrepNode, matrixp: Matrix4, style?: any, drawingLevel?: number): GeometricNode[];
        protected drawNodeProjectionLines(matrixp: Matrix4, node: BrepNode, style?: any, drawingLevel?: number): Curve2dNode[];
        protected createNodeSubGraphics(node: BrepNode, matrixp: Matrix4, isSide: boolean, vStyle?: any, drawingLevel?: number, hStyle?: any, isOutDoor?: boolean): SubGraphicsResult;
        computeDisplayOutLines(nodes: GeometricNode[], matrixp: Matrix4, style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption, isPositive?: boolean): Array<any>;
        protected getOutlinesFromModel(node: GeometricNode, line3ds: Line3[], line2ds: Line2[], outLine3doptions: MoldingOutline3dOptions): void;
        protected removeInvalidLinesFromObserver(curve3ds: Array<Line3>, triangles: Array<Triangle3>): void;
        protected checkoutIntrPoints(ray: Ray3, t: Triangle3): boolean;
        protected curvesToLines(curves2d: Array<Curve2d> | Array<Curve3d>, v2orv3?: boolean): Array<any>;
        protected computeLinesIntrResult(lines3: Array<Line3>, lines2: Array<Line2>): Array<Line3>;
        protected computeSpecialLinesIntrResult(lines3: Array<Line3>, lines2: Array<Line2>): Line3[];
        protected linesCullingLines(target: Line2, lines: Array<Line2>): Array<Line2>;
        protected segmentsIntr(line1: Line2, line2: Line2): Vector2;
        protected removeRepeatLine3s(lines: Line3[]): Line3[];
        protected computeTargetZFromPoints(target: Vector2, point1: Vector3, point2: Vector3): Vector3;
        protected computeLineV2sToV3s(targets: Array<Line2>, point1: Vector3, point2: Vector3): Array<Line3>;
        protected getCurves(curves2d: Array<Curve2d> | Array<Curve3d>, isv3?: boolean): Array<any>;
        protected createComplexCurvesGroup(curve: Curve2d | Curve3d): Array<any>;
        protected getPlankNodes(nodes: BrepNode[]): Array<any>;
        protected computeOffset(targetpoint: Vector2, sourcepoint: Vector2, targetoffset: Vector2): Vector2;
        protected createWholeBox(graphicbox: Box2, dimgeos: BrepNode[]): Box2;
        protected getStandardDistance(boxs: Box2[]): number;
        protected getPartAllDimpoints(maingra: GeometricNode, subdimpoints: Vector2[]): Vector2[];
        protected pointProjection(matrixp: Matrix4, matrixw: Matrix4, point: Vector3): Vector2;
        protected getPlankSurfaceRefCodeAsync(plank: PlankNode, context: DrawingNodeContext): Promise<string>;
        protected getPlankMaterialCodeAsync(plank: PlankNode, context: DrawingNodeContext): Promise<string>;
        protected checkStructureHardware(node: HardwareNode): boolean;
        protected computeOrderedNodesOutlinePoints(nodes: ContentNode[], matrixp: Matrix4): Vector2[];
        protected computeDisplaySurfacesFromOrderedSurfaces(surfaces: SectionSurface[], displaysurfaces: SectionSurface[]): void;
        protected putSectionSurfaceInArrayIntoSections(array: Surface[], sections: SectionSurface[]): void;
        protected buildModelingTrianglesFormBufferGeometry(buffer: BufferGeometry, matrixw?: Matrix4, matrixp?: Matrix4, matrixs?: Matrix4, style?: any): Triangle3[];
        protected createTriangle3(a: Vector3, b: Vector3, c: Vector3, style?: any): Triangle3;
        protected createComplexLines(curve: Curve2d | Curve3d, line2orline3?: boolean): any[];
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureBaseConverter";
    export class FurnitureChestBaseConverter extends FurnitureBaseConverter {
        protected static chest: ChestNode;
        protected static _childsBrep: Array<BrepBody>;
        protected static _holesBrep: Array<BrepBody>;
        protected static _childsBox: Array<BoxSolid>;
        constructor(domain?: DrawingDomainNode);
        protected get childsBrep(): Array<BrepBody>;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestFrontDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureChestBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter";
    export class FurnitureChestFrontDrawingConverter extends FurnitureChestBaseConverter {
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestFrontWithoutDoorDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureChestBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter";
    export class FurnitureChestFrontWithoutDoorDrawingConverter extends FurnitureChestBaseConverter {
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestLeftDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureChestBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter";
    export class FurnitureChestLeftDrawingConverter extends FurnitureChestBaseConverter {
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestProjectiveDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureChestBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter";
    export class FurnitureChestProjectiveDrawingConverter extends FurnitureChestBaseConverter {
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestRightDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureChestBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter";
    export class FurnitureChestRightDrawingConverter extends FurnitureChestBaseConverter {
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestStructDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureChestBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter";
    export class FurnitureChestStructDrawingConverter extends FurnitureChestBaseConverter {
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureChestTopDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureChestBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureChestBaseConverter";
    export class FurnitureChestTopDrawingConverter extends FurnitureChestBaseConverter {
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopBaseConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FurnitureCountertopNode } from "sk/data/scheme/database/furniture/node/FurnitureCountertopNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureBaseConverter";
    export class FurnitureCountertopBaseConverter extends FurnitureBaseConverter {
        protected static countertopNode: FurnitureCountertopNode;
        protected static _childsBrep: Array<BrepBody>;
        protected static _holesBrep: Array<BrepBody>;
        protected static _childsBox: Array<BoxSolid>;
        constructor(domain?: DrawingDomainNode);
        protected get childsBrep(): Array<BrepBody>;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopFrontDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureCountertopBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopBaseConverter";
    export class FurnitureCountertopFrontDrawingConverter extends FurnitureCountertopBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopLeftDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureCountertopBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopBaseConverter";
    export class FurnitureCountertopLeftDrawingConverter extends FurnitureCountertopBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopProjectiveDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureCountertopBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopBaseConverter";
    export class FurnitureCountertopProjectiveDrawingConverter extends FurnitureCountertopBaseConverter {
        protected formConverter: FormComponentConverter;
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopRightDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureCountertopBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopBaseConverter";
    export class FurnitureCountertopRightDrawingConverter extends FurnitureCountertopBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopStructDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FurnitureCountertopBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopBaseConverter";
    export class FurnitureCountertopStructDrawingConverter extends FurnitureCountertopBaseConverter {
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopTopDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureCountertopBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureCountertopBaseConverter";
    export class FurnitureCountertopTopDrawingConverter extends FurnitureCountertopBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureGroupBaseConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { FurnitureBaseConverter, SubGraphicsResult, WholeGraphicsResult } from "sk/data/scheme/drawing/converter/furniture/FurnitureBaseConverter";
    export class FurnitureGroupBaseConverter extends FurnitureBaseConverter {
        protected static groupNode: GroupNode;
        protected static _childsBrep: Array<BrepBody>;
        protected static _holesBrep: Array<BrepBody>;
        protected static _childsBox: Array<BoxSolid>;
        constructor(domain?: DrawingDomainNode);
        protected get childsBrep(): Array<BrepBody>;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected drawDimpoints(group: GroupNode, matrixp: Matrix4, distance: number, geos: any[], subresult: SubGraphicsResult, graogstyle: any, dimstyle: any, option?: DrawingNodeOption): WholeGraphicsResult;
        protected drawChestDimpoints(chest: BrepNode, matrixp: Matrix4, distance: number, geos: any[], subresult: SubGraphicsResult, graogstyle: any, dimstyle: any, option?: DrawingNodeOption): WholeGraphicsResult;
        protected drawGroupDimpoints(group: GroupNode, matrixp: Matrix4, distance: number, geos: any[], subresult: SubGraphicsResult, graogstyle: any, dimstyle: any, option?: DrawingNodeOption): WholeGraphicsResult;
        protected createNodeMainGraphics(node: BrepNode, matrixp: Matrix4, style?: any, drawingLevel?: number, option?: DrawingNodeOption): GeometricNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureGroupFrontDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureGroupBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureGroupBaseConverter";
    export class FurnitureGroupFrontDrawingConverter extends FurnitureGroupBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureGroupFrontWithoutDoorDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureGroupBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureGroupBaseConverter";
    export class FurnitureGroupFrontWithoutDoorDrawingConverter extends FurnitureGroupBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureGroupLeftDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureGroupBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureGroupBaseConverter";
    export class FurnitureGroupLeftDrawingConverter extends FurnitureGroupBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureGroupProjectiveDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureGroupBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureGroupBaseConverter";
    export class FurnitureGroupProjectiveDrawingConverter extends FurnitureGroupBaseConverter {
        protected formConverter: FormComponentConverter;
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureGroupRightDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureGroupBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureGroupBaseConverter";
    export class FurnitureGroupRightDrawingConverter extends FurnitureGroupBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/furniture/FurnitureGroupTopDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    import { FurnitureGroupBaseConverter } from "sk/data/scheme/drawing/converter/furniture/FurnitureGroupBaseConverter";
    export class FurnitureGroupTopDrawingConverter extends FurnitureGroupBaseConverter {
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        computeDrawingAsync(node: BrepNode, context: DrawingNodeContext): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/ipd/IpdPlankConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { GraphicsModel } from "sk/data/scheme/database/ipddata/graphics/model/GraphicsModel";
    import { IpdBase } from "sk/data/scheme/database/ipddata/ipd/entity/IpdBase";
    import { IpdHole } from "sk/data/scheme/database/ipddata/ipd/entity/IpdHole";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export type DrawWithTextResult = {
        geometric: BrepNode;
        text: BrepNode;
    };
    export type DrawWithTextArrayResult = {
        geometrics: BrepNode[];
        texts: BrepNode[];
    };
    export type DimGeoAndGeoResult = {
        dimgeos: BrepNode[];
        geos: BrepNode[];
    };
    export class IpdPlankConverter extends BaseDrawingConverter {
        protected gramodel: GraphicsModel;
        constructor(gramodel?: GraphicsModel, domain?: DrawingDomainNode);
        protected processDrawingIpd(ipd: IpdBase): ResultObject<DrawingDomainNode>;
        protected computeDrawingIpdDetail(ipd: IpdBase): Array<BrepNode>;
        private drawCenterGeometricsDimensions;
        private drawCenterGeometrics;
        private drawCenterPlank;
        private drawGrooves;
        private drawGroove;
        private drawHoles;
        protected drawHole(hole: IpdHole): DrawWithTextResult;
        protected splitGeometricsAndTexts(array: DrawWithTextResult[]): DrawWithTextArrayResult;
        protected findChildrenByClass(ipd: IpdBase, clazz: Function): IpdBase[];
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDecorateConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDrawingConverter";
    export class LevelingCeilingDecorateConverter extends LevelingCeilingDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        canConvert(node: BrepNode, option?: any): boolean;
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingRoomLingCeillings(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): void;
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
        private drawingPlank;
        protected buildDimentionVectors(container: WareNode): Types<Vector3>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingKeelBaseDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { Text2dDrawingNode } from 'sk/data/family/model/brep/drawing/text2d/Text2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDrawingConverter";
    export class LevelingCeilingKeelBaseDrawingConverter extends LevelingCeilingDrawingConverter {
        protected keels: Types<FamilyInstanceNode>;
        protected fillEnable: boolean;
        private unicode;
        private keeltypecodedict;
        private replacetypecodearray;
        constructor(domain?: DrawingDomainNode);
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected splitKeelsNameCodeMap(keels: Types<FamilyInstanceNode>): Map<string, string>;
        protected drawingWallLines(document: DrawingDataDocument, cowalls: CowallNode[], workInstance?: boolean, dimEnable?: boolean, dimBase?: number): void;
        protected drawingPlank(document: DrawingDataDocument, container: WareNode): void;
        protected buildDimentionVectors(container: WareNode): Types<Vector3>;
        protected drawWallCompleteLines(rootnode: BrepNode, style?: any, drawingLevel?: number): void;
        protected drawingWorkDistance(document: DrawingDataDocument, cowalls: CowallNode[]): void;
        protected drawDimensionsAsync(context: DrawingNodeContext, node: ContentNode): Promise<void>;
        protected dimensionSuggestionAsync(context: DrawingNodeContext, node: ContentNode): Promise<void>;
        protected drawFirstAsync(context: DrawingNodeContext, outlinePoints: Array<Vector2>, node: ContentNode): Promise<void>;
        protected getBoundaryPoints(bounds: Box2): Vector2[];
        protected checkConnectComponent(node: FamilyInstanceNode): boolean;
        protected checkNeedSerialNumber(context: DrawingNodeContext): boolean;
        protected drawKeelsTextAsync(context: DrawingNodeContext, keels: Array<FamilyInstanceNode>, needserialNumber: boolean, keeltypecodedict: Map<string, string>, replacetypecodearray: Array<string>, keepmaptext?: Map<string, string>, textstyle?: any, drawingLevel?: number): Promise<void>;
        protected makePointsAsync(context: DrawingNodeContext, dimensions: any): Promise<void>;
        protected checkHasKeelType(keel: ContentInstanceNode, typearray: Array<string>): boolean;
        protected checkNeedText(node: FamilyInstanceNode): boolean;
        protected makeDimension(outline: Vector2[], dimensions: any): void;
        protected makeLines(outline: Vector2[]): any;
        protected buildDimensions1(dimension: any, points: Types<Vector2>, distance: number): void;
        protected buildDimensionNode1(from: Vector2, to: Vector2, dimPoint2d: Vector2, angle: number): LineCurveDimensionDrawingNode;
        protected drawingTestAsync(context: DrawingNodeContext, node: ContentNode, fillEnable: boolean): Promise<void>;
        protected drawPelmetOutline(levelingceil: ContentNode): void;
        protected drawPelmetKeelsAsync(keels: Array<FamilyInstanceNode>, context: DrawingNodeContext): Promise<void>;
        protected drawEdgeKeelStartDirectionFromKeels(keels: Array<FamilyInstanceNode>): void;
        protected drawKeelsByGraphIDAsync(context: DrawingNodeContext, keels: Array<FamilyInstanceNode>, outlinepoints?: Vector2[]): Promise<GeometricNode[]>;
        protected drawEdgeKeelStartDirection(keel: FamilyInstanceNode): void;
        protected checkEdgeKeel(keel: FamilyInstanceNode): boolean;
        protected createTextDimension(text: string, position: Vector2, style?: any): Text2dDrawingNode;
        protected getObjects(node: ContentNode): any;
        protected getPelmetKeels(node: ContentNode): Array<FamilyInstanceNode>;
        protected findChildren(name: string, node: any, col: Types<any>): void;
        protected createPolygon(document: DrawingDataDocument, keelPoints: Vector2[][]): PolygonCurve2dDrawingNode[];
        protected drawDimensionsFromLinePoints(top: Vector2[], bottom: Vector2[], left: Vector2[], right: Vector2[], cellsize: number, style?: any, drawingLevel?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingKeelLayerDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingKeelBaseDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingKeelBaseDrawingConverter";
    export class LevelingCeilingKeelLayerDrawingConverter extends LevelingCeilingKeelBaseDrawingConverter {
        protected cowallMaps: any;
        protected getObjects(node: ContentNode): Types<FamilyInstanceNode>;
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        protected drawingLevelingCeilingsAsync(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): Promise<void>;
        protected dimensionSuggestionKeelLayerAsync(context: DrawingNodeContext, nodes: ContentNode[], parent: ContentNode): Promise<void>;
        protected getPelmetKeels(node: ContentNode): Array<FamilyInstanceNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingKeelCodeDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingKeelLayerDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingKeelLayerDrawingConverter";
    export class LevelingCeilingKeelCodeDrawingConverter extends LevelingCeilingKeelLayerDrawingConverter {
        private formComponent;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: BrepNode): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingKeelHangingDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingKeelBaseDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingKeelBaseDrawingConverter";
    export class LevelingCeilingKeelHangingDrawingConverter extends LevelingCeilingKeelBaseDrawingConverter {
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        protected drawingRoomLingCeillingsAsync(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[], parent?: ContentNode): Promise<void>;
        protected drawingTestMergeAsync(context: DrawingNodeContext, nodes: WareNode[], fillEnable: boolean): Promise<void>;
        protected dimensionSuggestionMergeAsync(context: IContext, nodes: DynamicWareNode[], parent: ContentNode): Promise<void>;
        protected getPelmetKeels(node: ContentNode): Array<FamilyInstanceNode>;
        protected drawPelmetOutline(levelingceil: ContentNode): void;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected getObjects(node: ContentNode): Types<FamilyInstanceNode>;
        drawNodeCenterText(projectionMatrix: Matrix4, node: ContentNode, content: string, rotationZ: number, style?: any, drawingLevel?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingProfileDrawingConverter" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDrawingConverter";
    export class LevelingCeilingProfileDrawingConverter extends LevelingCeilingDrawingConverter {
        protected computeDrawingAsync(context: DrawingNodeContext, levelingCeiling: DynamicWareNode): Promise<any>;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingSurfaceDrawingConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingCeilingPlankDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingPlankDrawingConverter";
    export class LevelingCeilingSurfaceDrawingConverter extends LevelingCeilingPlankDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        canConvert(node: BrepNode, option?: any): boolean;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingRoomLingCeillings(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): void;
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingSurveyDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { ReferenceLineNode } from 'sk/data/family/model/assistant/reference/ReferenceLineNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { AssembleRoomNode } from "sk/data/scheme/database/pattern/node/AssembleRoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeValueLineData } from "sk/data/scheme/drawing/data/DrawingNodeValueLineData";
    import { LevelingCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDrawingConverter";
    export class LevelingCeilingSurveyDrawingConverter extends LevelingCeilingDrawingConverter {
        protected baseSpace: number;
        constructor(domain?: DrawingDomainNode);
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        canConvert(node: BrepNode, option?: any): boolean;
        protected computeDrawingAsync(context: DrawingNodeContext, levelingCeiling: ContentNode): Promise<void>;
        protected appendBoundaryReactByPoints(points: Vector2[]): Box2;
        protected drawingRoomLingCeillingsAsync(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): Promise<void>;
        protected drawingLevelingCeilingAsync(context: IContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected getPelmetSurveyContainers(room: AssembleRoomNode): ContainerNode[];
        protected drawPelmetSurvey(room: AssembleRoomNode, observeMatrix: Matrix4): void;
        protected drawingDimentionsMerge(document: DrawingDataDocument, nodes: DynamicWareNode[]): LineCurveDimensionDrawingNode[];
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
        protected drawingLine(document: DrawingDataDocument, container: WareNode): void;
        protected drawingExpansionBoltAsync(context: IContext, document: DrawingDataDocument, container: WareNode): Promise<void>;
        protected drawingLineByVectors(document: DrawingDataDocument, begin: Vector3, end: Vector3): LineCurve2dDrawingNode;
        protected buildDimentionVectors(container: WareNode): Types<Vector3>;
        private drawingLines;
        protected buildSurveyContainersDimensions(containers: WareNode[], matrixp?: Matrix4, borderBox?: Box2): void;
        protected buildDimensionsByReferenceLines(all: any, base: number, boundaryBox: Box2, matrixp?: Matrix4): void;
        protected buildDimensions(node: WareNode, matrixp?: Matrix4): void;
        protected cutPointsByBoundary(points: Vector2[], boundary: Box2, property: string): void;
        protected getBorderPointsByRefercenceLines(node: ContentNode, box: Box2, lines: Array<ReferenceLineNode>, matrixp?: Matrix4, getLineValue?: boolean): void;
        protected buildDimensionGroupByReferenceLines(node: ContentNode, linesGroup: Array<Array<ReferenceLineNode>>, base: number, level: number, space: number, style: any, box: Box2, remarks?: Array<string>, matrixp?: Matrix4): void;
        protected buildDimensionByReferenceLines(node: ContentNode, lines: Array<ReferenceLineNode>, base: number, level: number, space: number, style: any, box: Box2, remark?: string, matrixp?: Matrix4): void;
        protected fetechDrawingCodeStart(lines: Array<ReferenceLineNode>, code: string, refRemarks?: Array<string>): Array<Array<ReferenceLineNode>>;
        protected linesToValueLineDataByNode(node: ContentNode, lines: Array<ReferenceLineNode>, matrixp?: Matrix4): DrawingNodeValueLineData[];
        protected linesToPointByNode(node: ContentNode, lines: Array<ReferenceLineNode>, ref?: Array<Vector2>, matrixp?: Matrix4): Array<Vector2>;
        splitReferenceLinesByDrawingCodesFromNodes(nodes: WareNode[], targetCodes: string[]): any;
        combineSplitlines(splitLinesArray: any[]): any;
        splitReferenceLineByDrawignCodes(node: WareNode, targetCodes: string[]): any;
        protected getRemarkByCode(code: string, text?: string): string;
        protected getRemarkByCodes(codes: Array<string>, text?: string): string;
        protected getRoomAndBeamPoints(): any[];
        protected borderPointsMerge(bpsList: Array<any>): any;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingfloor/LevelingFloorBaseLayerDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { LevelingFloorNode } from "sk/data/scheme/database/pattern/node/LevelingFloorNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingFloorDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingFloorDrawingConverter";
    type PlankOutPoints = {
        targetX: Types<number>;
        targetY: Types<number>;
    };
    export class LevelingFloorBaseLayerDrawingConverter extends BaseLevelingFloorDrawingConverter {
        processAsync(context: DrawingNodeContext, node: LevelingFloorNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected drawingLevelingFloor(context: DrawingNodeContext, document: DrawingDataDocument, node: WareNode, lastName?: string): void;
        protected checkFromDoor(node: WareNode): boolean;
        protected drawDynamicRoom(context: DrawingNodeContext, roomDynamicWare: ContentNode): void;
        protected drawWallsCompleteLines(context: DrawingNodeContext, walls: ContentNode[], style?: any, drawingLevel?: number): void;
        protected drawSurface2PlankDim(lines: Line2[]): PlankOutPoints;
        protected getDimensions(allFloors: Array<ContentNode>): Array<WareNode>;
        private drawingArrow;
        private drawFloorArrow;
        private computeInnerWallPoints;
        private drawingHoles;
        protected drawingTechnologyHole(document: DrawingDataDocument, hole: TechnologyHoleNode, isReturn?: boolean, observerMatrix?: Matrix4, style?: any): Vector2[];
        private drawingSizeText;
        private drawingHoleDimension;
        protected pointsTodimesions1(points: Array<Vector2>, ref?: Array<any>, endMarkOption?: any): Array<any>;
        private createDimPoints;
        private getClosePerpendicularIntersectTowPoints;
        private getCloseIntrPoint;
        private sortPoinesByDistance;
        private drawingHoleAndGetCenter;
        private drawingRectHole;
        protected buildDimensionVectors(container: WareNode, context?: DrawingNodeContext): Types<Vector3>;
        private filterPoitnsWithOrderValue;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingfloor/LevelingFloorHardwareDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { LevelingFloorNode } from "sk/data/scheme/database/pattern/node/LevelingFloorNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingFloorDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingFloorDrawingConverter";
    export class LevelingFloorHardwareDrawingConverter extends BaseLevelingFloorDrawingConverter {
        processAsync(context: DrawingNodeContext, node: LevelingFloorNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected drawingLevelingFloor(context: DrawingNodeContext, document: DrawingDataDocument, node: WareNode, nameLast?: string): void;
        protected buildDimensionVectors(container: WareNode): Types<Vector3>;
        protected getDimensions(allFloors: Array<ContentNode>): Array<WareNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceLayerDrawingConverter" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingWallFaceDrawingConverter } from "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceDrawingConverter";
    export class LevelingWallFaceLayerDrawingConverter extends LevelingWallFaceDrawingConverter {
        canConvert(node: DynamicWareNode, option?: any): boolean;
        protected findContainerByName2(node: DataNode, name: string, deep?: boolean): ContainerNode;
        protected computeDrawing(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): void;
        private drawStartDirection;
        protected drawArrowAtPoint(point: Vector2, direction: Vector2, width: number, height: number, style?: any): GeometricNode;
        protected drawingPolygonByVectors(document: DrawingDataDocument, vectors: Vector3[] | Vector2[], style?: any, drawingLevel?: number): PolygonCurve2dDrawingNode;
        protected getNodeProjectionSection(matrixw: Matrix4, matrixp: Matrix4, node: GeometricNode): SectionSurface;
        protected findHorizontalHighestLongestCurve(curves: Curve2d[]): Curve2d;
        protected drawingCurveLine(curve: Curve2d, style?: any, drawingLevel?: number): GeometricNode;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallSurveyLineDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ReferenceLineNode } from 'sk/data/family/model/assistant/reference/ReferenceLineNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { SurveyLineContainerDrawingConverter } from "sk/data/scheme/drawing/converter/common/SurveyLineContainerDrawingConverter";
    export class LevelingWallSurveyLineDrawingConverter extends SurveyLineContainerDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): ResultObject;
        protected computeDrawingDynamicNode(node: ContentInstanceNode, option?: any): any;
        protected drawLinkWallCode(levelwall: ContentNode, surveynode: ContainerNode, matrixp: Matrix4): void;
        protected fetchBorderLines(surveynode: ContainerNode): ReferenceLineNode[];
        protected findSurveContainer(node: ContentInstanceNode, containerName: string): ContainerNode;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallSurveyLineWithHardwareDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { CircleCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/CircleCurve2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingWallDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingWallDrawingConverter";
    import { LevelingWallSurveyLineDrawingConverter } from "sk/data/scheme/drawing/converter/levelingwall/LevelingWallSurveyLineDrawingConverter";
    export class LevelingWallSurveyLineWithHardwareDrawingConverter extends LevelingWallSurveyLineDrawingConverter {
        protected basewallConvert: BaseLevelingWallDrawingConverter;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): Promise<ResultObject>;
        protected buildContextObserveMatrix(context: DrawingNodeContext, node: BrepNode): void;
        protected computeDrawingDynamicWareNodeAsync(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): Promise<void>;
        drawHardwareAsync(context: DrawingNodeContext, node: ContentInstanceNode, containerName: string, style?: any, drawingLevel?: number): Promise<GeometricNode[]>;
        createHardwareSupportsAsync(context: DrawingNodeContext, node: ContentInstanceNode, matrixp: Matrix4, containerName: string, style?: any, drawingLevel?: number): Promise<GeometricNode[]>;
        protected drawPolygonHardware(node: ContentNode, matrixw: Matrix4, matrixp: Matrix4, style?: any, drawingLevel?: number): GeometricNode[];
        protected drawCircleHardware(node: ContentNode, matrixw: Matrix4, matrixp: Matrix4, style?: any, drawingLevel?: number): GeometricNode;
        protected drawOneHardware(node: ContentNode, matrixw: Matrix4, matrixp: Matrix4, style?: any, drawingLevel?: number): GeometricNode[];
        protected findHardwares(node: ContentInstanceNode, containerName: string): ContentNode[];
        protected checkCubeHardware(node: ContentNode): boolean;
        protected checkHardwareSupport(node: ContentNode, typeCode: string): boolean;
        protected checkCircleCollider(circle: CircleCurve2dDrawingNode, circles: CircleCurve2dDrawingNode[]): boolean;
        private drawKeelCode;
        protected checkKeelCodeDrawable(hardware: HardwareNode): boolean;
        protected createKeelCodeTextNode(keel: HardwareNode, context: DrawingNodeContext, types: Map<string, string>, replaceTypes: Array<string>): BrepNode;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceBaseLayerDrawingConverter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingWallFaceLayerDrawingConverter } from "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceLayerDrawingConverter";
    import { LevelingWallSurveyLineWithHardwareDrawingConverter } from "sk/data/scheme/drawing/converter/levelingwall/LevelingWallSurveyLineWithHardwareDrawingConverter";
    export class LevelingWallFaceBaseLayerDrawingConverter extends LevelingWallFaceLayerDrawingConverter {
        protected hardwareConvert: LevelingWallSurveyLineWithHardwareDrawingConverter;
        constructor(domain?: DrawingDomainNode);
        canConvert(node: ContentInstanceNode, option?: any): boolean;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): Promise<ResultObject>;
        processAsync(context: IContext, node: ContentInstanceNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceSurfaceLayerDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { LevelingWallFaceLayerDrawingConverter } from "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceLayerDrawingConverter";
    export class LevelingWallFaceSurfaceLayerDrawingConverter extends LevelingWallFaceLayerDrawingConverter {
        protected computeDrawing(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): ResultObject;
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): any;
        private drawFinishLines;
        private drawFinnishLine;
        private drawFinnishCeiling;
        private drawFinnishFloor;
        private findFinnishCeilingContainer;
        private findFinnishFloorContainer;
        private parseContainerNames;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceWithPlankDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { Plankgeos } from "sk/data/scheme/drawing/converter/base/BaseLevelingWallDrawingConverter";
    import { LevelingWallFaceDrawingConverter } from "sk/data/scheme/drawing/converter/levelingwall/LevelingWallFaceDrawingConverter";
    export class LevelingWallFaceWithPlankDrawingConverter extends LevelingWallFaceDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        canConvert(node: ContentInstanceNode, option?: any): boolean;
        protected computeDrawing(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): void;
        protected drawPlankGeos(node: ContentInstanceNode, matrixP: Matrix4, levelname: string, plankstyle?: any, holestyle?: any, planktextstyle?: any, plankdrawingLevel?: number, holedrawingLevel?: number, planktextdrawingLevel?: number): Plankgeos;
        protected drawPlanksSizeDimension(plankgeos: GeometricNode[], distance: number, style?: any, drawingLevel?: number): void;
        protected drawPlankSizeDimension(plankgeo: GeometricNode, distance: number, style?: any, drawingLevel?: number): GeometricNode[];
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): ResultObject;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallLayerDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class LevelingWallLayerDrawingConverter extends BaseDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): ResultObject;
        protected computeDrawing(node: ContentInstanceNode, option?: any): any;
        protected findContainers(node: ContentInstanceNode): GeometricNode[];
        protected drawContainers(nodes: GeometricNode[], matrixP: Matrix4, style?: any, showLevel?: number): GeometricNode[];
        protected drawContainerDetailDimensions(geonodes: GeometricNode[], box: Box2, distance: number, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[];
        protected drawOutlineDimensions(distance: number, box: Box2, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwall/LevelingWallSurveyLineNewDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { ReferenceLineNode } from 'sk/data/family/model/assistant/reference/ReferenceLineNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeValueLineData } from "sk/data/scheme/drawing/data/DrawingNodeValueLineData";
    import { SurveyLineContainerDrawingConverter } from "sk/data/scheme/drawing/converter/common/SurveyLineContainerDrawingConverter";
    export class LevelingWallSurveyLineNewDrawingConverter extends SurveyLineContainerDrawingConverter {
        processAsync(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingDynamicNodeAsync(node: ContentInstanceNode, option?: any): Promise<any>;
        protected drawLinkWallCode(levelwall: ContentNode, surveynode: ContainerNode, matrixp: Matrix4): void;
        protected fetchBorderLines(surveynode: ContainerNode): ReferenceLineNode[];
        protected findSurveContainer(node: ContentInstanceNode, containerName: string): ContainerNode;
        protected buildDimendsionsNew(node: ContainerNode, matrixp?: Matrix4): void;
        protected getBorderPointsByRefercenceLines(node: ContentNode, lines: Array<ReferenceLineNode>, matrixp?: Matrix4, getLineValue?: boolean): void;
        protected buildDimensionGroupByReferenceLinesNew(node: ContentNode, linesGroup: Array<Array<ReferenceLineNode>>, level: number, space: number, style: any, remarks?: Array<string>, matrixp?: Matrix4): Array<any>;
        private buildDimensionByReferencelines;
        private drawInnerDimension;
        private findPointArea;
        private sorValueLineDatas;
        private createInnerDimension;
        protected pointsSplitBorderNew(boundaryBox: Box2, points: Array<DrawingNodeValueLineData>, center?: Vector2, boxPointInclude?: boolean): any;
        private spilteLinesByLength;
        private checkIsSameLineAndCombine;
        private combineValueLineData;
        private getRefrenceLineBox;
        drawHardwareAsync(node: ContentInstanceNode, matrixp: Matrix4, containerName: string, style?: any, drawingLevel?: number): Promise<GeometricNode[]>;
        protected findHardwares(node: ContentInstanceNode, containerName: string): ContentNode[];
        protected checkHardwareSupport(node: ContentNode, typeCode: string): boolean;
        protected checkCubeHardware(node: ContentNode): boolean;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwalldrawing/content/BaseContentDrawingTransfer" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingGraphDocument } from 'sk/data/family/drawing/DrawingGraphDocument';
    import { DrawingGraphDocumentService } from 'sk/data/family/service/DrawingGraphDocumentService';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingNodeProjectionData } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class BaseContentDrawingTransfer extends InstanceObject {
        protected _document: DrawingDataDocument;
        protected _domain: DrawingDomainNode;
        protected _floorplan: FloorplanNode;
        protected drawingGraphDocuments: Dictionary<DrawingGraphDocument>;
        protected _schemeConfigService: SchemeConfigService;
        protected _drawingGraphDocumentService: DrawingGraphDocumentService;
        constructor(domain: DrawingDomainNode);
        setup(domain: DrawingDomainNode): void;
        get document(): DrawingDataDocument;
        protected appendChildNodesArray(children: DataNode[][]): void;
        protected appendChildNodes(children: Array<DataNode>): void;
        protected appendChildNode(child: DataNode): void;
        processAsync(context: DrawingNodeContext, levelingWall?: LevelingWallNode): Promise<ResultObject>;
        computeNodeResourceTypeByObserverData(node: ContentNode, matrix: Matrix4): DrawingNodeProjectionData;
        protected findNodeGraphicId(node: DataNode): string;
        protected drawFamilyInstancesByGraphIdAsync(nodes: DataNode[], observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption, checkValid?: boolean): Promise<Array<BrepNode>>;
        protected drawFamilyInstanceByGraphIdAsync(node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
        getGraphContentsAsync(graphId: string, type: string): Promise<DrawingGraphDocument>;
        convertGraphByIdTypeAsync(graphId: string, viewType: string, size: Value2, picMatrix: Matrix4, ref?: Array<BrepNode>): Promise<Array<BrepNode>>;
        protected creatFamilyInstanceByGraphIdAsync(node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwalldrawing/content/LevelingWallBeamTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/levelingwalldrawing/content/BaseContentDrawingTransfer";
    export class LevelingWallBeamTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        private _context;
        private _levelingWall;
        processAsync(context: DrawingNodeContext, levelingWall?: LevelingWallNode): Promise<ResultObject>;
        protected drawBeamAsync(levelingWall: LevelingWallNode): Promise<void>;
        private drawFilledBeam;
        private createFill;
        private getInstanceProfilePoints;
        private isIntersected;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwalldrawing/content/LevelingWallFillTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/levelingwalldrawing/content/BaseContentDrawingTransfer";
    export class LevelingWallFillTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        private _context;
        processAsync(context: DrawingNodeContext, levelingWall?: LevelingWallNode): Promise<ResultObject>;
        protected drawLevelingWallFillAsync(levelingWall: LevelingWallNode): Promise<void>;
        private getInstanceProfilePoints;
        private createFillsByWall;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwalldrawing/content/LevelingWallLayoutTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/levelingwalldrawing/content/BaseContentDrawingTransfer";
    export class LevelingWallLayoutTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        private _context;
        private _levelingWall;
        processAsync(context: DrawingNodeContext, levelingWall?: LevelingWallNode): Promise<ResultObject>;
        protected drawLevelingWallLayoutAsync(levelingWall: LevelingWallNode): Promise<void>;
        private processMaterialLayout;
        private drawTile;
        private drawPlank;
        private processPlankDecorateWall;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwalldrawing/content/LevelingWallOutDimensionTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/levelingwalldrawing/content/BaseContentDrawingTransfer";
    type BuildDimResult = {
        topDimLevel: number;
        bottomDimLevel: number;
        leftDimLevel: number;
        rightDimLevel: number;
    };
    export class LevelingWallOutDimensionTransfer extends BaseContentDrawingTransfer {
        style: any;
        private _context;
        private _levelingWall;
        constructor(domain: DrawingDomainNode);
        init(): void;
        processAsync(context: DrawingNodeContext, levelingWall?: LevelingWallNode): Promise<ResultObject>;
        protected buildOutlineDimensions(node: LevelingWallNode): BuildDimResult;
        protected computeOutlineBox(node: LevelingWallNode): Box2;
        getPlanksLines(node: LevelingWallNode): Array<Line2>;
        private processPlankDecorateWall;
        private processMaterialLayout;
        protected linesSplitBorder(boundary: Box2, lines: Line2[], center?: Vector2): Line2[][];
        protected removeRepeatLines(lines: Line2[]): Line2[];
        protected reSliceRepeatPoints(points: Vector2[], direction: Vector2): Vector2[];
        drawBorderDimensionLines(liness: any, dimsdistance: number, distance: number, style: any, drawingLevel: any): void;
        protected reSortPointsFromDirection(points: Vector2[], direction: Vector2): Vector2[];
        protected getLinesStartEnd(line: Line2[]): Array<Vector2>;
        protected sortLinesByLength(lines: Line2[]): void;
        protected buildDimensionsFromLinesNew201030(lines: Line2[], dimpointssortdirection: Vector2, dimsdistance: number, firstdimdistance?: number, firstborderpoint?: Vector2, lastborderpoint?: Vector2, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[][];
        protected computeDimPointsFromLinesAndBorder(lines: Line2[], pointssortdirection: Vector2, firstborderpoint?: Vector2, lastborderpoint?: Vector2): Vector2[];
        protected breakLinesByPoints(breakpoints: Vector2[], line: Line2): Line2[];
        protected buildFloorplanDimensions(node: BrepNode, style?: any): void;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected getFloorplanDimensionOutline(allDimsLiness: Line2[][]): Line2[][];
        protected removeInvalidLines(lines: Line2[]): Line2[];
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwalldrawing/LevelingWallElevationLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    export class LevelingWallElevationLayoutDrawingConverter extends BaseLevelingDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: LevelingWallNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
    }
}
declare module "sk/data/scheme/drawing/converter/levelingwalldrawing/util/LevelingWallDrawingUtil" {
    export class LevelingWallDrawingUtil {
    }
}
declare module "sk/data/scheme/drawing/converter/pelmet/PelmetProfileDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { PelmetNode } from "sk/data/scheme/database/pattern/node/PelmetNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class PelmetProfileDrawingConverter extends BaseDrawingConverter {
        protected drawWorkDim: boolean;
        protected _room: RoomNode;
        constructor(domain?: DrawingDomainNode);
        canConvert(node: BrepNode, option?: any): boolean;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected getRoomCelings(context: DrawingNodeContext, room: RoomNode): ContentNode[];
        protected computeDrawingAsync(context: DrawingNodeContext, pelmetNode: PelmetNode): Promise<void>;
        protected groups(nodes: Array<{
            p: ContentNode;
            c: Vector3;
        }>, distance: number): Array<{
            axis: Vector3;
            g: Array<{
                p: ContentNode;
                c: Vector3;
            }>;
        }>;
        protected drawingDimentionsLine(pc: {
            p: ContentNode;
            c: Vector3;
        }[], factor?: number): LeaderDrawingNode;
        textBoxs: Box2[];
        protected isCollision(textBox: Box2): boolean;
        protected outputBorder(surfaces: Array<SectionSurface>, color: string): Array<BrepNode>;
        protected outpuCurves(curves: Array<Curve2d>, color: string): void;
        protected drawingDimentions(points: Types<Vector3>, distance: Array<number>, lineLenght: number): LineCurveDimensionDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { LevelingCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/levelingceiling/LevelingCeilingDrawingConverter";
    export class ProxyCeilingDrawingConverter extends LevelingCeilingDrawingConverter {
        protected canConvertByName(node: BrepNode, name: string): boolean;
        protected getCeilElementId(node: ContentNode): string;
        protected findContainersByName(node: DataNode, name: string, deep?: boolean): ContainerNode[];
        protected findChildrenByType(type: Function, node: any, col: Types<any>): void;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingPlankDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingDrawingConverter";
    export class ProxyCeilingPlankDrawingConverter extends ProxyCeilingDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected drawingArrow(container: WareNode): void;
        findContainersByName(node: DataNode, name: string, recursive?: boolean, recursiveCount?: number): Array<ContainerNode>;
        protected drawingPelmetPlanks(document: DrawingDataDocument, node: ContentNode, name: string): ContainerNode[];
        protected drawingPelmetSurveyPlank(document: DrawingDataDocument, container: WareNode): void;
        drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingPlank(document: DrawingDataDocument, container: WareNode): void;
        private drawingPlankInnerDimension;
        protected polygonPointsTodimesions(points: Array<Vector2>): Array<any>;
        protected buildDimentionVectors(container: WareNode): Types<Vector3>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingBaseLayerDrawingConverter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingPlankDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingPlankDrawingConverter";
    export class ProxyCeilingBaseLayerDrawingConverter extends ProxyCeilingPlankDrawingConverter {
        canConvert(node: BrepNode, option?: any): boolean;
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingBaseLevelingCeilings(context: IContext, document: DrawingDataDocument, nodes: ContentNode[]): void;
        protected drawingBaseDimentions(document: DrawingDataDocument, nodes: ContentNode[]): LineCurveDimensionDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelBaseDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingDrawingConverter";
    export class ProxyCeilingKeelBaseDrawingConverter extends ProxyCeilingDrawingConverter {
        protected keels: Types<FamilyInstanceNode>;
        protected keeltypecodedict: Map<string, string>;
        protected replacetypecodearray: Array<string>;
        protected fillEnable: boolean;
        constructor(domain?: DrawingDomainNode);
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected splitKeelsNameCodeMap(keels: Types<FamilyInstanceNode>): Map<string, string>;
        protected drawingPlank(document: DrawingDataDocument, container: WareNode): void;
        protected drawingWallLines(document: DrawingDataDocument, cowalls: CowallNode[], workInstance?: boolean): void;
        protected buildDimentionVectors(container: WareNode): Types<Vector3>;
        protected drawWallCompleteLines(rootnode: BrepNode, style?: any, drawingLevel?: number): void;
        protected drawingWorkDistance(document: DrawingDataDocument, cowalls: CowallNode[]): void;
        protected drawDimensionsAsync(context: IContext, node: ContentNode): Promise<void>;
        protected dimensionSuggestionAsync(context: IContext, node: ContentNode): Promise<void>;
        protected drawFirstAsync(context: IContext, outlinePoints: Array<Vector2>): Promise<void>;
        protected checkNeedText(node: FamilyInstanceNode): boolean;
        protected checkConnectComponent(node: FamilyInstanceNode): boolean;
        protected makePointsAsync(context: IContext, dimensions: any): Promise<void>;
        protected makeDimension(outline: Vector2[], dimensions: any): void;
        protected buildDimensions1(dimension: any, points: Types<Vector2>, distance: number): void;
        protected buildDimensionNode1(from: Vector2, to: Vector2, dimPoint2d: Vector2, angle: number): LineCurveDimensionDrawingNode;
        protected drawingTestAsync(context: DrawingNodeContext, node: ContentNode, fillEnable: boolean): Promise<void>;
        protected drawEdgeKeelStartDirectionFromKeels(keels: Array<FamilyInstanceNode>): void;
        protected drawKeelsByGraphIDAsync(context: DrawingNodeContext, keels: Array<FamilyInstanceNode>): Promise<GeometricNode[]>;
        protected drawEdgeKeelStartDirection(keel: FamilyInstanceNode): void;
        protected checkEdgeKeel(keel: FamilyInstanceNode): boolean;
        protected createTextDimension(text: string, position: Vector2, style?: any): any;
        protected getObjects(node: ContentNode): any;
        protected findChildren(name: string, node: any, col: Types<any>): void;
        protected createPolygon(document: DrawingDataDocument, keelPoints: Vector2[][]): PolygonCurve2dDrawingNode[];
        protected drawDimensionsFromLinePoints(top: Vector2[], bottom: Vector2[], left: Vector2[], right: Vector2[], cellsize: number, style?: any, drawingLevel?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelHangingDrawingConverter" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingKeelBaseDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelBaseDrawingConverter";
    export class ProxyCeilingKeelHangingDrawingConverter extends ProxyCeilingKeelBaseDrawingConverter {
        protected drawingRoomLingCeillingsAsync(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): Promise<void>;
        protected drawingTestMergeAsync(context: DrawingNodeContext, nodes: WareNode[], fillEnable: boolean): Promise<void>;
        protected dimensionSuggestionMergeAsync(context: DrawingNodeContext, nodes: DynamicWareNode[]): Promise<void>;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected getObjects(node: ContentNode): any;
        protected findContainersByName(node: DataNode, name: string, deep?: boolean): ContainerNode[];
        protected makePointsAsync(context: DrawingNodeContext, dimensions: any): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingKeelBaseDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelBaseDrawingConverter";
    export class ProxyCeilingKeelLayerDrawingConverter extends ProxyCeilingKeelBaseDrawingConverter {
        protected cowallMaps: any;
        protected getObjects(node: ContentNode): Types<FamilyInstanceNode>;
        protected findContainersByName(node: DataNode, name: string, deep?: boolean): ContainerNode[];
        protected computeDrawingAsync(context: DrawingNodeContext, levelingCeiling: ContentNode): Promise<void>;
        protected drawingLinkRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected getCeilElementId(node: ContentNode): string;
        protected drawingPreformedAsync(context: DrawingNodeContext, node: ContentNode): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerBorderDrawingConverter" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingKeelLayerDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerDrawingConverter";
    export class ProxyCeilingKeelLayerBorderDrawingConverter extends ProxyCeilingKeelLayerDrawingConverter {
        protected findContainersByName(node: DataNode, name: string, deep?: boolean): ContainerNode[];
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerBorderCodeDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingKeelLayerBorderDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerBorderDrawingConverter";
    export class ProxyCeilingKeelLayerBorderCodeDrawingConverter extends ProxyCeilingKeelLayerBorderDrawingConverter {
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: BrepNode): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerCenterDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingKeelLayerDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerDrawingConverter";
    export class ProxyCeilingKeelLayerCenterDrawingConverter extends ProxyCeilingKeelLayerDrawingConverter {
        protected planks: Types<FamilyInstanceNode>;
        protected findContainersByName(node: DataNode, name: string, deep?: boolean): ContainerNode[];
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingPelmetPlanksAsync(document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingPelmetSurveyPlank(document: DrawingDataDocument, container: WareNode): void;
        protected makePelmetPlanksPoints(dimensions: any): void;
        protected makePointsAsync(context: DrawingNodeContext, dimensions: any): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerCenterCodeDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingKeelLayerCenterDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingKeelLayerCenterDrawingConverter";
    export class ProxyCeilingKeelLayerCenterCodeDrawingConverter extends ProxyCeilingKeelLayerCenterDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: BrepNode): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingProfileDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { AssembleCeilingEdgeNode } from "sk/data/scheme/database/pattern/node/AssembleCeilingEdgeNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { ProxyCeilingNode } from "sk/data/scheme/database/pattern/node/ProxyCeilingNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingDrawingConverter";
    export class ProxyCeilingProfileDrawingConverter extends ProxyCeilingDrawingConverter {
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, levelingCeiling: ProxyCeilingNode): Promise<void>;
        protected drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected findNearlyWall(edge: AssembleCeilingEdgeNode, levelingCeiling: ProxyCeilingNode): LevelingWallNode;
        protected findNearlyCoWall(edge: AssembleCeilingEdgeNode, room: RoomNode): CowallNode;
        protected outputBorder(surfaces: Array<SectionSurface>, color: string): Array<BrepNode>;
        protected outpuCurves(curves: Array<Curve2d>, color: string): void;
        protected drawingDimentions1(points: Types<Vector3>, distance: Array<number>, lineLenght: number): LineCurveDimensionDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingSurfaceDrawingConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingPlankDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingPlankDrawingConverter";
    export class ProxyCeilingSurfaceDrawingConverter extends ProxyCeilingPlankDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        canConvert(node: BrepNode, option?: any): boolean;
        drawingLevelingCeilingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingRoomLingCeillings(context: DrawingNodeContext, document: DrawingDataDocument, nodes: ContentNode[]): void;
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingSurveyDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { ProxyCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingDrawingConverter";
    export class ProxyCeilingSurveyDrawingConverter extends ProxyCeilingDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected computeDrawingAsync(context: DrawingNodeContext, levelingCeiling: ContentNode): Promise<void>;
        protected computeRoomDrawingAsync(context: DrawingNodeContext, room: RoomNode, option?: any): Promise<void>;
        canConvert(node: BrepNode, option?: any): boolean;
        protected drawingRoomLingCeillingsAsync(context: IContext, document: DrawingDataDocument, nodes: ContentNode[]): Promise<void>;
        protected drawingLevelingCeilingAsync(context: IContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected drawingDimentions1(document: DrawingDataDocument, nodes: ContainerNode[]): LineCurveDimensionDrawingNode[];
        protected drawingDimentionsMerge(document: DrawingDataDocument, nodes: ContainerNode[]): LineCurveDimensionDrawingNode[];
        protected getBorderPoints(node: ContentNode): Array<Vector3>;
        protected drawingLine(document: DrawingDataDocument, container: ContainerNode): void;
        protected drawingExpansionBoltAsync(context: IContext, document: DrawingDataDocument, container: ContainerNode): Promise<void>;
        protected buildDimentionVectors1(container: ContainerNode): Types<Vector3>;
        protected drawingBorderLine1(document: DrawingDataDocument, container: ContainerNode): void;
        protected drawingLineByVectors(document: DrawingDataDocument, begin: Vector3, end: Vector3): LineCurve2dDrawingNode;
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingSurveyBorderDrawingConverter" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ProxyCeilingSurveyDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingSurveyDrawingConverter";
    export class ProxyCeilingSurveyBorderDrawingConverter extends ProxyCeilingSurveyDrawingConverter {
        findContainersByName(node: DataNode, name: string, deep?: boolean): ContainerNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingSurveyCenterDrawingConverter" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ProxyCeilingSurveyDrawingConverter } from "sk/data/scheme/drawing/converter/proxyceiling/ProxyCeilingSurveyDrawingConverter";
    export class ProxyCeilingSurveyCenterDrawingConverter extends ProxyCeilingSurveyDrawingConverter {
        findContainersByName(node: DataNode, name: string, deep?: boolean): ContainerNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/room/RoomMappingDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    export class RoomMappingDrawingConverter extends BaseLevelingDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: RoomNode): Promise<ResultObject<DrawingDataDocument>>;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawingMappingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: RoomNode): Promise<void>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: RoomNode): Promise<any>;
        protected drawingRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: RoomNode): Promise<void>;
        protected drawingRoomTestSkDbAsync(document: DrawingDataDocument, node: RoomNode): Promise<void>;
        protected computeVectorsByBoundary(box: BoundaryBox): Vector3[];
        computeDomainBoundary(): void;
    }
}
declare module "sk/data/scheme/drawing/converter/room/RoomFloorMappingDrawingConverter" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { RoomMappingDrawingConverter } from "sk/data/scheme/drawing/converter/room/RoomMappingDrawingConverter";
    export class RoomFloorMappingDrawingConverter extends RoomMappingDrawingConverter {
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected drawingMappingAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: RoomNode): Promise<void>;
        private drawingMeasure;
        private drawingHoleBorderDimension;
        private drawingLineDimension;
        private getRoomMinPoints;
        private drawingDiameterDimension;
        private drawingHole;
        private findTechnologyHoleNode;
        private getMeasuresAsync;
    }
}
declare module "sk/data/scheme/drawing/converter/room/RoomSmallBoxMarkPointDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    export class RoomSmallBoxMarkPointDrawingConverter extends BaseLevelingDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: BrepNode): ResultObject<DrawingDataDocument>;
        protected computeDrawing(context: DrawingNodeContext, node: BrepNode): any;
        private drawCompeletedSurfaceLine;
        protected createFlatWallKeelSurveys(floorplan: FloorplanNode, style: any): GeometricNode[];
        protected computeKeelHardwareKeyPoints(flatwalls: FlatWallNode[]): Vector2[];
        private computeHardwareCenter;
        protected findSurveyKeels(node: DataNode): HardwareNode[];
        private createMarkPoitnNodes;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { RoomInfo } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { BaseFinishLineDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDrawingConverter";
    export type BuildDimResult = {
        topDimLevel: number;
        bottomDimLevel: number;
        leftDimLevel: number;
        rightDimLevel: number;
    };
    export class BaseFinishLineDynamicDrawingConverter extends BaseFinishLineDrawingConverter {
        protected createTextsByRoomInfos(infos: Array<RoomInfo>, textHeight?: number): Array<TextControlNode>;
        protected reSliceRepeatPoints(points: Vector2[], direction: Vector2): Vector2[];
        protected reSortPointsFromDirection(points: Vector2[], direction: Vector2): Vector2[];
        protected drawWallAndLineDistanceDim(line: Line2, dynamicware: ContentNode, dimstyle?: any, drawingLevel?: number): void;
        protected nodeGetCowalls(node: BrepNode): CowallNode[];
        protected computeFloorplanNodeOutlineBox(node: FloorplanNode): Box2;
        protected computeNodeOutlineBox(node: BrepNode): Box2;
        protected computeNodeOutlinePoints(node: BrepNode): Vector2[];
        protected nodeGetBeams(node: BrepNode): BeamNode[];
        protected nodeGetColumns(node: BrepNode): ColumnNode[];
        protected computeContentsDimPoints(contents: ContentNode[]): Vector2[];
        protected computeContentsTopDimLines(contents: ContentNode[]): Line2[];
        protected computeContentDimPoints(content: ContentNode): Vector2[];
        protected computeContentTopDimLines(content: ContentNode): Line2[];
        protected findFloorRoomNodeContentsWithoutOpenings(node: BrepNode, excludearray?: Array<Function>, onlyincludearray?: Array<Function>): Array<ContentNode>;
        protected buildFloorRoomNodeDimensionsAll(node: BrepNode, dimsdistance: number, style?: any, includeContents?: boolean, wallbreakbyOpenings?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, firstdimdistance?: number, drawingLevel?: number): void;
        protected buildFloorRoomNodeDimensionsAllNew201030(node: BrepNode, dimsdistance: number, style?: any, includeContents?: boolean, wallbreakbyOpenings?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, firstdimdistance?: number, drawingLevel?: number): void;
        protected computeContentsTopOutlineBoundary(node: BrepNode, includeContents: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>): Box2;
        protected computeDynamicStyle(style: any, codes: string[], defaultvalues: number[]): any;
        protected computeBoundaryArea(boundary: Box2): number;
        protected createFlatWallsOutlineDimLines(node: BrepNode, wallbreakbyOpenings?: boolean): Line2[];
        protected createFlatWallOutlineDimLines(flatwall: FlatWallNode, wallbreakbyOpenings?: boolean, cutsurface?: SectionSurface): Line2[];
        protected convertLineCurves2Line2s(linecurves: LineCurve2d[]): Line2[];
        protected buildFloorRoomNodeDimensions(node: BrepNode, boundary: Box2, dimsdistance: number, firstdimdistance?: number, wallbreakbyOpenings?: boolean, includeOutlineDim?: boolean, includeContents?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, style?: any, drawingLevel?: number): BuildDimResult;
        protected sortRooms(node: FloorplanNode): RoomNode[];
        protected getLinesStartEnd(line: Line2[]): Array<Vector2>;
        protected fetchRoomSingleCowall(room: RoomNode): any[];
        getValidSurface(cowall: CowallNode): WallSurfaceNode;
        protected buildFloorRoomNodeDimensionsNew201030(node: BrepNode, boundary: Box2, dimsdistance: number, firstdimdistance?: number, wallbreakbyOpenings?: boolean, includeOutlineDim?: boolean, includeContents?: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>, style?: any, drawingLevel?: number): BuildDimResult;
        protected createNodesOutlineDimLines(nodes: FamilyInstanceNode[]): Line2[];
        protected createNodeOutlineDimLines(node: FamilyInstanceNode): Line2[];
        protected sortLinesByLength(lines: Line2[]): void;
        protected computeCowallsOutlineBoundary(cowalls: CowallNode[]): Box2;
        protected buildDimensionsFromLinesNew(lines: Line2[], dimpointssortdirection: Vector2, dimsdistance: number, firstdimdistance?: number, firstborderpoint?: Vector2, lastborderpoint?: Vector2, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[][];
        protected buildDimensionsFromLinesNew201030(lines: Line2[], dimpointssortdirection: Vector2, dimsdistance: number, firstdimdistance?: number, firstborderpoint?: Vector2, lastborderpoint?: Vector2, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[][];
        protected computeDimPointsFromLinesAndBorder(lines: Line2[], pointssortdirection: Vector2, firstborderpoint?: Vector2, lastborderpoint?: Vector2): Vector2[];
        protected combineLinesNew(lines: Line2[]): Line2[][];
        protected checkLineLinesIntersection(line: Line2, lines: Line2[]): boolean;
        linesIntersection(line1: Line2, line2: Line2): boolean;
        isPointOnLine(point: Vector2, line: Line2, includeLineEndpoint?: boolean, tolerance?: number): boolean;
        protected createCowallsOutlineDimLines(cowalls: CowallNode[], wallbreakbyOpenings?: boolean): Line2[];
        protected createGroupCowallOutlineDimLines(groupcowalls: CowallNode[], includeopenings?: boolean): Line2[];
        protected computeRelinkLines(lines: Line2[]): Line2;
        protected reLinkLines(lines: Line2[]): Line2;
        protected createOutlineDimLinesFromPoints(innerfrom: Vector2, innerto: Vector2, outerfrom: Vector2, outerto: Vector2, outlinebreakpoints?: any[]): Line2[];
        protected breakLinesByPoints(breakpoints: Vector2[], line: Line2): Line2[];
        protected createSingleCowallOutlineDimLinesNew201030(cowall: CowallNode, wallbreakbyOpenings?: boolean): Line2[];
        protected createSingleCowallOutlineDimLines(cowall: CowallNode, wallbreakbyOpenings?: boolean): Line2[];
        protected computeSingleCowallRoomInfo(cowall: CowallNode): any;
        protected computeSingleCowallRoomInfoNew201030(cowall: CowallNode): any;
        protected computeCowallInnerOuterLineFromSingleCowall(cowallroominfo: any, singlecowallroominfo: any, istojoiner?: boolean): any;
        protected lineCut(line: Line2, cutpoint: Vector2, cutdirection: Vector2, cutend?: boolean): Line2;
        protected needCutDimCowall(cowall: CowallNode): boolean;
        protected checkCutDimCowall(joiner: WallJoinnerNode, cowall: CowallNode): boolean;
        protected getCutCowall(joiner: WallJoinnerNode, cowall: CowallNode): CowallNode;
        protected computeCowallLineFromJoiner2OtherJoiner(joiner: WallJoinnerNode, cowall: CowallNode): Line2;
        protected computeJoiner2OtherJoinerLine(joiner: WallJoinnerNode, otherjoiner: WallJoinnerNode): Line2;
        protected getOtherJoiner(joiner: WallJoinnerNode, cowall: CowallNode): WallJoinnerNode;
        protected checkCowallOrPartnerIsCowall(cowall: CowallNode, id: string): boolean;
        protected checkSingleCowall(cowall: CowallNode): boolean;
        protected getOpeningDimPoints(opening: OpeningNode): Vector2[];
        protected findColumns(node: FloorplanNode): DataNode[];
        protected buildFloorplanDimensions(node: BrepNode, style?: any): void;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected afterCompute(context: DrawingNodeContext): void;
        protected preCompute(context: DrawingNodeContext, node: BrepNode): void;
        protected prepareDynamicData(context: DrawingNodeContext, node: BrepNode): void;
        protected getStandardBoundary(): Box2;
        protected getStandardDomainBoundary(): Box2;
        protected computeStandardScale(): number;
        protected computeNscale(node: BrepNode): number;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected dynamicAdjustBoundary(): void;
        protected reSetFontSize(nscale: number): void;
        protected linesSplitBorder(boundary: Box2, lines: Line2[], center?: Vector2): Line2[][];
        protected removeRepeatLines(lines: Line2[]): Line2[];
        protected removeInvalidLines(lines: Line2[]): Line2[];
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingGraphDocument } from 'sk/data/family/drawing/DrawingGraphDocument';
    import { DrawingGraphDocumentService } from 'sk/data/family/service/DrawingGraphDocumentService';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingNodeProjectionData } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class BaseContentDrawingTransfer extends InstanceObject {
        protected _document: DrawingDataDocument;
        protected _domain: DrawingDomainNode;
        protected _floorplan: FloorplanNode;
        protected drawingGraphDocuments: Dictionary<DrawingGraphDocument>;
        protected _schemeConfigService: SchemeConfigService;
        protected _drawingGraphDocumentService: DrawingGraphDocumentService;
        constructor(domain: DrawingDomainNode);
        setup(domain: DrawingDomainNode): void;
        get document(): DrawingDataDocument;
        protected appendChildNodesArray(children: DataNode[][]): void;
        protected appendChildNodes(children: Array<DataNode>): void;
        protected appendChildNode(child: DataNode): void;
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        computeNodeResourceTypeByObserverData(node: ContentNode, matrix: Matrix4): DrawingNodeProjectionData;
        protected findNodeGraphicId(node: DataNode): string;
        protected drawFamilyInstancesByGraphIdAsync(nodes: DataNode[], observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption, checkValid?: boolean): Promise<Array<BrepNode>>;
        protected drawFamilyInstanceByGraphIdAsync(node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
        getGraphContentsAsync(context: ContextObject, graphId: string, type: string): Promise<DrawingGraphDocument>;
        convertGraphByIdTypeAsync(context: ContextObject, graphId: string, viewType: string, size: Value2, picMatrix: Matrix4, ref?: Array<BrepNode>): Promise<Array<BrepNode>>;
        protected creatFamilyInstanceByGraphIdAsync(node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/util/FloorPlanDrawingUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DecorateSurfaceLineInfo } from "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil";
    export class FloorPlanDrawingUtil {
        static getBaseSurfaceLine(decorateSurfacelines: Array<DecorateSurfaceLineInfo>): Array<Vector2>;
        static drawDotLines(document: DrawingDataDocument, lineFrom: Vector2, lineTo: Vector2, style: any, solid?: number, gap?: number): Array<LineCurve2dDrawingNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanBaseFinishLineDimensionTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanBaseFinishLineDimensionTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        private addRoomsDim;
        private addRoomAllDims;
        private addFinishLineDisDim;
        private addRoomInnerDim;
        private findWalSurface;
        private findNearLine;
        private parallelAndProject;
        private findFinishLine;
        private addDimToOpenings;
        protected getInstanceProfilePoints(familyInstance: FamilyInstanceNode): Vector2[];
        private cutLineWithPoints;
        private cutLine;
        private addDim;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanBaseFinishLineTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanBaseFinishLineTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected drawFloorplanLevelingWallFinishLineAsync(floorplan: FloorplanNode): Promise<void>;
        protected drawLevelingWallFinishLine(room: RoomNode): void;
        private getBeamBasePolygon;
        protected drawFlatWallAsync(flatwall: LevelingWallNode, observeMatrix?: Matrix4, withwhitebg?: boolean, flatwalloutlines?: Array<Vector2>, cutsurface?: SectionSurface, roomnode?: RoomNode): Promise<BrepNode[]>;
        protected drawLines(floorPolygon: Array<Vector2>, style: any): void;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanBaseInformationTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DecorateSurfaceLineInfo } from "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { LevelingWallTypeEnumEnum } from "sk/data/scheme/database/pattern/element/LevelingWallTypeEnumEnum";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanBaseInformationTransfer extends BaseContentDrawingTransfer {
        private _context;
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected drawFloorplanLevelingWallInformationAsync(floorplan: FloorplanNode): Promise<void>;
        private writeInformation;
        protected drawLevelingWallInformation(room: RoomNode): void;
        protected drawInformation(decorateSurfacelines: Array<DecorateSurfaceLineInfo>): void;
        protected isWallTypeSame(room: RoomNode): LevelingWallTypeEnumEnum;
        private getLevelingWallType;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorPlanBeamTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorPlanBeamTransfer extends BaseContentDrawingTransfer {
        protected informationVisible: boolean;
        constructor(domain: DrawingDomainNode, visible?: boolean);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected getFamilyInstancesByViewType(viewtype: DrawingViewTypeEnum, floorplan: FloorplanNode): FamilyInstanceNode[];
        protected createBeamsInfos(instances: FamilyInstanceNode[], pos?: Vector2, textHeight?: number): void;
        private drawBeam;
        protected getInstanceProfilePoints(familyInstance: FamilyInstanceNode): Vector2[];
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorPlanColumnTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorPlanColumnTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected getFamilyInstancesByViewType(viewtype: DrawingViewTypeEnum, floorplan: FloorplanNode): FamilyInstanceNode[];
        protected createBeamsInfos(instances: FamilyInstanceNode[], pos?: Vector2, textHeight?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorPlanContentInfoDrawingTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export type TextInfo = {
        x: number;
        y: number;
        length: number;
        width: number;
        height: number;
        area: number;
        name: string;
        identifier: string;
    };
    export class FloorPlanContentInfoDrawingTransfer extends BaseContentDrawingTransfer {
        infos: Array<TextInfo>;
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        getTextCenter(floorplan: FloorplanNode): Vector2;
        pushInfos(info: TextInfo): void;
        protected computeFloorplanNodeOutlineBox(node: FloorplanNode): Box2;
        protected dividedInfo(info: TextInfo): Array<TextInfo>;
        protected createTextsByInfos(): Array<TextControlNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanDecorateFinishLineDimensionTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanDecorateFinishLineDimensionTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        private addRoomsDim;
        private addRoomAllDims;
        private addFinishLineDisDim;
        private addRoomInnerDim;
        private findWalSurface;
        private findNearLine;
        private parallelAndProject;
        private findFinishLine;
        private addDimToOpenings;
        protected getInstanceProfilePoints(familyInstance: FamilyInstanceNode): Vector2[];
        private cutLineWithPoints;
        private cutLine;
        private addDim;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanDecorateFinishLineTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanDecorateFinishLineTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected drawFloorplanLevelingWallFinishLineAsync(floorplan: FloorplanNode): Promise<void>;
        protected drawLevelingWallFinishLine(room: RoomNode): void;
        protected drawLines(floorPolygon: Array<Vector2>, style: any): void;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanDecorateInformationTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { DecorateSurfaceLineInfo } from "sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanDecorateInformationTransfer extends BaseContentDrawingTransfer {
        private _context;
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected drawDecorateInformationAsync(context: DrawingNodeContext, floorplan: FloorplanNode): Promise<void>;
        private writeInformationAsync;
        protected drawDecorateLayerInformation(room: RoomNode): void;
        protected drawInformationAsync(decorateSurfacelines: Array<DecorateSurfaceLineInfo>): Promise<void>;
        protected isDecorateTypeSameAsync(room: RoomNode): Promise<string>;
        protected loadGoodsDataAsync(element: ContentInstanceElement): Promise<string>;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorPlanFlatwallTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorPlanFlatwallTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected drawFloorplanFlatWallsDim(floorplan: FloorplanNode): void;
        protected drawFloorplanFlatWallAsync(floorplan: FloorplanNode, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean, breakbyopening?: boolean): Promise<void>;
        protected drawFlatWallsAsync(flatwalls: FlatWallNode[], observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwallsoutlines?: Array<Vector2>): Promise<BrepNode[]>;
        protected drawFlatWallAsync(flatwall: FlatWallNode, observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwalloutlines?: Array<Vector2>, cutsurface?: SectionSurface, roomnode?: RoomNode): Promise<BrepNode[]>;
        protected drawFloorplanFlatWallsText(floorplan: FloorplanNode, textHeight?: number, dimBoxs?: Box2[]): void;
        protected drawFlatWallCode(flatwall: FlatWallNode, textHeight?: number, cutsurface?: SectionSurface, roomnode?: RoomNode): {
            codeText: BrepNode[];
            nameText: LeaderDrawingNode[];
        };
        protected drawFlatWallCodeText(flatwallnode: FlatWallNode, innerdirection: Vector2, cutsurface?: SectionSurface, roomnode?: RoomNode, textHeight?: number): LeaderDrawingNode[];
        protected flatwallTextOffset(flatwallAndNames: {
            flatwall: FlatWallNode;
            leader: LeaderDrawingNode;
        }[], textHeight?: number, dimBoxs?: Box2[]): void;
        protected computeLeaderTextBox(point: Value2, text: string, textHeight: number): Box2;
        protected offsetFlatWallText(curLeaderAndBox: {
            leader: LeaderDrawingNode;
            box: Box2;
        }, offsetDir: Vector2, offsetStep: number, leaderAndBoxs: {
            leader: LeaderDrawingNode;
            box: Box2;
        }[], boxs: Box2[], textHeight: number, offsetArr?: Vector2[], curOffsetCount?: number, originPoint?: Value2): void;
        protected computeOffsetArr(offsetDir: Value2, offsetCount: number): Array<any>;
        private fillFlatWallTexture;
        protected drawFlatWallDimensions(floorplan: FloorplanNode): void;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorPlanOpeningTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorPlanOpeningTransfer extends BaseContentDrawingTransfer {
        protected informationVisible: boolean;
        constructor(domain: DrawingDomainNode, visible?: boolean);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected getFamilyInstancesByViewType(viewtype: DrawingViewTypeEnum, floorplan: FloorplanNode): FamilyInstanceNode[];
        protected createInstanceInfos(instances: FamilyInstanceNode[], code?: string, textHeight?: number): void;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanRoomInnerDimensionTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanRoomInnerDimensionTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        private addRoomsDim;
        private addRoomAllDims;
        private addRoomInnerDim;
        private addColumnDim;
        private removeDimsToColumns;
        private addDimToOpenings;
        protected getInstanceProfilePoints(familyInstance: FamilyInstanceNode): Vector2[];
        private cutLineWithPoints;
        private cutLine;
        private addDim;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorPlanRoomTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { RoomInfo } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorPlanRoomTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected createTextsByRoomInfos(infos: Array<RoomInfo>, textHeight?: number): Array<TextControlNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/WallTypEnum" {
    export class WallTypeEnum {
        static brickWall: string;
        static steelWall: string;
        static reinforcedConcreteWall: string;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorPlanSteelwallFillTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorPlanSteelwallFillTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        private fillFlatWall;
        private fillTexture;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanWallFillDrawingTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { Fill2dDrawingNode } from 'sk/data/family/model/brep/drawing/Fill2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanWallFillDrawingTransfer extends BaseContentDrawingTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        protected wallsFilterInvalid(walls: WallNode[]): WallNode[];
        protected fetchFloorplanAllWalls(floorplan: FloorplanNode): DataNode[];
        protected drawingWalls(document: DrawingDataDocument, walls: Array<WallNode>, fillEnable: boolean, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean): void;
        protected createFillsByWall(document: DrawingDataDocument, dpolygons: PolygonCurve2dDrawingNode[], id: string): Fill2dDrawingNode[];
        protected createWallPolygonsWithoutOpening(document: DrawingDataDocument, walls: Array<WallNode> | Array<CowallNode>, wallPoints: Vector2[][], observeMatrix?: Matrix4): PolygonCurve2dDrawingNode[];
        protected computeWallsZindex(walls: Array<WallNode>, observeMatrix?: Matrix4): number;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanWallOutDimensionsTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { WallJoinnerNode } from "sk/data/scheme/database/floorplan/model/WallJoinnerNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { RoomInfo } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { BuildDimResult } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanWallOutDimensionsTransfer extends BaseContentDrawingTransfer {
        style: any;
        constructor(domain: DrawingDomainNode);
        init(): void;
        processAsync(context: DrawingNodeContext, floorplan?: FloorplanNode): Promise<ResultObject>;
        getContentsLines(node: BrepNode, contentsOnlyIncludeArray: Array<Function>): Array<Array<Line2>>;
        getOutBorderCowalls(node: BrepNode): Array<CowallNode>;
        getCowallInnerLine(cowall: CowallNode): Line2;
        getCowallOuterLine(cowall: CowallNode): Line2;
        drawBorderDimensionLines(liness: any, dimsdistance: number, distance: number, style: any, drawingLevel: any): void;
        protected combineLines(beamLines: Array<Array<Line2>>, cowallLines: Array<Line2>): Array<Line2>;
        protected buildFloorOutlineDimensions(node: BrepNode): BuildDimResult;
        protected createTextsByRoomInfos(infos: Array<RoomInfo>, textHeight?: number): Array<TextControlNode>;
        protected reSliceRepeatPoints(points: Vector2[], direction: Vector2): Vector2[];
        protected reSortPointsFromDirection(points: Vector2[], direction: Vector2): Vector2[];
        protected nodeGetCowalls(node: BrepNode): CowallNode[];
        protected computeFloorplanNodeOutlineBox(node: FloorplanNode): Box2;
        protected computeNodeOutlineBox(node: BrepNode): Box2;
        protected computeNodeOutlinePoints(node: BrepNode): Vector2[];
        protected nodeGetBeams(node: BrepNode): BeamNode[];
        protected nodeGetColumns(node: BrepNode): ColumnNode[];
        protected computeContentsDimPoints(contents: ContentNode[]): Vector2[];
        protected computeContentsTopDimLines(contents: ContentNode[]): Line2[];
        protected computeContentDimPoints(content: ContentNode): Vector2[];
        protected computeContentTopDimLines(content: ContentNode): Line2[];
        protected findFloorRoomNodeContentsWithoutOpenings(node: BrepNode, excludearray?: Array<Function>, onlyincludearray?: Array<Function>): Array<ContentNode>;
        protected computeContentsTopOutlineBoundary(node: BrepNode, includeContents: boolean, contentsExcludeArray?: Array<Function>, contentsOnlyIncludeArray?: Array<Function>): Box2;
        protected computeDynamicStyle(style: any, codes: string[], defaultvalues: number[]): any;
        protected computeBoundaryArea(boundary: Box2): number;
        protected convertLineCurves2Line2s(linecurves: LineCurve2d[]): Line2[];
        protected cowallsFilterInvalid(cowalls: CowallNode[]): CowallNode[];
        protected getLinesStartEnd(line: Line2[]): Array<Vector2>;
        getValidSurface(cowall: CowallNode): WallSurfaceNode;
        protected createNodesOutlineDimLines(nodes: FamilyInstanceNode[]): Line2[];
        protected createNodeOutlineDimLines(node: FamilyInstanceNode): Line2[];
        protected sortLinesByLength(lines: Line2[]): void;
        protected computeCowallsOutlineBoundary(cowalls: CowallNode[]): Box2;
        protected buildDimensionsFromLinesNew201030(lines: Line2[], dimpointssortdirection: Vector2, dimsdistance: number, firstdimdistance?: number, firstborderpoint?: Vector2, lastborderpoint?: Vector2, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[][];
        protected computeDimPointsFromLinesAndBorder(lines: Line2[], pointssortdirection: Vector2, firstborderpoint?: Vector2, lastborderpoint?: Vector2): Vector2[];
        protected combineLinesNew(lines: Line2[]): Line2[][];
        protected checkLineLinesIntersection(line: Line2, lines: Line2[]): boolean;
        linesIntersection(line1: Line2, line2: Line2): boolean;
        isPointOnLine(point: Vector2, line: Line2, includeLineEndpoint?: boolean, tolerance?: number): boolean;
        protected createCowallsOutlineDimLines(cowalls: CowallNode[], wallbreakbyOpenings?: boolean): Line2[];
        protected createGroupCowallOutlineDimLines(groupcowalls: CowallNode[], includeopenings?: boolean): Line2[];
        protected computeRelinkLines(lines: Line2[]): Line2;
        protected reLinkLines(lines: Line2[]): Line2;
        protected createOutlineDimLinesFromPoints(innerfrom: Vector2, innerto: Vector2, outerfrom: Vector2, outerto: Vector2, outlinebreakpoints?: any[]): Line2[];
        protected breakLinesByPoints(breakpoints: Vector2[], line: Line2): Line2[];
        protected createSingleCowallOutlineDimLinesNew201030(cowall: CowallNode, wallbreakbyOpenings?: boolean): Line2[];
        protected createSingleCowallOutlineDimLines(cowall: CowallNode, wallbreakbyOpenings?: boolean): Line2[];
        protected computeSingleCowallRoomInfo(cowall: CowallNode): any;
        protected computeSingleCowallRoomInfoNew201030(cowall: CowallNode): any;
        protected computeCowallInnerOuterLineFromSingleCowall(cowallroominfo: any, singlecowallroominfo: any, istojoiner?: boolean): any;
        protected lineCut(line: Line2, cutpoint: Vector2, cutdirection: Vector2, cutend?: boolean): Line2;
        protected needCutDimCowall(cowall: CowallNode): boolean;
        protected checkCutDimCowall(joiner: WallJoinnerNode, cowall: CowallNode): boolean;
        protected getCutCowall(joiner: WallJoinnerNode, cowall: CowallNode): CowallNode;
        protected getAngleFromVector2s(v1: Vector2, v2: Vector2): number;
        protected computeCowallLineFromJoiner2OtherJoiner(joiner: WallJoinnerNode, cowall: CowallNode): Line2;
        protected computeJoiner2OtherJoinerLine(joiner: WallJoinnerNode, otherjoiner: WallJoinnerNode): Line2;
        protected getOtherJoiner(joiner: WallJoinnerNode, cowall: CowallNode): WallJoinnerNode;
        protected checkCowallOrPartnerIsCowall(cowall: CowallNode, id: string): boolean;
        protected checkSingleCowall(cowall: CowallNode): boolean;
        protected getOpeningDimPoints(opening: OpeningNode): Vector2[];
        protected findColumns(node: FloorplanNode): DataNode[];
        protected buildFloorplanDimensions(node: BrepNode, style?: any): void;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected getStandardDomainBoundary(): Box2;
        protected reSetFontSize(nscale: number): void;
        protected linesSplitBorder(boundary: Box2, lines: Line2[], center?: Vector2): Line2[][];
        protected getFloorplanDimensionOutline(allDimsLiness: Line2[][]): Line2[][];
        protected removeRepeatLines(lines: Line2[]): Line2[];
        protected removeInvalidLines(lines: Line2[]): Line2[];
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FloorplanWallsThicknessTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseContentDrawingTransfer } from "sk/data/scheme/drawing/converter/scheme/content/BaseContentDrawingConverter";
    export class FloorplanWallsThicknessTransfer extends BaseContentDrawingTransfer {
        style: any;
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, floorplan: FloorplanNode): Promise<ResultObject>;
        init(): void;
        createWallThicknessDimensions(floorplan: FloorplanNode): void;
        protected drawFloorplanFlatWallsDim(floorplan: FloorplanNode): void;
        protected computeDynamicStyle(style: any, codes: string[], defaultvalues: number[]): any;
        getOutBorderCowalls(node: BrepNode): Array<CowallNode>;
        getInnerWalls(node: BrepNode): Array<WallNode>;
        protected cowallsFilterInvalid(cowalls: CowallNode[]): CowallNode[];
        protected nodeGetCowalls(node: BrepNode): CowallNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/content/FrameDrawingTransfer" { }
declare module "sk/data/scheme/drawing/util/quadtree/DrawingQuadTreeRectangle" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    export class DrawingQuadTreeRectangle {
        private _x;
        get x(): number;
        private _y;
        get y(): number;
        private _halfWidth;
        get halfWidth(): number;
        private _halfHeight;
        get halfHeight(): number;
        private _polygonPts;
        constructor(x: number, y: number, halfWidth: number, halfHeight: number);
        draw(domain: DrawingDomainNode): void;
        isIntersect(pts: Vector2[]): boolean;
    }
}
declare module "sk/data/scheme/drawing/util/quadtree/DrawingQuadTools" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingQuadTreeRectangle } from "sk/data/scheme/drawing/util/quadtree/DrawingQuadTreeRectangle";
    export class DrawingQuadTools {
        static getMainBox(domain: DrawingDomainNode): DrawingQuadTreeRectangle;
        static getDifferentNodeBox(ele: DataNode): Vector2[];
        static drawBox(domain: DrawingDomainNode, result: Types<DataNode>): void;
        static isPolygonIntersect(box1: Vector2[], box2: Vector2[]): boolean;
        private static getLeardNodeBox;
        private static getTextControlNodeBox;
        private static getText2dNodeBox;
        private static getTextBoxPoints;
    }
}
declare module "sk/data/scheme/drawing/util/quadtree/DrawingQuadTree" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingQuadTreeRectangle } from "sk/data/scheme/drawing/util/quadtree/DrawingQuadTreeRectangle";
    export class DrawingQuadTree {
        private _boundary;
        private _capacity;
        private _isDivided;
        private _dimNodes;
        private _parent;
        private _level;
        private _ne;
        private _nw;
        private _sw;
        private _se;
        constructor(boundary: DrawingQuadTreeRectangle, capacity: number);
        insert(drawDim: DataNode): void;
        private subDivide;
        private unSubDivide;
        delete(dimNode: DataNode): void;
        query(dimNode: DataNode, result: Types<DataNode>): void;
        querySpecial(dimNode: DataNode, result: Types<DataNode>, specialClass: Array<Function>): void;
        private isNeedClass;
        draw(domain: DrawingDomainNode): void;
    }
}
declare module "sk/data/scheme/drawing/util/quadtree/DrawingNodeArrageUtil" {
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDocument } from 'sk/data/family/drawing/DrawingDocument';
    export class DrawingNodeArrageUtil {
        static autoArrange(document: DrawingDocument, domain: DrawingDomainNode): void;
        private static createQuadTree;
        private static cheackAndMove;
        private static move;
        private static stepAroundLearderNode;
        private static stepAroundLineCurveDimensionNode;
        private static stepAroundText2dDrawingNode;
        private static stepAroundTextControlNode;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/FloorplanBaseInforDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Geometric } from 'foundation/runtime/geometry/Geometric';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { AlignLineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/AlignLineCurveDimensionDrawingNode';
    import { CurveDimensionNode } from 'sk/data/family/model/assistant/dimension/CurveDimensionNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { AssembleBeamNode } from "sk/data/scheme/database/pattern/node/AssembleBeamNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { LevelingCeilingNode } from "sk/data/scheme/database/pattern/node/LevelingCeilingNode";
    import { LevelingFloorNode } from "sk/data/scheme/database/pattern/node/LevelingFloorNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseFinishLineDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter";
    export class FloorplanBaseInforDrawingConverter extends BaseFinishLineDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: FloorplanNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
        protected computeDrawingDetailAsync(context: DrawingNodeContext, floorplan: FloorplanNode): Promise<void>;
        protected drawNodesByCodeAsync(context: DrawingNodeContext, code: string, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        private dimIsOffset;
        protected drawFlatWallSurveysAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix: Matrix4): Promise<void>;
        protected offsetDimsTextDir(surveyDims: {
            keelDims: AlignLineCurveDimensionDrawingNode[];
            keelDimsOrigin: Value2[];
            lengthDims: AlignLineCurveDimensionDrawingNode[];
            lengthDimsOrigin: Value2[];
            containerDims: AlignLineCurveDimensionDrawingNode[];
            flatwall: FlatWallNode;
        }[]): void;
        protected flatWallsText(flatwalls: FlatWallNode[], surveyDims: any[]): void;
        protected offsetDimsByIntersectCount(targetOffsetDims: any[], surveyDims: any[]): any;
        protected tryOffsetDims(surveyDims: any, tryCount: number, offsetStep: number, excludeDims?: any[]): any[];
        protected checkAndOffsetKeelDims(dims: AlignLineCurveDimensionDrawingNode[], surveyDims: any[], curSurveyDim: any, offsetStep: number): boolean;
        protected moveDims(dims: AlignLineCurveDimensionDrawingNode[], offset: number, flatwall: FlatWallNode): void;
        protected mergeLine(lines: AlignLineCurveDimensionDrawingNode[]): AlignLineCurveDimensionDrawingNode;
        protected checkDimsIntersect(offsetTarget: AlignLineCurveDimensionDrawingNode, dim: AlignLineCurveDimensionDrawingNode): boolean;
        protected drawFlatWallSurvey(context: DrawingNodeContext, flatwall: FlatWallNode, observeMatrix: Matrix4): any;
        protected checkDimensionsEquals(dims1: CurveDimensionNode[], dims2: CurveDimensionNode[], line: Line2): boolean;
        protected checkPointsEquals(point1s: Vector2[], point2s: Vector2[]): boolean;
        protected computeDimensionPointsOnLine(dims: CurveDimensionNode[], line: Line2): Vector2[];
        protected drawContainersSurveyDimensions(containers: ContentNode[], flatwallinnerlinedirection: Vector2, distance: number, observeMatrix: Matrix4, style?: any, drawingLevel?: number): BrepNode[];
        protected createOuterKeelSurveyDimensions(keelouterline: Line2, keels: HardwareNode[], distance: number, observeMatrix?: Matrix4, style?: any, drawingLevel?: number): BrepNode[];
        protected createInnerKeelSurveyDimensions(keelinnerline: Line2, keels: HardwareNode[], distance: number, observeMatrix?: Matrix4, style?: any, drawingLevel?: number): BrepNode[];
        protected computeCurve2dsBoxTopView(curve2ds: Curve2d[]): Box2;
        protected curve2dsApplyMatrix(curve2ds: Curve2d[], matrix: Matrix4): void;
        protected computeInnerKeelInnerLine(innerlinedirection: Vector2, innerkeelcontainer: ContainerNode, observeMatrix: Matrix4): Line2;
        protected computeOuterKeelOuterLine(innerlinedirection: Vector2, outerkeelcontainer: ContainerNode, observeMatrix: Matrix4): Line2;
        protected findSurveyKeels(node: DataNode): HardwareNode[];
        protected drawNodesForFamilyInstancesAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleGroundAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleFloorAsync(context: DrawingNodeContext, floor: LevelingFloorNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleTopAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawBoardsAsync(context: DrawingNodeContext, floorplan: FloorplanNode, observeMatrix?: Matrix4, isTop?: boolean): Promise<void>;
        protected drawNodeForAssembleBeamAsync(context: DrawingNodeContext, beam: AssembleBeamNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembleWallAsync(context: DrawingNodeContext, wall: LevelingWallNode, observeMatrix?: Matrix4): Promise<void>;
        protected drawNodesForAssembelCeilAsync(context: DrawingNodeContext, ceil: LevelingCeilingNode, observeMatrix?: Matrix4): Promise<void>;
        protected createGeometricProjectionMathLines(matrixw: Matrix4, matrixp: Matrix4, geometric: Geometric): Curve2d[];
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/FloorplanDecorateInforDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseFinishLineDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter";
    export class FloorplanDecorateInforDrawingConverter extends BaseFinishLineDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: FloorplanNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/RoomFinishLineDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { Fill2dDrawingNode } from 'sk/data/family/model/brep/drawing/Fill2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseFinishLineDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter";
    export class RoomFinishLineDrawingConverter extends BaseFinishLineDynamicDrawingConverter {
        protected cowallMaps: any;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: BrepNode): Promise<any>;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawDynamicRoom(roomdynamicware: ContentNode): void;
        protected drawLevelingStartWallDirection(levelNode: LevelingWallNode): void;
        protected lineGetSameDirectionCoinsideLineFromLines(line: LineCurve2d, lines: LineCurve2d[]): Vector3[];
        protected drawWallStartDirection(wall: DynamicWareNode, lines: LineCurve2d[]): void;
        protected drawWallsCavityAndDims(walls: ContentNode[], style?: any, drawingLevel?: number): void;
        protected drawWallsCompleteLines(walls: ContentNode[], style?: any, drawingLevel?: number): void;
        protected getExtendLine(line: LineCurve2d, length: number): LineCurve2d;
        protected getLineMathNodesFromDrawNodes(lines: LineCurve2dDrawingNode[]): LineCurve2d[];
        protected drawDynamicWallCode(wall: ContentNode, distance: number, code: string, style?: any, drawingLevel?: number): void;
        private drawWallCode;
        protected drawCompleteLineDistanceDim(to: Vector2, from: Vector2): void;
        protected drawLevelingWallPlanks(wallnode: ContentNode): void;
        protected drawPlank(container: WareNode): void;
        protected computeVectorsByBoundary(box: BoundaryBox): Vector3[];
        private createCoWallPolygonsWithoutOpening;
        protected createFillsByWall(document: DrawingDataDocument, dpolygons: PolygonCurve2dDrawingNode[], id: string): Fill2dDrawingNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/FloorplanLevelingWallDrawingConverter copy" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { LevelingWallNode } from "sk/data/scheme/database/pattern/node/LevelingWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { RoomFinishLineDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/RoomFinishLineDrawingConverter";
    export class FloorplanLevelingWallDrawingConverter extends RoomFinishLineDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: BrepNode): Promise<any>;
        protected buildFloorplanDimensionsInfo(node: BrepNode): any;
        protected drawDynamicRoom(roomdynamicware: ContentNode): void;
        protected drawWallsCompleteLinesNew(assembledRoom: ContentNode, style?: any, drawingLevel?: number): void;
        protected getExtendLine(line: LineCurve2d, length: number): LineCurve2d;
        protected drawBeamsCompleteLines(beams: ContentNode[], style?: any, drawingLevel?: number): void;
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawShareDoorRoomsCompleteLineDistanceDim(floorplan: FloorplanNode, style?: any, drawingLevel?: number): void;
        protected findDynamicWareWallFromCowall(cowall: CowallNode, floorplan: FloorplanNode): LevelingWallNode;
        private buildCowallMap;
        protected computeVectorsByBoundary(box: BoundaryBox): Vector3[];
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/FloorplanLevelingWallDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseFinishLineDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter";
    export class FloorplanLevelingWallDrawingConverter extends BaseFinishLineDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: FloorplanNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/FloorplanOriginDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BaseboardNode } from "sk/data/scheme/database/floorplan/model/BaseboardNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseFinishLineDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter";
    type WallInfo = {
        x: number;
        y: number;
        name: string;
        angle: number;
    };
    export class FloorplanOriginDrawingConverter extends BaseFinishLineDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: FloorplanNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
        protected buildFloorPlanDimensionsByViewType(node: FloorplanNode, dimsdistance: number, viewtype: DrawingViewTypeEnum, style?: any, firstdimdistance?: number, drawingLevel?: number): void;
        protected getFamilyInstancesByViewType(viewtype: DrawingViewTypeEnum, floorplan: FloorplanNode): FamilyInstanceNode[];
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawWallSurfaceCode(assemblyroom: ContentNode): void;
        protected drawBaseboardLine(floorplan: FloorplanNode): BrepNode[];
        protected findBaseboards(floorplan: FloorplanNode): DataNode[];
        protected drawBaseboards(baseboards: BaseboardNode[]): BrepNode[];
        protected drawBaseboard(baseboard: BaseboardNode): BrepNode[];
        protected getWallIdentifier(cowall: CowallNode): number;
        protected getWallInfos(cowalls: CowallNode[]): Array<WallInfo>;
        protected drawDynamicWallCode(wall: ContentNode, distance: number, code: string, style?: any, drawingLevel?: number): void;
        private drawWallCode;
        protected createTextsByWallInfos(infos: Array<WallInfo>): Array<TextControlNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/scheme/TestDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BaseboardNode } from "sk/data/scheme/database/floorplan/model/BaseboardNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { DrawingViewTypeEnum } from "sk/data/scheme/drawing/constants/DrawingConstants";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseFinishLineDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/scheme/BaseFinishLineDynamicDrawingConverter";
    type WallInfo = {
        x: number;
        y: number;
        name: string;
        angle: number;
    };
    export class TestDrawingConverter extends BaseFinishLineDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: FloorplanNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingDetailAsync(context: DrawingNodeContext, floorplan: FloorplanNode): Promise<void>;
        private computeDrawingAsync;
        protected buildFloorPlanDimensionsByViewType(node: FloorplanNode, dimsdistance: number, viewtype: DrawingViewTypeEnum, style?: any, firstdimdistance?: number, drawingLevel?: number): void;
        protected getFamilyInstancesByViewType(viewtype: DrawingViewTypeEnum, floorplan: FloorplanNode): FamilyInstanceNode[];
        protected preAppendExtraBoundary(boundary: Box2): Box2;
        protected drawWallSurfaceCode(assemblyroom: ContentNode): void;
        protected drawBaseboardLine(floorplan: FloorplanNode): BrepNode[];
        protected findBaseboards(floorplan: FloorplanNode): DataNode[];
        protected drawBaseboards(baseboards: BaseboardNode[]): BrepNode[];
        protected drawBaseboard(baseboard: BaseboardNode): BrepNode[];
        protected getWallIdentifier(cowall: CowallNode): number;
        protected getWallInfos(cowalls: CowallNode[]): Array<WallInfo>;
        protected drawDynamicWallCode(wall: ContentNode, distance: number, code: string, style?: any, drawingLevel?: number): void;
        private drawWallCode;
        protected createTextsByWallInfos(infos: Array<WallInfo>): Array<TextControlNode>;
    }
}
declare module "sk/data/scheme/util/AssembleBathroomInfoUtil" {
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { AssembleBathroomElement } from "sk/data/scheme/database/pattern/element/AssembleBathroomElement";
    export class AssembleBathroomInfoUtil {
        static getAssembleBathroom(room: RoomNode): AssembleBathroomElement;
        static getFloorFinishHeightByRoom(room: RoomNode): number;
        static getFloorFinishHeightByAssembeleBathroom(abath: AssembleBathroomElement): number;
    }
}
declare module "sk/data/scheme/drawing/converter/standard/StandardDrawingUtils" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DoorNode } from "sk/data/scheme/database/floorplan/model/DoorNode";
    import { HoleNode } from "sk/data/scheme/database/floorplan/model/HoleNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    export const numberUnit = "mm";
    export enum DoorComponent {
        MD = 0,
        MB = 1,
        MTX = 2,
        MTXB = 3,
        MS = 4,
        GMS = 5
    }
    export enum ViewType {
        InternalFront = 0,
        ExternalFront = 1,
        Top = 2,
        Side = 3
    }
    export class StandardDrawingUtils {
        static setInfoToFrame(context: IContext, document: DrawingDataDocument, door: DoorNode, allEntity: Map<DoorComponent, WareNode>, gmsTopYValue: number, holeBottomYValue: number): Promise<boolean>;
        private static getGDHeightGap;
        private static getDMGValue;
        static isDoorHostSingleRoom(entity: DoorNode | HoleNode): Boolean;
        static setFrameValue(templateData: Map<string, string>, key: string, value: string): void;
        static getSelectVariableValue(winDooor: OpeningNode, code: string): string;
        static getDecorateValue(context: IContext, node: WareNode): Promise<string>;
        static getDoorHeightValue(node: DoorNode): number;
        static getDrawingShowId(element: BrepElement): string[];
        static getDoorRelatRoom(entity: DoorNode | HoleNode, isHostRoom?: Boolean): RoomNode;
        static getDoorGroundedValueByRoom(entity: DoorNode | HoleNode, isHostRoom: Boolean): number;
        static findDoorComponentGMS(holeNode: HoleNode): WareNode;
        static findDoorComponentMB(holeNode: HoleNode, allDoorComponentNode: WareNode[]): WareNode;
        static findDoorComponentMS(holeNode: HoleNode, allDoorComponentNode: WareNode[]): WareNode;
        static getContentNodeArea(node: ContentNode): number;
        static getTwoFrontViewTransform(holeNode: HoleNode): Matrix4[];
        static getTwoTopViewTransform(holeNode: ContentNode): Matrix4[];
    }
}
declare module "sk/data/scheme/drawing/converter/standard/StandardDrawingBaseConverter" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { PointDrawingNode } from 'sk/data/family/model/brep/drawing/PointDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DoorNode } from "sk/data/scheme/database/floorplan/model/DoorNode";
    import { HoleNode } from "sk/data/scheme/database/floorplan/model/HoleNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseLevelingDynamicDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDynamicDrawingConverter";
    import { DoorComponent, ViewType } from "sk/data/scheme/drawing/converter/standard/StandardDrawingUtils";
    export class StandardDrawingBaseConverter extends BaseLevelingDynamicDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected getProjectEntity(context: DrawingNodeContext, door: DoorNode, matP: Matrix4): Promise<Map<DoorComponent, WareNode>>;
        protected getConnectRoomGdHeight(context: DrawingNodeContext, door: DoorNode, allEntity: Map<DoorComponent, WareNode>, hostRoomGdHeight: number, matP: Matrix4): Promise<number>;
        protected setInfoToDrawingFrame(context: DrawingNodeContext, door: DoorNode, allEntity: Map<DoorComponent, WareNode>, matrixP: Matrix4): Promise<boolean>;
        protected findDoorComponentMTX(context: DrawingNodeContext, holeNode: HoleNode, firstChildren: WareNode[], matP: Matrix4): Promise<WareNode>;
        protected findDoorComponentMTXB(context: DrawingNodeContext, holeNode: HoleNode, firstChildren: WareNode[], matP: Matrix4): Promise<WareNode>;
        protected getBoxS(box: Box2): number;
        protected getBox(context: DrawingNodeContext, node: WareNode, matP: Matrix4): Promise<Box2>;
        protected drawingDimensionEntity(context: DrawingNodeContext, holeNode: HoleNode, gmsNode: WareNode, dmHeight: number, hostRoomGdHeight: number, connectRoomGdHeight: number, view: ViewType, matrixP?: Matrix4): Promise<void>;
        protected drawingSizeDim(allPoint: Vector2[], matrixP: Matrix4, isLeftDim?: boolean): void;
        protected drawingBottomDim(dmHeight: number, stPoint: Vector2, endPoint: Vector2, matrixP: Matrix4): void;
        protected getAllLine(allPoint: Vector2[]): Line2[];
        protected drawingGMSShape(context: DrawingNodeContext, doorGMS: WareNode, hostRoomGdHeight: number, connectRoomGdHeight: number, holeNode: HoleNode, view: ViewType, matrixP: Matrix4): Promise<void>;
        protected drawingMBShape(context: DrawingNodeContext, doorMB: WareNode, hostRoomGdHeight: number, connectRoomGdHeight: number, holeNode: HoleNode, viewType: ViewType, matrixP?: Matrix4): Promise<void>;
        protected drawingProjectNodeShape(context: DrawingNodeContext, holeNode: HoleNode, doorMB: WareNode, hostRoomGdHeight: number, connectRoomGdHeight: number, viewType: ViewType, color: any, matrixP: Matrix4): Promise<void>;
        protected drawingDoorMTBXLeader(context: DrawingNodeContext, doorMTXB: WareNode, view: ViewType, matrixP: Matrix4): Promise<void>;
        protected drawingDoorChildNodeShape(context: DrawingNodeContext, wareNode: WareNode, viewType: ViewType, color: string, matrixP: Matrix4): Promise<void>;
        protected drawingTXEntity(context: DrawingNodeContext, holeNode: HoleNode, wareNode: WareNode, hostRoomGdHeight: number, connectRoomGdHeight: number, viewType: ViewType, color: string, matrixP: Matrix4): Promise<BrepNode[]>;
        protected updateTXNodes(nodes: BrepNode[], txCenterPoint: Vector2, leftTXBottomYValue: number, rightTXBottomYValue: number): BrepNode[];
        protected updateLineNodes(node: BrepNode[], bottomYValue: number): void;
        protected updateLineNode(node: BrepNode, bottomYValue: number): void;
        protected drawingMBLeaderDim(context: DrawingNodeContext, doorMB: WareNode, viewType: ViewType, matrixP: Matrix4): Promise<void>;
        protected drawingMSAndOpeingDir(context: DrawingNodeContext, hole: HoleNode, hostRoomGdHeight: number, connectRoomGdHeight: number, doorMS: WareNode, doorMB: WareNode, viewType: ViewType, matrixP?: Matrix4): Promise<void>;
        protected drawingMSEntity(context: DrawingNodeContext, doorMS: WareNode, doorMB: WareNode, viewType: ViewType, color: string, matrixP: Matrix4): Promise<Vector2>;
        protected drawingOpeningDir(context: DrawingNodeContext, hole: HoleNode, basePoint: Vector2, hostRoomGdHeight: number, connectRoomGdHeight: number, doorMS: WareNode, doorMB: WareNode, viewType: ViewType, matrixP?: Matrix4): Promise<void>;
        protected drawingMSLeaderAndDir(bottomYValue: number, name: string, doorMBAllPointsPlane: Vector2[], basePoint: Vector2, viewType: ViewType): void;
        protected drawingHoleShape(context: DrawingNodeContext, holeNode: HoleNode, viewType: ViewType, matrixP?: Matrix4): Promise<void>;
        protected getNodeAllBBoxPoint(context: DrawingNodeContext, contentNode: ContentNode, matrixP: Matrix4): Promise<Vector2[]>;
        protected getProjectBBoxAllPoints(holeBox: Box2): Vector2[];
        protected getRectDiagonalPoint(sizeCenter: Vector2, xLength: number, yLength: number, drawingDir: Vector2): Vector2[];
        protected drawingTXShape(context: DrawingNodeContext, doorMTX: WareNode, hostRoomGdHeight: number, connectRoomGdHeight: number, holeNode: HoleNode, viewType: ViewType, matrixP?: Matrix4): Promise<void>;
        protected drawingTXWidthDim(allPlanePoints: Vector2[], doorNode: DoorNode): void;
        protected setDimensionStyle(borderlineLength?: number): void;
        protected createLeaderDim(basePos: Vector2, content: string, isRightDir?: boolean, isUpDir?: boolean): LeaderDrawingNode;
        protected drawingLeaderDim(basePos: Vector2, content: string, isRightDir?: boolean, isUpDir?: boolean): void;
        protected setLeaderDimStyle(): any;
        protected drawingGroundShape(context: DrawingNodeContext, goundHeight: number, hostRoomGdHeight: number, connectRoomGdHeight: number, holeNode: HoleNode, viewType: ViewType, matrixP?: Matrix4): Promise<void>;
        protected drawingDMLine(tempDMMin: Vector2, tempDMMax: Vector2, hostRoomGdHeight: number, connectRoomGdHeight: number, holeAllPointPlane: Vector2[], viewType: ViewType, isSingleRoom: Boolean): void;
        protected drawingDMFill(dmMin: Vector2, dmMax: Vector2): void;
        protected drawingCustomRectShape(entityMin: Vector2, entityMax: Vector2, color: string): void;
        protected drawingDotOutLine(points: Array<Vector2>, style: any, isClose?: Boolean, solid?: number, gap?: number): void;
        protected drawingNodeRectShape(context: DrawingNodeContext, doorMB: WareNode, viewType: ViewType, color: string, matrixP?: Matrix4): Promise<void>;
        protected getBBoxAllPointsByPlane(minPlane: Vector2, maxPlane: Vector2): Array<Vector2>;
        protected converVecToPointNode(point: Vector2): PointDrawingNode;
        protected drawingLineShape(pStr: Vector2, pEnd: Vector2, color: string): void;
        protected drawingText(context: DrawingNodeContext, holeNode: HoleNode, view: ViewType, matrixP: Matrix4): Promise<void>;
        drawingRoomName(context: DrawingNodeContext, holeNode: HoleNode, view: ViewType, matrixP: Matrix4, style: any): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/standard/StandardDoorFrontDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DoorNode } from "sk/data/scheme/database/floorplan/model/DoorNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { StandardDrawingBaseConverter } from "sk/data/scheme/drawing/converter/standard/StandardDrawingBaseConverter";
    import { ViewType } from "sk/data/scheme/drawing/converter/standard/StandardDrawingUtils";
    export class StandardDoorFrontDrawingConverter extends StandardDrawingBaseConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: DoorNode): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
        private drawingFrontViewDoorEntity;
        drawingDMLine(tempDMMin: Vector2, tempDMMax: Vector2, hostRoomGdHeight: number, connectRoomGdHeight: number, holeAllPointPlane: Vector2[], viewType: ViewType, isSingleRoom: Boolean): void;
        drawingTXWidthDim(allPlanePoints: Vector2[], doorNode: DoorNode): void;
        drawingMSEntity(context: DrawingNodeContext, doorMS: WareNode, doorMB: WareNode, viewType: ViewType, color: string, matrixP: Matrix4): Promise<Vector2>;
    }
}
declare module "sk/data/scheme/drawing/converter/standard/StandardDoorTopDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DoorNode } from "sk/data/scheme/database/floorplan/model/DoorNode";
    import { HoleNode } from "sk/data/scheme/database/floorplan/model/HoleNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { StandardDrawingBaseConverter } from "sk/data/scheme/drawing/converter/standard/StandardDrawingBaseConverter";
    import { ViewType } from "sk/data/scheme/drawing/converter/standard/StandardDrawingUtils";
    export class StandardDoorTopDrawingConverter extends StandardDrawingBaseConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: DoorNode): Promise<ResultObject<DrawingDataDocument>>;
        private computeDrawingAsync;
        private drawingSizeViewDoorEntity;
        private drawingWallWCMLine;
        private getWallWCMXLine;
        drawingTopWall(context: DrawingNodeContext, dmHeight: number, holeNode: HoleNode, view: ViewType, matrixP: Matrix4): Promise<void>;
        private drawingTopViewDoorEntity;
        protected drawingTopViewDimensionEntity(context: DrawingNodeContext, holeNode: HoleNode, dmHeight: number, hostRoomGdHeight: number, connectRoomGdHeight: number, view: ViewType, matrixP?: Matrix4): Promise<void>;
        drawingDMLine(tempDMMin: Vector2, tempDMMax: Vector2, hostRoomGdHeight: number, connectRoomGdHeight: number, holeAllPointPlane: Vector2[], viewType: ViewType, isSingleRoom: Boolean): void;
        drawingMSEntity(context: DrawingNodeContext, doorMS: WareNode, doorMB: WareNode, viewType: ViewType, color: string, matrixP: Matrix4): Promise<Vector2>;
        drawingTopMSEntity(context: DrawingNodeContext, doorMS: WareNode, doorMB: WareNode, viewType: ViewType, color: string, matrixP: Matrix4): Promise<Vector2>;
        drawingSizeMSEntity(context: DrawingNodeContext, doorMS: WareNode, doorMB: WareNode, viewType: ViewType, color: string, matrixP: Matrix4): Promise<Vector2>;
        drawingRoomName(context: DrawingNodeContext, holeNode: HoleNode, view: ViewType, matrixP: Matrix4, style: any): Promise<void>;
    }
}
declare module "sk/data/scheme/drawing/converter/test/TestConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { PointDrawingNode } from 'sk/data/family/model/brep/drawing/PointDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class TestConverter extends BaseDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject>;
        protected computeDrawingAsync(node: BrepNode, option?: any): Promise<any>;
        private myTest;
        private testMutiText;
        private testAlignNode;
        private testLeaderNode;
        private testCircleArcAngleDimension;
        private testCircleArcDimension;
        private testControl;
        private testtextcontrol;
        private testText2d;
        private testPolyline;
        private testPolygon;
        private testNurbs;
        private testline2d;
        private testDimensionNode;
        private testFill2d;
        private testCircle;
        private testCircleArc;
        private testDiameterDimension;
        private testEllipse;
        private testEllipseArc;
        private testRadiusDimension;
        createOGPoints(points: Vector3[]): PointDrawingNode[];
        createOGPoint(x: number, y: number, z: number): PointDrawingNode;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/base/BaseFinishLineDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { LeaderDrawingNode } from 'sk/data/family/model/brep/drawing/leader/LeaderDrawingNode';
    import { Fill2dDrawingNode } from 'sk/data/family/model/brep/drawing/Fill2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BeamNode } from "sk/data/scheme/database/floorplan/model/BeamNode";
    import { ColumnNode } from "sk/data/scheme/database/floorplan/model/ColumnNode";
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { WallNode } from "sk/data/scheme/database/floorplan/model/WallNode";
    import { WallSurfaceNode } from "sk/data/scheme/database/floorplan/model/WallSurfaceNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { AssembleRoomNode } from "sk/data/scheme/database/pattern/node/AssembleRoomNode";
    import { DecorateLayerNode } from "sk/data/scheme/database/pattern/node/DecorateLayerNode";
    import { FlatWallNode } from "sk/data/scheme/database/pattern/node/FlatWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { BaseDrawingConverter, WallSurfaceLineAndPath } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { FormComponentConverter } from "sk/data/scheme/drawing/converter/component/FormComponentConverter";
    export type ComputeNearestPointResult = {
        p: Vector2;
        b: Vector2;
        i: number;
    };
    export enum LevelingDrawingContentEnum {
        wallsCompleteLinesGeos = 0,
        wallCompletePoitns = 1
    }
    export type WallCompleteInfo = {
        completeInnerLine: Line2;
        completePoints: Vector2[];
    };
    export type WallBaseInfo = {
        baseOuterLine: Line2;
        basePoints: Vector2[];
    };
    export class BaseFinishLineDrawingConverter extends BaseDrawingConverter {
        protected graphicFormMap: Map<BrepNode[], string>;
        protected keelsMap: Map<string, string>;
        protected formConverter: FormComponentConverter;
        constructor(domain?: DrawingDomainNode);
        protected wallsFilterInvalid(walls: WallNode[]): WallNode[];
        protected cowallsFilterInvalid(cowalls: CowallNode[]): CowallNode[];
        protected findAssembelRoomByAssembelWall(wallnode: ContentNode): ContentNode;
        protected fetchFloorplanAllWalls(floorplan: FloorplanNode): DataNode[];
        protected isInRoom(room: RoomNode, instance: ContentNode, checkBox?: boolean, includeRoomOutline?: boolean): boolean;
        protected checkPointsInRoomFlatWalls(room: RoomNode, points: Vector2[], includeedge: boolean): boolean;
        protected checkPointsInRoomCowalls(room: RoomNode, points: Vector2[], includeedge: boolean): boolean;
        protected checkPointsInPolygon(points: Vector2[], polygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        protected checkPolygonsIntersection(polygon: Vector2[], otherpolygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        protected checkCurveLinecurve(curve2d: Curve2d, tolerance?: number): boolean;
        protected checksectionSurfaceIntersectSectionSurface(section: SectionSurface, othersection: SectionSurface): boolean;
        protected findRoomContents(room: RoomNode, excludearray?: Array<Function>, onlyincludearray?: Array<Function>): FamilyInstanceNode[];
        protected findAssembledRooms(floorplan: FloorplanNode): ContentNode[];
        protected findAssembledRoomByRoomNode(room: RoomNode): AssembleRoomNode;
        protected _room: RoomNode;
        protected getLevelWalls(assembledRoom: ContentNode): ContentNode[];
        protected getMarkPoints(floorNode: BrepNode): ContentNode[];
        protected getLevelBeams(assembledRoom: ContentNode): ContentNode[];
        protected findBeam(node: ContentNode): ContentNode;
        protected drawDynamicRoom(roomdynamicware: ContentNode, drawcontext?: DrawingNodeContext): void;
        protected findCowallFromDynamicwall(node: DynamicWareNode): CowallNode;
        protected findRoomFromAssembledRoom(node: ContentNode): RoomNode;
        protected computeNodeStartDirection(node: BrepNode): Vector2;
        protected buildFloorplanDimensions(node: BrepNode, style?: any): void;
        protected computeAssemledBoundary(node: BrepNode, box?: Box2): Box2;
        protected createBeamsInfos(instances: FamilyInstanceNode[], pos?: Vector2, textHeight?: number): void;
        protected drawWallsCavityAndDims(walls: DynamicWareNode[], style?: any, drawingLevel?: number): void;
        protected drawWallCavityAndDims(wall: ContentNode, planks: ContentNode[], style?: any, drawingLevel?: number): void;
        protected drawForm(): void;
        private drawTextForm;
        private drawGraphicForm;
        protected drawKeelText(textpos: Vector2, rotationZ: number, keel: ContentInstanceNode, needserialNumber: boolean, needProcessNumber: boolean, keeltypecodedict: Map<string, string>, replacetypecodearray: Array<string>, keepmaptext?: Map<string, string>, style?: any, drawingLevel?: number): BrepNode;
        protected createKeelText(textpos: Vector2, rotationZ: number, keel: ContentInstanceNode, needserialNumber: boolean, needProcessNumber: boolean, keeltypecodedict: Map<string, string>, replacetypecodearray: Array<string>, keepmaptext?: Map<string, string>, style?: any, drawingLevel?: number): BrepNode;
        protected computeKeelMapText(keel: ContentInstanceNode, code: string, textmap: Map<string, string>): void;
        protected computeKeelCode(keel: ContentInstanceNode, typedict: Map<string, string>, replacetypecodearray: Array<string>): string;
        protected drawFlatWall(flatwall: FlatWallNode): BrepNode[];
        protected drawingWallLines(document: DrawingDataDocument, cowalls: CowallNode[], workInstance?: boolean, dimEnable?: boolean, dimBase?: number): void;
        protected checkCeilOrFloorTouchWall(ceil: ContentNode, wall: ContentNode, tolerance?: number): boolean;
        protected checkCurvesIntersection(curves: Curve2d[], othercurves: Curve2d[]): boolean;
        protected drawWallsCompleteLines(walls: ContentNode[], style?: any, drawingLevel?: number, context?: DrawingNodeContext): void;
        protected computeDecorateSurfaceInnerLineAndPath(decorateLayer: DecorateLayerNode): WallSurfaceLineAndPath;
        protected computeWallLineAndBox(levelingWall: ContentNode, isOuterLine?: boolean): WallSurfaceLineAndPath;
        protected computeNearestPointInLinecurve(linecurve: LineCurve2d, point: Vector3): Vector3;
        protected computeDynamicWallSurfaceLine(dynamicwall: ContentNode): Line2;
        protected getLinesPoints(lines: Line2[]): Vector2[];
        protected computePlankDirectionTopView(plank: PlankNode): Vector2;
        protected computeWallsZindex(walls: Array<WallNode>, observeMatrix?: Matrix4): number;
        protected drawingRoomCowalls(room: RoomNode, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected drawingCoWalls(document: DrawingDataDocument, cowalls: Array<CowallNode>, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected computeDirectionPolygons(polygons: Vector2[][], positive?: boolean): Vector2[][];
        protected computeDirectionPolygon(points: Vector2[], positive?: boolean): Vector2[];
        protected computePolygonDirection(polygon: Vector2[]): boolean;
        protected getAngleFromVector2s(v1: Vector2, v2: Vector2): number;
        protected drawLineArrow(point1: Vector2, point2: Vector2, style: any, drawingLevel?: number): void;
        protected drawingWalls(document: DrawingDataDocument, walls: Array<WallNode>, fillEnable: boolean, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean): void;
        protected createWallPolygonsWithoutOpening(document: DrawingDataDocument, walls: Array<WallNode> | Array<CowallNode>, wallPoints: Vector2[][], observeMatrix?: Matrix4): PolygonCurve2dDrawingNode[];
        protected createFillsByWall(document: DrawingDataDocument, dpolygons: PolygonCurve2dDrawingNode[], id: string): Fill2dDrawingNode[];
        protected drawFlatWallsAsync(flatwalls: FlatWallNode[], observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwallsoutlines?: Array<Vector2>): Promise<BrepNode[]>;
        protected drawFloorplanFlatWallsText(flatwalls: FlatWallNode[], textHeight?: number, dimBoxs?: Box2[]): void;
        protected flatwallTextOffset(flatwallAndNames: {
            flatwall: FlatWallNode;
            leader: LeaderDrawingNode;
        }[], textHeight?: number, dimBoxs?: Box2[]): void;
        protected computeLeaderTextBox(point: Value2, text: string, textHeight: number): Box2;
        protected offsetFlatWallText(curLeaderAndBox: {
            leader: LeaderDrawingNode;
            box: Box2;
        }, offsetDir: Vector2, offsetStep: number, leaderAndBoxs: {
            leader: LeaderDrawingNode;
            box: Box2;
        }[], boxs: Box2[], textHeight: number, offsetArr?: Vector2[], curOffsetCount?: number, originPoint?: Value2): void;
        protected computeOffsetArr(offsetDir: Value2, offsetCount: number): Array<any>;
        protected drawFlatwallCodeForm(flatwalls: FlatWallNode[]): void;
        protected drawFlatWallAsync(flatwall: FlatWallNode, observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, usepositiondrawingLevel?: boolean, withwhitebg?: boolean, flatwalloutlines?: Array<Vector2>, cutsurface?: SectionSurface, roomnode?: RoomNode): Promise<BrepNode[]>;
        protected computeFlatwallGeosExcludeDoors(geos: Curve2dNode[], openings: OpeningNode[]): BrepNode[];
        protected computeFlatWallOpenings(flatwall: FlatWallNode): OpeningNode[];
        protected drawFlatWallPlanks(flatwall: FlatWallNode, observeMatrix?: Matrix4, cutsurface?: SectionSurface): BrepNode[];
        protected drawFlatWallCode(flatwall: FlatWallNode, textHeight?: number, cutsurface?: SectionSurface, roomnode?: RoomNode): {
            codeText: BrepNode[];
            nameText: LeaderDrawingNode[];
        };
        protected drawFlatWallCodeText(flatwallnode: FlatWallNode, innerdirection: Vector2, cutsurface?: SectionSurface, roomnode?: RoomNode, textHeight?: number): LeaderDrawingNode[];
        protected drawFlatWallOuterKeelCode(outercontainer: ContainerNode, flatwallinnerdirection: Vector2, cutsurface?: SectionSurface): BrepNode;
        protected drawFlatWallInnerKeelCode(innercontainer: ContainerNode, flatwallinnerdirection: Vector2, cutsurface?: SectionSurface): BrepNode;
        protected drawRoomFlatWallAsync(roomnode: RoomNode, observeMatrix?: Matrix4, includePlanks?: boolean, breakbyopening?: boolean, flatwallsoutlines?: Array<Vector2>): Promise<void>;
        protected checkFlatWallOverRoom(flatwall: FlatWallNode, room: RoomNode): boolean;
        protected getRoomFlatWalls(roomnode: RoomNode): FlatWallNode[];
        protected findWallsFromCowalls(cowalls: CowallNode[]): WallNode[];
        protected findNodeFromNodeIdInNodes(id: string, nodes: DataNode[]): DataNode;
        protected findNodeFromElementIdInNodes(id: string, nodes: DataNode[]): DataNode;
        protected isElementIdInNodes(id: string, nodes: DataNode[]): boolean;
        protected drawFloorplanFlatWallAsync(floorplan: FloorplanNode, observeMatrix?: Matrix4, usepositiondrawingLevel?: boolean, breakbyopening?: boolean): Promise<void>;
        protected drawWallAndLineDistanceDim(line: Line2, dynamicware: ContentNode, dimstyle?: any, drawingLevel?: number): void;
        protected computeOGWallFromAssemblewall(assemblewall: ContentNode): CowallNode[];
        protected computeOGWallNearestInnerLine(cowall: CowallNode, innerline: Line2): Line2;
        protected computeOGWallInnerLine(assembledWall: ContentNode): Line2;
        protected findSurfaceNodeByElementId(floorplannode: FloorplanNode, elementid: string): WallSurfaceNode;
        protected createCompleteDistanceDims(completeline: Line2, distance: number, centerposoffset: number, style?: any, drawingLevel?: number): LineCurveDimensionDrawingNode[];
        protected getInnerEdgeFromColumnInnerDirection(columnNode: ColumnNode, direction: Vector2): Line2;
        protected findUpAssemledRoom(node: DataNode): ContentNode;
        protected findChildrenAssemledRoom(node: DataNode): BrepNode;
        protected findNodeRelationContent(node: ContentNode, findslave?: boolean): InstanceElement;
        protected findNodeRelationElementId(node: ContentNode, findslave?: boolean): string;
        protected findBindValue(node: ContentNode, parameterCode: string, findslave?: boolean): string;
        protected findRelationElements(node: ContentNode, findslave?: boolean): InstanceElement[];
        protected getCowallById(id: string, cowalls: Types<CowallNode>): CowallNode;
        protected getColumnByAssembelColumnWall(wall: ContentNode): ColumnNode;
        protected getColumnByIdFromCowalls(id: string, cowalls: Types<CowallNode>): ColumnNode;
        protected checkColumn(node: ContentNode): boolean;
        protected computeWallCavityLine(dynamicware: DynamicWareNode, base: WareNode): Line2;
        protected computeWallCompleteLineFromAssembleWall(dynamicWare: ContentNode): Line2;
        protected computeWallInnerDirection(dynamiware: ContentNode): Vector2;
        protected computeWallInnerLine(dynamiware: ContentNode): Line2;
        protected computeWallBaseInfo(dynamicware: ContentNode, base: ContentNode): WallBaseInfo;
        protected computeSurfaceContainerInnerLine(dynamicware: ContentNode, surface: WareNode): Line2;
        protected findChildContainerByName(node: DynamicWareNode, name: string): DataNode;
        protected getRoomWorkPoints(): Types<Vector3>;
        protected getRoomInnerPoints(): Types<Vector3>;
        protected getRoomBeamPoints(): Array<Vector3>;
        protected drawingRoomInstancesAsync(context: DrawingNodeContext, room: RoomNode, openingEnable?: boolean, beamEnable?: boolean, columnEnable?: boolean): Promise<void>;
        protected getBreakOpeningFlagByCode(context: DrawingNodeContext): boolean;
        protected drawingOpenings(document: DrawingDataDocument, room: RoomNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingOpening(document: DrawingDataDocument, opening: OpeningNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingOpeningCode(opening: OpeningNode, matrix?: Matrix4): void;
        protected drawOpeningNodeText(node: ContentNode, startX: number, startY: number, content: string, offset: number): void;
        protected computeVectorsByBoundary(box: BoundaryBox, matrix?: Matrix4): Vector3[];
        textBoxs: Box2[];
        protected isCollision(textBox: Box2): boolean;
        protected getTextOffsetPoint(textStr: string, textHeight: number, originPoint: Vector2, offsetY?: number): Vector2;
        protected textStrIsCollision(textStr: string, textHeight: number, originPoint: Value2): boolean;
        protected getAssembleWallBox(node: ContentNode): Box2;
        protected drawStartPoint(points: Vector2[], borders: Vector2[], path: PathCurve2d, style?: any): void;
        protected computeNearestPoint(points: Vector2[], borders: Vector2[]): ComputeNearestPointResult;
        protected getBeamClipPoints(beam: BeamNode, roomPoints: Vector2[]): Array<Vector2>;
        protected createInstanceInfos(instances: FamilyInstanceNode[], code?: string, textHeight?: number): void;
        protected computeCurve2dNodeCutBySurface(curve2dNode: Curve2dNode, cutsurface: SectionSurface, keepstyleanddrawinglevel?: boolean, includeedge?: boolean): Curve2dNode[];
        protected computeCurve2dNodesCutBySurface(curve2dNodes: Curve2dNode[], cutsurface: SectionSurface, keepstyleanddrawinglevel?: boolean, includeedge?: boolean): Curve2dNode[];
        createNodesProjections(matrixp: Matrix4, nodes: GeometricNode[], style?: any, drawingLevel?: number, drawoption?: DrawingNodeOption): GeometricNode[];
        protected findFlatWallDrawNode(flatwall: FlatWallNode): HardwareNode[];
        protected computeSectionSurfaceByPoints(points: Vector2[]): SectionSurface;
        protected computeLineCurvesFromOrderPoints2d(points: Vector2[]): LineCurve2d[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/module/UnitBathroomBaseTransfer" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingGraphDocument } from 'sk/data/family/drawing/DrawingGraphDocument';
    import { DrawingGraphDocumentService } from 'sk/data/family/service/DrawingGraphDocumentService';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingNodeProjectionData } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class UnitBathroomBaseTransfer extends InstanceObject {
        protected _document: DrawingDataDocument;
        protected _domain: DrawingDomainNode;
        protected _floorplan: FloorplanNode;
        protected _room: RoomNode;
        protected drawingGraphDocuments: Dictionary<DrawingGraphDocument>;
        protected _schemeConfigService: SchemeConfigService;
        protected _drawingGraphDocumentService: DrawingGraphDocumentService;
        constructor(domain: DrawingDomainNode);
        setup(domain: DrawingDomainNode): void;
        get document(): DrawingDataDocument;
        protected appendChildNodesArray(children: DataNode[][]): void;
        protected appendChildNodes(children: Array<DataNode>): void;
        protected appendChildNode(child: DataNode): void;
        processAsync(context: DrawingNodeContext, bathroomNode: BathroomNode): Promise<ResultObject>;
        computeNodeResourceTypeByObserverData(node: ContentNode, matrix: Matrix4): DrawingNodeProjectionData;
        protected findNodeGraphicId(node: DataNode): string;
        protected drawFamilyInstancesByGraphIdAsync(nodes: DataNode[], observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption, checkValid?: boolean): Promise<Array<BrepNode>>;
        protected drawFamilyInstanceByGraphIdAsync(node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
        getGraphContentsAsync(graphId: string, type: string): Promise<DrawingGraphDocument>;
        convertGraphByIdTypeAsync(graphId: string, viewType: string, size: Value2, picMatrix: Matrix4, ref?: Array<BrepNode>): Promise<Array<BrepNode>>;
        protected creatFamilyInstanceByGraphIdAsync(node: DataNode, observerMatrix: Matrix4, replace: boolean, style?: any, context?: DrawingNodeContext, drawingLevel?: number, positionDrawingLevel?: boolean, option?: DrawingNodeOption): Promise<Array<BrepNode>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/module/UnitBathroomOriginFloorTransfer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomBaseTransfer } from "sk/data/scheme/drawing/converter/unitbathroom/design/module/UnitBathroomBaseTransfer";
    export class UnitBathroomOriginFloorTransfer extends UnitBathroomBaseTransfer {
        constructor(domain: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, bathroomNode: BathroomNode): Promise<ResultObject>;
        protected findBindValue(node: ContentNode, parameterCode: string, findslave?: boolean): string;
        protected findLinkRoom(node: ContentNode): RoomNode;
        protected drawingRoomCowalls(room: RoomNode, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected drawingCoWalls(document: DrawingDataDocument, cowalls: Array<CowallNode>, fillEnable: boolean, wallpolygons?: Array<Vector2>): void;
        protected computeDirectionPolygons(polygons: Vector2[][], positive?: boolean): Vector2[][];
        protected computeDirectionPolygon(points: Vector2[], positive?: boolean): Vector2[];
        protected computePolygonDirection(polygon: Vector2[]): boolean;
        private createWallPolygonsWithoutOpening;
        private createFillsByWall;
        protected getAngleFromVector2s(v1: Vector2, v2: Vector2): number;
        protected isInRoom(room: RoomNode, instance: ContentNode, checkBox?: boolean, includeRoomOutline?: boolean): boolean;
        protected checkPolygonsIntersection(polygon: Vector2[], otherpolygon: Vector2[], border?: boolean, tolerance?: number): boolean;
        protected findRoomContents(room: RoomNode, excludearray?: Array<Function>, onlyincludearray?: Array<Function>): FamilyInstanceNode[];
        protected drawingOpenings(document: DrawingDataDocument, room: RoomNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingOpening(document: DrawingDataDocument, opening: OpeningNode, matrix?: Matrix4, style?: any, drawingLeveling?: number, isDrawCode?: boolean): void;
        protected drawingPolygonByVectors(document: DrawingDataDocument, vectors: Vector3[] | Vector2[], style?: any, drawingLevel?: number): PolygonCurve2dDrawingNode;
        protected drawingOpeningCode(opening: OpeningNode, matrix?: Matrix4): void;
        protected drawOpeningNodeText(node: ContentNode, startX: number, startY: number, content: string, offset: number): void;
        protected computeVectorsByBoundary(box: BoundaryBox, matrix?: Matrix4): Vector3[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomAreaPlaneLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomAreaPlaneLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomCeilingManufactureDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomCeilingManufactureDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomCeilingPlaneLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomCeilingPlaneLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomFloorPlaneTileLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomFloorPlaneTileLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomOriginFloorplanDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomOriginFloorplanDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
        processDataAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentNode, option?: any): Promise<any>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWallElevationATileLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWallElevationATileLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        drawingNum: number;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWallElevationBTileLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWallElevationBTileLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        drawingNum: number;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWallElevationCTileLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWallElevationCTileLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        drawingNum: number;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWallElevationDTileLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWallElevationDTileLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        drawingNum: number;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWallElevationManufactureDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWallElevationManufactureDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWallElevationTileLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWallElevationTileLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWallPlaneLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWallPlaneLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/design/UnitBathroomWarePlaneLayoutDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDesignDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/design/base/UnitBathroomDesignDrawingConverter";
    export class UnitBathroomWarePlaneLayoutDrawingConverter extends UnitBathroomDesignDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomFloorDryPlankNode } from "sk/data/scheme/database/assemble/node/BathroomFloorDryPlankNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { BathroomAreaNode } from "sk/data/scheme/database/pattern/node/BathroomAreaNode";
    import { BathroomFloorDryNode } from "sk/data/scheme/database/pattern/node/BathroomFloorDryNode";
    import { BathroomFloorWetNode } from "sk/data/scheme/database/pattern/node/BathroomFloorWetNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeBorderOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { WallSurfaceLineAndPath } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    import { BaseLevelingDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseLevelingDrawingConverter";
    export type BathRoomBoundaryLines = {
        topLine: Line2;
        bottomLine: Line2;
        leftLine: Line2;
        rightLine: Line2;
    };
    export type FloorGroup = {
        dryFloor: WareNode;
        dryTiles: WareNode[];
        dryPlate: WareNode;
        dryBox: BoxSolid;
        drySupports: WareNode[];
        wetFloor: WareNode;
        wetPlate: WareNode;
        wetBox: BoxSolid;
        holes: TechnologyHoleNode[];
        code: string;
        others: FamilyInstanceNode[];
    };
    export type FloorGroupInfo = {
        area: BathroomAreaNode;
        dryFloor: BathroomFloorDryNode;
        wetFloor: BathroomFloorWetNode;
        dryFloorPlanks: BathroomFloorDryPlankNode[];
        dryFloorTiles: ContentNode[];
        holes: TechnologyHoleNode[];
        others: ContentNode[];
        supports: ContentNode[];
        wetothers: FamilyInstanceNode[];
    };
    export type CeilingGroupInfo = {
        planks: PlankNode[];
        others: ContentNode[];
    };
    export type CeilingGroup = {
        planks: WareNode[];
        holes: TechnologyHoleNode[];
        code: string;
        others: FamilyInstanceNode[];
        ceilingBox: BoxSolid;
    };
    export type WallInfo = {
        wall: WareNode;
        planks: ContentNode[];
        tiles: ContentNode[];
        holes: TechnologyHoleNode[];
        others: FamilyInstanceNode[];
    };
    export type WallGroup = {
        wallMap: Map<string, WallInfo[]>;
        code: string;
    };
    export type BathroomAllSplitInfo = {
        style: DrawingUnitBathroomStyleInfo;
        floorGroups: FloorGroupInfo[];
        ceilGroups: CeilingGroupInfo[];
        completeDis: number;
    };
    export type BathroomSplitInfo = {
        style: DrawingUnitBathroomStyleInfo;
        floor: WareNode;
        floorGroups: FloorGroup[];
        walls: WareNode[];
        wallInfos: WallInfo[];
        wallGroups: WallGroup[];
        ceiling: WareNode;
        ceilingGroups: CeilingGroup[];
        linkRoom: RoomNode;
        measures: FamilyInstanceNode[];
        completeDis: number;
        others: FamilyInstanceNode[];
        contentRotation: number;
        ceilingBoxHeight: number;
    };
    export class UnitBathroomDrawingConverter extends BaseLevelingDrawingConverter {
        processAsync(context: DrawingNodeContext, node: DynamicWareNode): Promise<ResultObject<DrawingDataDocument>>;
        protected drawingUnitBathroomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: DynamicWareNode): Promise<void>;
        protected computeDrawingAsync(context: DrawingNodeContext, unitBathroom: DynamicWareNode, option?: any): Promise<any>;
        protected findHoles(plank: ContentNode): ContentNode[];
        protected checkCornerPlank(plank: PlankNode): boolean;
        protected createEmptyBathroomSplitInfoNew(): BathroomAllSplitInfo;
        protected createEmptyBathroomSplitInfo(): BathroomSplitInfo;
        protected createEmptyCeilingGroupInfo(): CeilingGroupInfo;
        protected createEmptyFloorGroupInfo(): FloorGroupInfo;
        protected createEmptyFloorGroup(): FloorGroup;
        protected createEmptyWallGroup(): WallGroup;
        protected createEmptyWallInfo(): WallInfo;
        protected createEmptyCeilingGroup(): CeilingGroup;
        protected createDefaultStyle(): DrawingUnitBathroomStyleInfo;
        protected getSplitBathroomInfoAsyncNew(context: DrawingNodeContext, bathroom: BathroomNode): BathroomAllSplitInfo;
        protected getOpeningInstance(floorplan: BrepNode): FamilyInstanceNode[];
        protected computeCeilingGroupInfo(bathroom: BathroomNode): CeilingGroupInfo;
        protected computeFloorGroupInfo(bathroom: BathroomNode): FloorGroupInfo[];
        protected findBathroomInstanceFamilyInstanceNode(instance: DataNode): FamilyInstanceNode;
        protected findBathroomInstancesFamilyInstancesNodes(instances: DataNode[]): FamilyInstanceNode[];
        protected getSplitBathroomInfoAsync(context: DrawingNodeContext, unitBathroom: DynamicWareNode): Promise<BathroomSplitInfo>;
        protected findDryFloorNode(bathroom: BathroomNode): ContentNode;
        protected findWetFloorNode(bathroom: BathroomNode): ContentNode;
        protected findPlanksFromFloor(floornode: ContentNode): ContentNode[];
        protected othersSplit(info: BathroomSplitInfo): void;
        protected getWallInfoByNodeAsync(context: DrawingNodeContext, wall: WareNode): Promise<WallInfo>;
        protected deleteNullForSplitInfo(info: BathroomSplitInfo): void;
        protected deleteNullForArray(arr: Array<any>): void;
        protected findLinkRoom(node: ContentNode): RoomNode;
        protected drawingLinkRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: DynamicWareNode): Promise<void>;
        protected buildRoomDimensions(node: BrepNode, observerMatrix?: Matrix4): void;
        protected drawReduceGeoNodeArray(nodes: Curve2dNode[], distance: number): GeometricNode[];
        protected drawReduceGeoNode(node: Curve2dNode, distance: number): GeometricNode;
        protected drawingOpening(document: DrawingDataDocument, opening: OpeningNode, matrix?: Matrix4): void;
        protected drawBathroomSurFaceLines(bathroom: BathroomNode | BathroomAreaNode, style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected drawBathroomCavityLines(bathroom: BathroomNode, style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected drawBathroomDryFloorOutline(bathroomfloor: ContentNode): GeometricNode[];
        protected drawBathroomWetFloorOutline(bathroomfloor: ContentNode): GeometricNode[];
        protected drawFloorNodeOutline(bathroomfloor: ContentNode, observerMatrix: Matrix4, style?: any, drawingLevel?: number): Curve2dNode;
        protected drawBathroomFloorOutline(bathroomfloor: ContentNode, style?: any, drawingLevel?: number): GeometricNode[];
        protected drawLine2s(lines: Line2[], style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected findWholePlanksFromBathroomWall(bathroomwall: BathroomWallNode): ContentNode[];
        protected findPlanksFromBathroomWall(bathroomwall: BathroomWallNode): ContentNode[];
        protected computeWallLineAndBox(assembelwall: ContentNode, isouterLine?: boolean): WallSurfaceLineAndPath;
        protected convertlines2linecurves(lines: Line2[]): LineCurve2d[];
        protected computeWallInnerLineDirection(bathroomwall: BathroomWallNode): Vector2;
        protected fetchAllWallsFromBathroom(bathroom: BathroomNode | BathroomAreaNode): BathroomWallNode[];
        protected fetchPlanksFromWall(wall: BathroomWallNode): PlankNode[];
        protected fetchPlanksFromBathroomWall(bathroomwall: BathroomWallNode): WareNode[];
        protected computeContainerPolygon(container: WareNode, clazz: Function, showIdentifyCode?: boolean): Vector3[][];
        protected computeVectorsByBoundary(box: BoundaryBox, matrix?: Matrix4): Vector3[];
        protected createOpeningDimpoints(bathroom: ContentNode, isDrawOpenline?: boolean): Vector2[];
        protected computeOpeningLine(node: ContentNode, dir: Vector2): Line2;
        protected computeOpeningClosedRoomLine(open: ContentNode, orderLines: Line2[]): Line2;
        private findClosedLine;
        protected drawOpenNodeCode(node: ContentNode, line: Line2, index: number): void;
        protected drawingOpeningElement(document: DrawingDataDocument, opening: OpeningNode, matrix: Matrix4, geoStyle?: any, drawomgLevel?: number): PolygonCurve2dDrawingNode;
        protected createDefaultFirstUseBorderOption(borderEnable?: boolean, boxEnable?: boolean, ignoreNoPoints?: boolean): DrawingNodeBorderOption;
        protected drawNodesInnerDimensions(nodes: GeometricNode[], dimdistance?: number, style?: any, drawingLevel?: number): BrepNode[];
        protected drawNodeInnerDimension(node: GeometricNode, dimdistance?: number, style?: any, drawingLevel?: number): BrepNode[];
        protected computeLinesFromPoints(points: Vector2[] | Vector3[]): Line2[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomCeilingDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDrawingConverter, CeilingGroup, CeilingGroupInfo, BathroomAllSplitInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomCeilingDrawingConverter extends UnitBathroomDrawingConverter {
        protected _style: DrawingUnitBathroomStyleInfo;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, unitBathroom: ContentNode): Promise<void>;
        protected drawingDetailsAsync(context: DrawingNodeContext, splitinfo: BathroomAllSplitInfo, groupCount: number, observerMatrix: Matrix4): Promise<void>;
        protected computeDrawingDimensions(context: DrawingNodeContext, option?: any): void;
        protected drawingUnitBathroomNewAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: ContentNode): Promise<void>;
        protected computeCeilDrawingDimensions(ceilingGroup: CeilingGroup): void;
        protected drawOtherDims(anchorpoints: Vector2[], outlinepoints: Vector2[], box: Box2, distanceanchor: number, distanceoutline: number): void;
        protected drawingUnitBathroomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: DynamicWareNode): Promise<void>;
        private drawingGroupCode;
        private drawingCeilOthersNewAsync;
        private drawingCeilOthersAsync;
        private drawingHolesAndDimensions;
        private hasPoint;
        private drawingHoleBorderDimension;
        private drawingHoleCenterDimension;
        private findPlankByWare;
        private getPlankMinPoints;
        private drawingHole;
        private drawingDiameterDimension;
        protected drawingPlankDimensionsNew(ceilingGroup: CeilingGroupInfo, observerMatrix: Matrix4, distance: number): BrepNode[];
        private drawingPlankDimensions;
        protected drawingDimensionByPoints(box: Box2, points: Vector3[], distance: number, style?: any): void;
        protected computeBox(points: Types<Vector3>): Box2;
        protected drawingPlanksNew(context: DrawingNodeContext, document: DrawingDataDocument, ceilingGroup: CeilingGroupInfo, observerMatrix: Matrix4, outlinepolygon?: Vector2[]): void;
        private drawingPlanks;
        private getInfoByName;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomCeilingPlankDrawingConverter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomCeilingDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomCeilingDrawingConverter";
    export class UnitBathroomCeilingPlankDrawingConverter extends UnitBathroomCeilingDrawingConverter {
        processAsync(context: DrawingNodeContext, node: DynamicWareNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, bathroomceiling: DynamicWareNode): Promise<any>;
        protected drawingUnitBathroomAsync(context: DrawingNodeContext, document: DrawingDataDocument, bathroomceiling: DynamicWareNode): Promise<void>;
        protected drawingPlankNodes(document: DrawingDataDocument, planks: PlankNode[]): GeometricNode[];
        protected drawDimensions(document: DrawingDataDocument, plankGeometricNodes: GeometricNode[], planks: PlankNode[]): void;
        protected computeBox(points: Types<Vector3>): Box2;
        protected drawingDimensionByPoints(box: Box2, points: Vector3[], distance: number, style?: any): void;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { DimensionNode } from 'sk/data/family/model/assistant/dimension/DimensionNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeBorderOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { FloorGroup, FloorGroupInfo, UnitBathroomDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export type OutlineGeometrics = {
        drygeo: GeometricNode;
        wetgeo: GeometricNode;
        dryreducegeo: GeometricNode;
        wetreducegeo: GeometricNode;
        holes: GeometricNode[];
        holeanchorpoints: Vector2[];
    };
    export enum UnitFloorDrawingContentEnum {
        DryGeo = 0,
        WetGeo = 1,
        SurfaceLines = 2,
        PlankGeos = 3,
        PlankLines = 4,
        PlankOutLines = 5,
        PlankCodeOutLines = 6,
        DryFloorPlankFinish = 7,
        DryFloorFinishGeo = 8,
        DryFloorReduceFinishGeo = 9,
        DryFinnishGeo = 10,
        WetFinnishGeo = 11,
        HoleGeos = 12,
        HoleAnchorPoints = 13,
        OtherAnchorPoints = 14,
        OtherOutlinePoints = 15,
        SupportOutlinePoints = 16,
        KeelsOutlinePoints = 17,
        ElevationWallPoints = 18
    }
    export class UnitBathroomFloorBaseOutlineDrawingConverter extends UnitBathroomDrawingConverter {
        protected isSplitView: boolean;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: ContentNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: ContentNode, drawingcontext: DrawingNodeContext, option?: any): ResultObject<DrawingDataDocument>;
        protected drawBathroomDryWetFloorOutlines(drawingcontext: DrawingNodeContext, bathroom: BathroomNode): GeometricNode[];
        protected drawDimensions(node: ContentNode, drawcontext: DrawingNodeContext): void;
        protected drawDetail(node: ContentNode, drawcontext: DrawingNodeContext): any;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentNode, option?: any): Promise<any>;
        protected splitGroup(areaNodes: BrepNode[][], splitGap?: number): void;
        protected drawFloorInfo(context: DrawingNodeContext, groupinfo: FloorGroupInfo, style: DrawingUnitBathroomStyleInfo): void;
        protected computeDrawingDimensions(context: DrawingNodeContext, option?: any, bathroom?: ContentNode, isMerge?: boolean): void;
        protected drawDryWetDimPoints(firstgeos: GeometricNode[], box: Box2, node?: ContentNode, distance?: number, style?: any, option?: any): void;
        protected drawTileAndDryInnerDimPoints(firstgeos: GeometricNode[], drygeo: GeometricNode[], box: Box2, distance?: number, style?: any, option?: any): void;
        protected computeDrawingAsyncOldAsync(context: DrawingNodeContext, node: DynamicWareNode, option?: any): Promise<any>;
        protected drawBaseOutlineNew(context: DrawingNodeContext, groupinfo: FloorGroupInfo, drycompleteDis: number, wetcompleteDis: number, style: DrawingUnitBathroomStyleInfo): BrepNode[];
        protected drawWetAreaLable(wetareas: GeometricNode[], label: string): void;
        protected drawBaseOutlineAsync(node: DynamicWareNode, groupinfo: FloorGroup, rotation: number, completeDis: number, style: DrawingUnitBathroomStyleInfo): Promise<OutlineGeometrics>;
        protected drawDetailNewAsync(context: DrawingNodeContext, node: ContentNode, groupinfo: FloorGroupInfo, rotation: number, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected drawDetailAsync(node: DynamicWareNode, groupinfo: FloorGroup, rotation: number, outlinegeos: OutlineGeometrics, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected drawDryAreaAsync(dynamicWare: ContentNode, matrixp: Matrix4, dryware: ContentNode, style?: any, drawingLevel?: number): Promise<GeometricNode>;
        protected drawWetAreaAsync(dynamicWare: ContentNode, matrixp: Matrix4, wetarea: ContentNode, style?: any, drawingLevel?: number): Promise<GeometricNode>;
        protected drawAreaOutlineAsync(contentNode: ContentNode, matrixw: Matrix4, matrixp: Matrix4, style?: any, drawingLevel?: number): Promise<GeometricNode[]>;
        protected drawReduceNodesGeo(nodes: GeometricNode[], distance: number, matrixp: Matrix4): GeometricNode[];
        protected drawReduceGeoNodes(node: GeometricNode, distance: number, matrixp: Matrix4): GeometricNode;
        protected drawHoles(holes: ContentNode[], matrixp: Matrix4, style?: any, drawingLevel?: number, anchorpoints?: Array<Vector2>): GeometricNode[];
        protected drawHoleAsync(dynamicWare: DynamicWareNode, drynode: WareNode, matrixp: Matrix4, style?: any, drawingLevel?: number): Promise<GeometricNode[]>;
        protected drawHolesDimensions(holes: GeometricNode[], dryreducegeos: Curve2dNode[], distance: number, style?: any, innerdimstyle?: any, drawingLevel?: number, borderoption?: DrawingNodeBorderOption, linedims?: Array<BrepNode>): void;
        protected drawCenter2GeosNearestDimension(center: Vector2, curves: Curve2dNode[], distance: number, style?: any, drawingLevel?: number): void;
        protected drawPointAndDirection2LinesNearestDimension(point: Vector2, direction: Vector2, lines: LineCurve2d[], distance: number, style?: any, drawingLevel?: number): void;
        protected computeNearestPointInPoints(points: Vector2[], referpoint: Vector2): Vector2;
        protected drawOutlineDims(dryreducegeo: GeometricNode, wetreducegeo: GeometricNode, box: Box2, distance: number, style?: any, drawingLevel?: number): DimensionNode[];
        protected drawOutlineDimsAsync(dryreducegeo: GeometricNode, wetreducegeo: GeometricNode, box: Box2, distance: number, style?: any, drawingLevel?: number): Promise<DimensionNode[]>;
        protected drawCodeText(box: Box2, distance: number, content: string, style?: any, drawingLevel?: number): GeometricNode;
        protected createDimsAround(points: any, box: Box2, distance: number, style?: any, drawingLevel?: number): DimensionNode[];
        protected findHoles(drynode: WareNode): TechnologyHoleNode[];
        protected clonePolygonPoints(poly: PolygonCurve2dDrawingNode): PointNode[];
        protected checkIfFlip(m: Matrix4): boolean;
        protected computeMovementWithGroups(predrypos: Vector2, curdrypos: Vector2, offset: number): Vector2;
        protected computeOffsetBox(drywetbox: Box2, outlinebox: Box2): Box2;
        protected computeMovement(preBox: Box2, curBox: Box2, movement: Vector2): Vector2;
        protected getDryPos(drygeo: GeometricNode): Vector2;
        protected getAllGeos(outlinegeo: OutlineGeometrics, details: BrepNode[]): BrepNode[];
        protected getConnectionLine(dryarea: GeometricNode, wetarea: GeometricNode): LineCurve2d;
        protected getDirectionFromVector(v: Vector2): number;
        protected checkCurve2dArrayCoincideCurve2d(curve2d: Curve2d, curve2dArray: Curve2d[]): boolean;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFacesWallPlankDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomDimensionGroup } from "sk/data/scheme/drawing/data/DrawingNodeDimension";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { BathroomSplitInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { UnitBathroomFloorBaseOutlineDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    export class UnitBathroomFacesWallPlankDrawingConverter extends UnitBathroomFloorBaseOutlineDrawingConverter {
        protected surfaceName: string;
        protected _groups: Array<DrawingUnitBathroomDimensionGroup>;
        protected _info: BathroomSplitInfo;
        protected showMode: string;
        protected styleInfo: DrawingUnitBathroomStyleInfo;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: DynamicWareNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: DynamicWareNode): Promise<void>;
        protected createPlankAsync(info: BathroomSplitInfo, node: DynamicWareNode, matrixP: Matrix4): Promise<void>;
        protected createTileAsync(info: BathroomSplitInfo, node: DynamicWareNode, matrixP: Matrix4): Promise<void>;
        protected createHoleDimensionAsync(group: DrawingUnitBathroomDimensionGroup): Promise<void>;
        protected findTile(hole: any, group: DrawingUnitBathroomDimensionGroup): void;
        protected findInfoByTile(tile: any, holeTileMap: Map<any, any>): any;
        protected drawTextByBox2(geo: GeometricNode, content: string, textcolor: string, rotation: number, textanchor: number, showlevel: number, document: DrawingDataDocument): GeometricNode;
        protected drawTextByPosition(position: Vector2, content: string, textcolor: string, rotation: number, textanchor: number, showlevel: number, document: DrawingDataDocument): GeometricNode;
        protected drawNodesAsync(): Promise<void>;
        protected drawHoleTileDimensionAsync(holeTileMap: Map<any, any>): Promise<void>;
        protected findHoleDimensionLine(hole: any, outlines: any): any;
        protected drawDimensionAsync(values: Array<any>, box: Box2, name: string): Promise<void>;
        protected buildDimensions1(dimension: any, points: Array<Vector2>, distance: number, color: string): void;
        protected buildDimensionNode1(from: Vector2, to: Vector2, dimPoint2d: Vector2, angle: number, color: string): LineCurveDimensionDrawingNode;
        protected makeTextAsync(box: Box2, offsetDistance: number): Promise<void>;
        drawingAngleFlag(angle: number, x: number, y: number, style?: any, drawingLevel?: number): Array<BrepNode>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorDrawingConverter" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DimensionNode } from 'sk/data/family/model/assistant/dimension/DimensionNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { FloorGroup, FloorGroupInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { UnitBathroomFloorBaseOutlineDrawingConverter, OutlineGeometrics } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    export type DimensionPoints = {
        pointa: Vector2;
        pointb: Vector2;
        dimpoint: Vector2;
    };
    export type DryEdge = {};
    export class UnitBathroomFloorDrawingConverter extends UnitBathroomFloorBaseOutlineDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected drawDetailNewAsync(context: DrawingNodeContext, node: ContentNode, groupinfo: FloorGroupInfo, rotation: number, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentNode, option?: any): Promise<any>;
        protected drawDetailAsync(node: DynamicWareNode, groupinfo: FloorGroup, rotation: number, outlinegeos: OutlineGeometrics, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected getOutlineDimEdge(dryarea: GeometricNode, dryreducearea: GeometricNode, wetarea: GeometricNode): LineCurve2d;
        protected getLeftLineFromLines(lines: LineCurve2d[]): LineCurve2d;
        protected drawHoleDimension(holegeos: GeometricNode[], dryreduce: GeometricNode, dimedge: LineCurve2d, style?: any, drawingLevel?: number): DimensionNode[];
        protected getVerticalDimPoint(holegeo: GeometricNode, dimdistance: number, dryreduce: GeometricNode, dimedge: LineCurve2d): DimensionPoints;
        protected getHorizontalDimPoint(holegeo: GeometricNode, dimdistance: number, drydimEdge: LineCurve2d): DimensionPoints;
        protected drawDimension(pointa: Vector2, pointb: Vector2, dimpoint: Vector2, angle: number, style?: any, drawingLevel?: number): GeometricNode;
        protected drawDiameterDimension(hole: GeometricNode, style?: any, drawingLevel?: number): GeometricNode;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorDryWareDrawingConverter" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DimensionNode } from 'sk/data/family/model/assistant/dimension/DimensionNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomFloorBaseOutlineDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    export class UnitBathroomFloorDryWareDrawingConverter extends UnitBathroomFloorBaseOutlineDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected drawDryWares(dynamicware: DynamicWareNode, wares: WareNode[], matrixp: Matrix4, style?: any, drawingLevel?: number): GeometricNode[];
        protected drawDryWaresAndTextsNew(context: DrawingNodeContext, planks: ContentNode[], matrixp: Matrix4, style?: any, textstyle?: any, drawingLevel?: number, textdrawingLevel?: number, tiletextlengthscale?: number, sizeOrName?: boolean): GeometricNode[];
        protected drawDryWaresAndTexts(dynamicware: DynamicWareNode, wares: WareNode[], matrixp: Matrix4, style?: any, textstyle?: any, drawingLevel?: number, textdrawingLevel?: number): GeometricNode[];
        protected drawDryWaresDimensionsByBox(dryreduce: GeometricNode, waregeos: GeometricNode[], connectionLine: LineCurve2d, distance: number, matrixp: Matrix4, box: Box2, style?: any, drawingLevel?: number): DimensionNode[];
        protected drawDryWaresDimensions(dryreduce: GeometricNode, waregeos: GeometricNode[], connectionLine: LineCurve2d, distance: number, matrixp: Matrix4, style?: any, drawingLevel?: number): DimensionNode[];
        protected drawDryWareText(geo: GeometricNode, content: string, rotation: number, style?: any, drawingLevel?: number, lengthfactor?: number): GeometricNode[];
        protected seperatePointsToBoxAround(points: Vector2[][], box: Box2): any;
        protected seperatePointsWithConnection(points: Vector2[], line: LineCurve2d, matrixp: Matrix4, box: Box2): Vector2[][];
        protected seperateDimPointsByDirection(points: Vector2[], directions: number[], box: Box2): Vector2[][];
        protected pointsAnyToArray(points: any): Vector2[][];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorFinishDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CircleCurve2d } from 'foundation/runtime/geometry/curve2d/CircleCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Geometric } from 'foundation/runtime/geometry/Geometric';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomFloorDryNode } from "sk/data/scheme/database/pattern/node/BathroomFloorDryNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { UnitBathroomDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomFloorFinishDrawingConverter extends UnitBathroomDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: BrepNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawing(node: ContentNode, drawingcontext: DrawingNodeContext, option?: any): ResultObject<DrawingDataDocument>;
        protected drawDryFloorHoles(context: DrawingNodeContext, node: BathroomFloorDryNode): void;
        protected computeCircleDimPointsFromCurve2dNodes(curves: Curve2dNode[]): Vector2[];
        protected computeCirclesCenters(curves: CircleCurve2d[]): Vector2[];
        protected computeDecomposeCurveFromCurve2dNodes(curvenodes: Curve2dNode[]): Curve2d[];
        protected checkOnlyCircle(curve2ds: Curve2d[]): boolean;
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): void;
        drawGeometricProjections(worldMatrix: Matrix4, projectionMatrix: Matrix4, geometric: Geometric, style?: any, drawingLevel?: number, option?: DrawingNodeOption, isPositive?: boolean): GeometricNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorKeelDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomFloorDryNode } from "sk/data/scheme/database/pattern/node/BathroomFloorDryNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomFloorFinishDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorFinishDrawingConverter";
    export class UnitBathroomFloorKeelDrawingConverter extends UnitBathroomFloorFinishDrawingConverter {
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentNode, option?: any): Promise<any>;
        protected findKeelsFromFloorDry(node: BathroomFloorDryNode): ContentNode[];
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): void;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorLinkDrawingConverter" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { FloorGroupInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { UnitBathroomFloorBaseOutlineDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    export class UnitBathroomFloorLinkDrawingConverter extends UnitBathroomFloorBaseOutlineDrawingConverter {
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: any, node: ContentNode): Promise<any>;
        protected drawingLinkRoomAsync(context: DrawingNodeContext, document: DrawingDataDocument, bathroom: ContentNode): Promise<void>;
        private buildLineDimensions;
        protected drawBaseOutlineNew(context: IContext, groupinfo: FloorGroupInfo, drycompleteDis: number, wetcompleteDis: number, style: DrawingUnitBathroomStyleInfo, roomNode?: BathroomNode): BrepNode[];
        protected findLinkRoom(bathroom: ContentNode): RoomNode;
        protected floorlinkDimensions(points: Vector2[]): void;
        private computeBox;
        private drawingDimensionByPoints;
        private drawingOpenings1;
        private drawingOpening1;
        private drawingWalls1;
        private createWallPolygonsWithoutOpening1;
        private createFillsByWall1;
        protected computeBathroomWallCavityLine(bathroomwall: BathroomWallNode): Line2;
        private drawingLineDimension;
        private getVerticalLineByLines;
        private getLineInLineByValue;
        protected removeIntersectionLines(target: Line2[], order: Vector2[], selfinner: Vector2[]): void;
        createRoomInnerLine(room: RoomNode): Array<Line2>;
        createCowallInnerLine(cowall: CowallNode): Line2;
        private computeInnerLines;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorPlankLineDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomFloorPlankLineDrawingConverter extends UnitBathroomDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        process(context: DrawingNodeContext, node: ContentNode, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): void;
        protected computeDrawing(node: ContentNode, drawingcontext: DrawingNodeContext, option?: any): ResultObject<DrawingDataDocument>;
        protected computePathNodes(): void;
        protected drawPlankHoles(context: DrawingNodeContext, node: ContentNode): void;
        protected drawPlankOutlines(context: DrawingNodeContext, node: ContentNode, style?: any, drawingLevel?: number): GeometricNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorPlankFoldDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomFloorDryPlankNode } from "sk/data/scheme/database/assemble/node/BathroomFloorDryPlankNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { UnitBathroomFloorPlankLineDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorPlankLineDrawingConverter";
    export class UnitBathroomFloorPlankFoldDrawingConverter extends UnitBathroomFloorPlankLineDrawingConverter {
        protected computeDrawing(node: ContentNode, drawingcontext: DrawingNodeContext, option?: any): ResultObject<DrawingDataDocument>;
        protected drawPlankEdgeCode(node: BathroomFloorDryPlankNode): void;
        protected drawPlankEdgeCodeLine(node: BathroomFloorDryPlankNode, drawingcontext: DrawingNodeContext): void;
        protected getUpLeftLineDims(outline: GeometricNode[]): Array<any>;
        protected drawingLineDimension(lines: [{
            line2: Line2;
            offset: number;
        }]): void;
        protected drawEdgeCode(edge: EdgeSurfaceNode, plank: BathroomFloorDryPlankNode): void;
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): void;
        protected drawCodeText(node: BathroomFloorDryPlankNode): void;
        drawNodeOutlineProjections(projectionMatrix: Matrix4, node: GeometricNode, style?: any, drawingLevel?: number, option?: DrawingNodeOption, isPositive?: boolean): GeometricNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorPlankOutlineDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomFloorPlankLineDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorPlankLineDrawingConverter";
    export class UnitBathroomFloorPlankOutlineDrawingConverter extends UnitBathroomFloorPlankLineDrawingConverter {
        protected computeDrawing(node: ContentNode, drawingcontext: DrawingNodeContext, option?: any): ResultObject<DrawingDataDocument>;
        protected computeDrawingDimensions(drawingcontext: DrawingNodeContext, option?: any): void;
        protected drawPlankLineDimensions(planklinegeos: GeometricNode[], box: Box2, dimdistance: number, style?: any, drawingLevel?: number): BrepNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorPlanksDrawingConverter" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { FloorGroup, FloorGroupInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { OutlineGeometrics } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    import { UnitBathroomFloorDryWareDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorDryWareDrawingConverter";
    export type DryGeometrics = {
        dryreduce: GeometricNode;
        drygeos: GeometricNode[];
    };
    export class UnitBathroomFloorPlanksDrawingConverter extends UnitBathroomFloorDryWareDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected drawDetail(node: BathroomNode, drawcontext: DrawingNodeContext): void;
        protected drawBathroomWetFloorOutline(bathroomfloor: ContentNode): GeometricNode[];
        protected drawDimensions(node: ContentNode, drawcontext: DrawingNodeContext): void;
        protected drawPlanks(planks: ContentNode[], observeMatrix: Matrix4, style?: any, drawingLevel?: number): GeometricNode[];
        protected drawDetailNewAsync(context: DrawingNodeContext, node: ContentNode, groupinfo: FloorGroupInfo, rotation: number, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected computeDrawingDimensions(context: DrawingNodeContext, option?: any): void;
        protected drawDetailAsync(node: DynamicWareNode, groupinfo: FloorGroup, rotation: number, outlinegeos: OutlineGeometrics, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorSupportDrawingConverter" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingNodeOption } from "sk/data/scheme/drawing/data/DrawingNodeOption";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { FloorGroup, FloorGroupInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { OutlineGeometrics } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    import { UnitBathroomFloorDryWareDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorDryWareDrawingConverter";
    export class UnitBathroomFloorSupportDrawingConverter extends UnitBathroomFloorDryWareDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        protected drawDetailNewAsync(context: DrawingNodeContext, node: ContentNode, groupinfo: FloorGroupInfo, rotation: number, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected computeDrawingDimensions(context: DrawingNodeContext, option?: any): void;
        protected drawDetailAsync(node: DynamicWareNode, groupinfo: FloorGroup, rotation: number, outlinegeos: OutlineGeometrics, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected drawNodesProjections(projectionMatrix: Matrix4, nodes: GeometricNode[], style?: any, drawingLevel?: number, option?: DrawingNodeOption): Curve2dNode[];
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorTilesDrawingConverter" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { FloorGroupInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { UnitBathroomFloorDryWareDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorDryWareDrawingConverter";
    export class UnitBathroomFloorTilesDrawingConverter extends UnitBathroomFloorDryWareDrawingConverter {
        private leftTopPoint;
        constructor(domain?: DrawingDomainNode);
        protected drawDetailNewAsync(context: DrawingNodeContext, node: ContentNode, groupinfo: FloorGroupInfo, rotation: number, style?: DrawingUnitBathroomStyleInfo): Promise<BrepNode[]>;
        protected drawDryWetDimPoints(firstgeos: GeometricNode[], box: Box2, node?: ContentNode, distance?: number, style?: any, option?: any): void;
        private computTileAndDryInnerAreaDistance;
        protected drawTileAndDryInnerDimPoints(firstgeos: GeometricNode[], drygeo: GeometricNode[], box: Box2, distance?: number, style?: any, option?: any): void;
        private findLeftTopPlank;
        private drawDryTileCode;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomPlanDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { FloorGroup, FloorGroupInfo, BathroomAllSplitInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { UnitBathroomFloorBaseOutlineDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    export class UnitBathroomPlanDrawingConverter extends UnitBathroomFloorBaseOutlineDrawingConverter {
        private completeDis;
        private style;
        processAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
        protected drawingDetailsAsync(context: DrawingNodeContext, splitinfo: BathroomAllSplitInfo, groupCount: number, observerMatrix: Matrix4): Promise<void>;
        protected computeDrawingDimensions(context: DrawingNodeContext, option?: any, bathroom?: ContentNode): void;
        processAsyncOldAsync(context: DrawingNodeContext, node: ContentNode): Promise<ResultObject<DrawingDataDocument>>;
        drawingByGroupNewAsync(context: DrawingNodeContext, group: FloorGroupInfo, observerMatrix: Matrix4): Promise<Array<BrepNode>>;
        drawingByGroupAsync(context: DrawingNodeContext, group: FloorGroup, observerMatrix: Matrix4): Promise<Array<BrepNode>>;
        drawingDimsNew(otherKPs: Array<Vector2>, platKPs: Array<Vector2>): Array<BrepNode>;
        drawingDims(otherKPs: Array<Vector2>, platKPs: Array<Vector2>): Array<BrepNode>;
        drawingHoles(group: FloorGroup, observerMatrix: Matrix4): Array<BrepNode>;
        drawingOthersNewAsync(context: DrawingNodeContext, group: FloorGroupInfo, observerMatrix: Matrix4, kps?: Array<Vector2>): Promise<Array<BrepNode>>;
        drawingOthersAsync(context: DrawingNodeContext, group: FloorGroup, observerMatrix: Matrix4, kps?: Array<Vector2>): Promise<Array<BrepNode>>;
        drawingPlateNewAsync(context: DrawingNodeContext, group: FloorGroupInfo, observerMatrix: Matrix4, kps?: Array<Vector2>): Promise<Array<BrepNode>>;
        drawingPlateAsync(context: DrawingNodeContext, group: FloorGroup, observerMatrix: Matrix4, kps?: Array<Vector2>): Promise<Array<BrepNode>>;
        drawingInnerLines(breps: Array<BrepNode>, dis: number, kps?: Array<Vector2>, ref?: Array<BrepNode>): Array<BrepNode>;
        protected buildDimensionByBorderPoints(bps: any, level: number, space: number, style?: any, remark?: string): Array<BrepNode>;
        protected buildDimensionNodes(dimensions: Array<any>, space: number, level: number, style?: any): Array<BrepNode>;
        convertGeometricNodes(nodes: Array<GeometricNode>, observerMatrix: Matrix4, ref?: Array<BrepNode>): Array<BrepNode>;
    }
}
declare module "sk/data/scheme/drawing/util/DrawingNodeProjectorUtil" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Solid } from 'foundation/runtime/geometry/Solid';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PolygonCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/PolygonCurve2dDrawingNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    export class DrawingNodeProjectorUtil {
        static computeProjection(matrixw: Matrix4, matrixp: Matrix4, solid: Solid, fillcolor: string, linecolor: string, showlevel: number, document: DrawingDataDocument): GeometricNode[];
        static drawByPaths(pathcurves: PathCurve2d[], fillcolor: string, linecolor: string, showlevel: number, document: DrawingDataDocument): GeometricNode[];
        static createGeomery(drawpoints: Vector2[], document: DrawingDataDocument, fillcolor: string, linecolor: string): GeometricNode;
        static createCircleCurve(center: Vector3, begin: Vector3, color: string, linecolor: string, showlevel: number, document: DrawingDataDocument): GeometricNode;
        static createLine2d(drawpoingts: Vector2[], document: DrawingDataDocument, color: string): LineCurve2dDrawingNode;
        static createPolygon2d(drawpoints: Vector2[], document: DrawingDataDocument, fillcolor: string, linecolor: string): PolygonCurve2dDrawingNode;
        protected static getPointsFromCurves(curves: Curve2d[]): Vector2[];
        protected static pointsContainPoint(points: Vector3[], point: Vector3): boolean;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomPlanWallPlankDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurveDimensionDrawingNode } from 'sk/data/family/model/brep/drawing/dimension/LineCurveDimensionDrawingNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { BathroomSplitInfo, WallInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    import { UnitBathroomFloorBaseOutlineDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomFloorBaseOutlineDrawingConverter";
    class WallPlanksInfo {
        dimensionNodes: Array<any>;
        noDimensionNodes: Array<any>;
        constructor();
    }
    export class UnitBathroomPlanWallPlankDrawingConverter extends UnitBathroomFloorBaseOutlineDrawingConverter {
        protected _groups: any;
        protected styleInfo: DrawingUnitBathroomStyleInfo;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: DynamicWareNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: DynamicWareNode, option?: any): Promise<any>;
        protected computeDrawingOldAsync(context: DrawingNodeContext, node: DynamicWareNode, option?: any): Promise<any>;
        protected createOutlineAsync(info: BathroomSplitInfo, node: DynamicWareNode): Promise<any>;
        protected createPlanksAsync(info: BathroomSplitInfo, node: DynamicWareNode): Promise<any>;
        protected createWallDimension(wallMapInfos: WallInfo[], group: WallPlanksInfo, name: string, worldMatrix: Matrix4, matrixP: Matrix4): void;
        protected drawNodesAsync(): Promise<void>;
        protected drawDimensionAsync(values: Array<any>, box: Box2, name: string): Promise<void>;
        protected buildDimensionsByPoints(dimension: any, points: Array<Vector2>, distance: number): void;
        protected buildDimensionNodeByPoints(from: Vector2, to: Vector2, dimPoint2d: Vector2, angle: number): LineCurveDimensionDrawingNode;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomRoomFloorMappingDrawingConverter" {
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomRoomFloorMappingDrawingConverter extends UnitBathroomDrawingConverter {
        protected drawingUnitBathroomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: DynamicWareNode): Promise<void>;
        private drawingMeasure;
        private drawingHoleBorderDimension;
        private drawingLineDimension;
        private getRoomMinPoints;
        private drawingDiameterDimension;
        private drawingHole;
        private findTechnologyHoleNode;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomToRoomDrawingConverter" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { RoomNode } from "sk/data/scheme/database/floorplan/model/RoomNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomToRoomDrawingConverter extends UnitBathroomDrawingConverter {
        protected drawingUnitBathroomAsync(context: DrawingNodeContext, document: DrawingDataDocument, node: DynamicWareNode): Promise<void>;
        private drawingDryAndWet;
        private buildLineDimensions;
        private drawingLineDimension;
        private getVerticalLineByLines;
        createRoomInnerLine(room: RoomNode): Array<Line2>;
        createCowallInnerLine(cowall: CowallNode): Line2;
        private computeInnerLines;
        createLine(from: Vector3 | Vector2, to: Vector3 | Vector2): Line2;
        private computeVectorsByPlate;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomWallDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomDimensionGroup } from "sk/data/scheme/drawing/data/DrawingNodeDimension";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDrawingConverter, WallInfo } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomWallDrawingConverter extends UnitBathroomDrawingConverter {
        protected _group: DrawingUnitBathroomDimensionGroup;
        protected _styleInfo: DrawingUnitBathroomStyleInfo;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected getWallInfoByNodeAsync(context: DrawingNodeContext, bathroomWall: BrepNode): Promise<WallInfo>;
        protected createPlanks(walInfo: WallInfo, node: BathroomWallNode, matrixP: Matrix4): void;
        protected drawLineCurves(curves: LineCurve2d[], style?: any, drawingLevel?: number): LineCurve2dDrawingNode[];
        protected checkCornerPlankStart(plank: ContentNode): boolean;
        protected drawingOpeningForBathroomWall(node: BathroomWallNode, matrixP: Matrix4): void;
        protected findHolesFromPlank(plank: PlankNode): TechnologyHoleNode[];
        protected createTiles(walInfo: WallInfo, node: BathroomWallNode, matrixP: Matrix4): void;
        protected drawNodesAndDimensions(wallnode: BathroomWallNode, observeMatrix?: Matrix4): void;
        protected drawHoleGeosInnerDimensions(holegeos: GeometricNode[]): void;
        protected drawFinnishCeilingLines(nodes: Curve2dNode[], bathroomnode: BathroomNode, wallnode: BathroomWallNode, observeMatrix?: Matrix4): BrepNode[];
        protected computeCeilingProjection(bathroomnode: BathroomNode, wallnode: BathroomWallNode, observeMatrix?: Matrix4): SectionSurface[];
        protected computeCeilPlankProjectionsOutlineSectionSurface(ceil: ContentNode, observeMatrix?: Matrix4): SectionSurface[];
        protected computeNodesOutlinesSurface(nodes: Curve2dNode[]): SectionSurface;
        protected createBoundBoxPoints(box: Box2): Vector2[];
        protected drawTextByBox2(geo: GeometricNode, content: string, textcolor: string, rotation: number, textanchor: number, showlevel: number, document: DrawingDataDocument): GeometricNode;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomWallElevationDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomAreaNode } from "sk/data/scheme/database/pattern/node/BathroomAreaNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { UnitBathroomDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomWallElevationDrawingConverter extends UnitBathroomDrawingConverter {
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeObserveMatrix(context: DrawingNodeContext, node: ContentNode): void;
        protected computeDrawing(context: DrawingNodeContext, node: ContentNode, option?: any): void;
        protected drawFamilyInstancesInWall(context: DrawingNodeContext, node: BathroomWallNode, walloutlinepoints: Vector2[]): void;
        protected computeOrderedCurve2dNodesInSection(curve2dnodes: Curve2dNode[], section: SectionSurface): Curve2dNode[];
        protected computeFamilyInstancesInWall(context: DrawingNodeContext, node: BathroomWallNode, walloutlinepoints: Vector2[]): ContentNode[];
        protected computeFamilyInstanceInWall(matrixp: Matrix4, instance: ContentNode, wallpoints: Vector2[]): boolean;
        protected findFamilyInstanceFromBathroom(area: BathroomAreaNode): ContentNode[];
        protected drawWallOutline(context: DrawingNodeContext, node: BathroomWallNode, matrixp: Matrix4, walloutlinepoints?: Array<Vector2>): void;
        protected computeDrawingDimensions(context: DrawingNodeContext, option?: any): void;
    }
}
declare module "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomWallPlankDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { BathroomNode } from "sk/data/scheme/database/pattern/node/BathroomNode";
    import { BathroomWallNode } from "sk/data/scheme/database/pattern/node/BathroomWallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { DrawingUnitBathroomStyleInfo } from "sk/data/scheme/drawing/data/DrawingNodeStyle";
    import { UnitBathroomDrawingConverter } from "sk/data/scheme/drawing/converter/unitbathroom/UnitBathroomDrawingConverter";
    export class UnitBathroomWallPlankDrawingConverter extends UnitBathroomDrawingConverter {
        protected _styleInfo: DrawingUnitBathroomStyleInfo;
        constructor(domain?: DrawingDomainNode);
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawingAsync(context: DrawingNodeContext, node: ContentInstanceNode, option?: any): Promise<any>;
        protected drawBathroomWallsCode(bathroomnode: BathroomNode): void;
        protected drawBathroomWallCode(bathroomwall: BathroomWallNode): void;
        protected createPlankOutLinesAsync(context: DrawingNodeContext, node: ContentInstanceNode): Promise<Map<any, any>>;
        protected drawCornerPlankText(plank: ContentNode, observeMatrix?: Matrix4): void;
        protected checkIsCornerWholePlank(plank: ContentNode): boolean;
        protected computeNodeSurfaceLine(node: ContentNode, observerMatrix?: Matrix4): Line2;
        private drawNodesAndDimensions;
    }
}
declare module "sk/data/scheme/drawing/converter/window/WindowDynamicWareDrawingConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { CowallNode } from "sk/data/scheme/database/floorplan/model/CowallNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    import { BaseDrawingConverter } from "sk/data/scheme/drawing/converter/base/BaseDrawingConverter";
    export class WindowDynamicWareDrawingConverter extends BaseDrawingConverter {
        constructor(domain?: DrawingDomainNode);
        static getHostCowall(node: ContentNode): CowallNode;
        private static findRelationByCodeStatic;
        protected getWindowHostCowall(node: ContentNode): CowallNode;
        processAsync(context: DrawingNodeContext, node: BrepNode, option?: any): Promise<ResultObject<DrawingDataDocument>>;
        protected computeDrawing(node: ContentNode): void;
        computeDomainBoundary(): void;
        private drawingCowall;
        private buildMatrix;
        private computeBox;
        private drawingOpenings;
        private drawingOpening;
        private drawingWindow;
        private drawingCowallBound;
    }
}
declare module "sk/data/scheme/drawing/declare/DrawingGenerator" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class DrawingGenerator extends InstanceObject {
        build(data: any, param?: any): ResultObject<any>;
        buildAsync(context: IContext, data: any, param?: any): Promise<ResultObject<any>>;
    }
}
declare module "sk/data/scheme/drawing/service/DrawingGeneratorService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Service } from 'cross/runtime/module/Service';
    import { DrawingGenerator } from "sk/data/scheme/drawing/declare/DrawingGenerator";
    export class DrawingGeneratorService extends Service {
        protected _items: Dictionary<DrawingGenerator>;
        get(name: string): DrawingGenerator;
        register(name: string, generator: DrawingGenerator): void;
    }
}
declare module "sk/data/scheme/drawing/declare/DrawingGeneratorDeclare" {
    export function DrawingGeneratorDeclare(name: string): (target: any) => void;
}
declare module "sk/data/scheme/drawing/service/DrawingNodeConfigService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Service } from 'cross/runtime/module/Service';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DrawingNodeConfig } from "sk/data/scheme/drawing/config/DrawingNodeConfig";
    import { DrawingNodeConfigItem } from "sk/data/scheme/drawing/config/DrawingNodeConfigItem";
    export class DrawingNodeConfigService extends Service {
        protected _configs: TypeMap<string, DrawingNodeConfig>;
        protected _configItems: TypeMap<string, DrawingNodeConfigItem>;
        getConfigByCode(code: string): DrawingNodeConfig;
        getConfigByNode(node: BrepNode): DrawingNodeConfig;
        registerConfig(code: string, config: DrawingNodeConfig): void;
        getConfigItem(code: string): DrawingNodeConfigItem;
        registerConfigItem(code: string, configItem: DrawingNodeConfigItem): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister" {
    import { MergeConfig } from "sk/data/scheme/drawing/config/DrawingNodeConfig";
    import { DrawingNodeConfigTypeEnum } from "sk/data/scheme/drawing/constants/DrawingNodeConfigTypeEnum";
    export class DrawingNodeConfigRegister {
        protected inactiveItemCodes: Array<string>;
        constructor();
        setup(name: string, code: string, type: DrawingNodeConfigTypeEnum, itemCodes: Array<string>, clazz: Function, parentClazz?: Function, merge?: boolean, mergeDown?: boolean, mergeConfig?: MergeConfig): void;
        private getActiveItemCodes;
    }
}
declare module "sk/data/scheme/drawing/declare/DrawingNodeConfigDeclare" {
    import { MergeConfig } from "sk/data/scheme/drawing/config/DrawingNodeConfig";
    import { DrawingNodeConfigTypeEnum } from "sk/data/scheme/drawing/constants/DrawingNodeConfigTypeEnum";
    export function DrawingNodeConfigDeclare(name: string, code: string, matchType: DrawingNodeConfigTypeEnum, itemCodes: Array<string>, clazz: Function, parentClazz?: Function, merge?: boolean, mergeDown?: boolean, mergeConfig?: MergeConfig): (target: any) => void;
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister" {
    import { DrawingNodeConfigItem } from "sk/data/scheme/drawing/config/DrawingNodeConfigItem";
    export class DrawingNodeConfigItemRegister {
        nameTypes: Array<string>;
        sizes: Array<string>;
        protected item: DrawingNodeConfigItem;
        constructor();
        setup(name: string, drawingName: string, code: string, processCode: string, sizes?: Array<string>, merge?: boolean): void;
    }
}
declare module "sk/data/scheme/drawing/declare/DrawingNodeConfigItemDeclare" {
    export function DrawingNodeConfigItemDeclare(name: string, drawingName: string, itemCode: string, processCode: string, sizes?: Array<string>, merge?: boolean): (target: any) => void;
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister" {
    import { DrawingNodeConverterOption } from "sk/data/scheme/drawing/config/DrawingNodeConverterConfig";
    export class DrawingNodeConverterRegister {
        setup(processCode: string, converterClazz: Function, clazz: Function, drawingOption?: DrawingNodeConverterOption): void;
    }
}
declare module "sk/data/scheme/drawing/declare/DrawingNodeConverterConfigDeclare" {
    import { DrawingNodeConverterOption } from "sk/data/scheme/drawing/config/DrawingNodeConverterConfig";
    export function DrawingNodeConverterConfigDeclare(processCode: string, converterClazz: Function, drawingOption?: DrawingNodeConverterOption): (target: any) => void;
}
declare module "sk/data/scheme/drawing/DrawingSchemeDocument" {
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    import { SchemeStructureElement } from "sk/data/scheme/database/scheme/element/SchemeStructureElement";
    import { SchemeFamilyStructure } from "sk/data/scheme/database/scheme/SchemeFamilyStructure";
    import { SchemeBlueprintNode } from "sk/data/scheme/model/SchemeBlueprintNode";
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class DrawingSchemeDocument extends SchemeDocument {
        blueprint: SchemeBlueprintNode;
        constructor();
        protected loadJsonComplete(context: PersistentContext, jconfig: any): void;
        get rootFamilyStructure(): SchemeFamilyStructure;
        get rootStructure(): SchemeStructureElement;
        reset(): void;
    }
}
declare module "sk/data/scheme/drawing/DrawingSchemeDataDocument" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { DrawingSchemeDocument } from "sk/data/scheme/drawing/DrawingSchemeDocument";
    export class DrawingSchemeDataDocument extends DrawingSchemeDocument {
        protected static _factory: PersistentFactory;
        static get Factory(): PersistentFactory;
        get factory(): PersistentFactory;
        static createEmptyDocument(): DrawingSchemeDocument;
        static createDefaultDocument(): DrawingSchemeDocument;
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeAssembleBeamConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeAssembleBeamConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeAssembleOpeningConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeAssembleOpeningConfigRegister extends DrawingNodeConfigRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeBathroomConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeBathroomConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeChestConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeChestConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeFlatWallConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeFlatWallConfigRegister extends DrawingNodeConfigRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeFloorplanConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeFloorplanConfigRegister extends DrawingNodeConfigRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeFurnitureConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeFurnitureConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeFurnitureCountertopConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeFurnitureCountertopConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeLevelingBeamConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeLevelingBeamConfigRegister extends DrawingNodeConfigRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeLevelingCeilingConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeLevelingCeilingConfigRegister extends DrawingNodeConfigRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeLevelingFloorConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeLevelingFloorConfigRegister extends DrawingNodeConfigRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeLevelingWallConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeLevelingWallConfigRegister extends DrawingNodeConfigRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodePelmetConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodePelmetConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeProxyCeilingConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeProxyCeilingConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeRoomConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeRoomConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/DrawingNodeStandardConfigRegister" {
    import { DrawingNodeConfigRegister } from "sk/data/scheme/drawing/register/config/DrawingNodeConfigRegister";
    export class DrawingNodeStandardConfigRegister extends DrawingNodeConfigRegister {
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeAssembleBeanConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeAssembleBeanConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeFlatWallConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeFlatWallConfigItemRegister extends DrawingNodeConfigItemRegister {
        setup(name: string, drawingName: string, code: string, processCode: string, sizes: Array<string>): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeFloorplanConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeFloorplanConfigItemRegister extends DrawingNodeConfigItemRegister {
        setup(name: string, drawingName: string, code: string, processCode: string, sizes?: Array<string>): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeFurnitureConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeFurnitureConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
        setup(name: string, drawingName: string, code: string, processCode: string, sizes?: string[]): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeFurnitureCountertopConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeFurnitureCountertopConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeLevelingBeamConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeLevelingBeamConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeLevelingCeilingConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeLevelingCeilingConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
        setup(name: string, drawingName: string, code: string, processCode: string, sizes: Array<string>): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeLevelingFloorConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeLevelingFloorConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeLevelingOpeningConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeLevelingOpeningConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeLevelingWallConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeLevelingWallConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
        setup(name: string, drawingName: string, code: string, processCode: string, sizes: Array<string>): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodePelmetConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodePelmetConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeProxyCeilingConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeProxyCeilingConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
        setup(name: string, drawingName: string, code: string, processCode: string, sizes: Array<string>): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeRoomConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeRoomConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeSingleCubeConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeSingleCubeConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeStandardConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeStandardConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
        setup(name: string, drawingName: string, code: string, processCode: string, sizes?: Array<string>): void;
    }
}
declare module "sk/data/scheme/drawing/register/config/item/DrawingNodeUnitBathRoomConfigItemRegister" {
    import { DrawingNodeConfigItemRegister } from "sk/data/scheme/drawing/register/config/item/DrawingNodeConfigItemRegister";
    export class DrawingNodeUnitBathRoomConfigItemRegister extends DrawingNodeConfigItemRegister {
        constructor();
        setup(name: string, drawingName: string, code: string, processCode: string, sizes: Array<string>): void;
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeBeamConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeBeamConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeCubeConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeCubeConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeFlatWallConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeFlatWallConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeFloorplanConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeFloorplanConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeLevelingCeilingConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeLevelingCeilingConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeLevelingFloorConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeLevelingFloorConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeLevelingOpeningConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeLevelingOpeningConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeLevelingWallConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeLevelingWallConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodePelmetConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodePelmetConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeProxyCeilingConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeProxyCeilingConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeRoomConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeRoomConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/register/converter/DrawingNodeUnitBathroomConverterRegister" {
    import { DrawingNodeConverterRegister } from "sk/data/scheme/drawing/register/converter/DrawingNodeConverterRegister";
    export class DrawingNodeUnitBathroomConverterRegister extends DrawingNodeConverterRegister {
    }
}
declare module "sk/data/scheme/drawing/service/DrawingNodeController" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingDataDocument } from 'sk/data/family/drawing/DrawingDataDocument';
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    import { FurnitureCountertopNode } from "sk/data/scheme/database/furniture/node/FurnitureCountertopNode";
    import { DrawingNodeContext } from "sk/data/scheme/drawing/context/DrawingNodeContext";
    export class DrawingNodeController extends InstanceObject {
        protected _node: BrepNode;
        constructor(node?: BrepNode);
        startConvertAsyncNew(context: DrawingNodeContext, node?: BrepNode, domain?: DrawingDomainNode): Promise<ResultObject<DrawingDataDocument>>;
        startConvertWithParaAsyncNew(context: DrawingNodeContext, processCode: string, node?: BrepNode, domain?: DrawingDomainNode): Promise<ResultObject<DrawingDataDocument>>;
        private getStructureConverter;
        private getFurnitureChestConverter;
        private getFurnitureGroupConverter;
        private getFurnitureCountertopConverter;
        startConvertAsync(context: DrawingNodeContext, node?: BrepNode, domain?: DrawingDomainNode): Promise<ResultObject<DrawingDataDocument>>;
        startConvertWithParaAsync(context: DrawingNodeContext, processCode: string, node?: BrepNode, domain?: DrawingDomainNode): Promise<ResultObject<DrawingDataDocument>>;
        protected convertFurnitureChestAsync(node: ChestNode, context: DrawingNodeContext, processCode: string, domain: DrawingDomainNode): Promise<ResultObject>;
        protected convertFurnitureGroupAsync(node: GroupNode, context: DrawingNodeContext, processCode: string, domain: DrawingDomainNode): Promise<ResultObject>;
        protected convertFurnitureCountertopAsync(node: FurnitureCountertopNode, context: DrawingNodeContext, processCode: string, domain: DrawingDomainNode): Promise<ResultObject>;
    }
}
declare module "sk/data/scheme/drawing/template/info/DrawingTemplateProcessUnit" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    export class DrawingTemplateIndexUnit {
        name: string;
        index: number;
        linkId: string;
        children: Array<DrawingTemplateIndexUnit>;
        constructor(name: string, linkId: string, index?: number);
        push(dataNode: DataNode, index?: number): DrawingTemplateIndexUnit;
    }
    export class DrawingTemplateProcessUnit {
        content: DataNode;
        contents: Array<DataNode>;
        linkNode: DataNode;
        linkTemplateId: string;
        code: string;
        referenceNode: DataNode;
        index: number;
        count: number;
        constructor();
        saveData(jcf?: any): any;
        loadData(document: DataDocument, jcf: any): any;
    }
}
declare module "sk/data/scheme/drawing/template/info/DrawingTemplateProcessInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DrawingTemplateProcessUnit } from "sk/data/scheme/drawing/template/info/DrawingTemplateProcessUnit";
    export class DrawingTemplateProcessInfo extends InstanceObject {
        units: Array<DrawingTemplateProcessUnit>;
        constructor(parentNode?: DataNode);
        get contentCount(): number;
        push(content: DataNode, linkNode: DataNode, templateId: string, code?: string, referenceNode?: DataNode): void;
        pushArray(contents: Array<DataNode>, linkNode: DataNode, templateId: string, code?: string, referenceNode?: DataNode): void;
        protected setUnitData(unit: DrawingTemplateProcessUnit, linkNode: DataNode, templateId: string, code?: string, referenceNode?: DataNode): void;
        get(index: number): DrawingTemplateProcessUnit;
    }
}
declare module "sk/data/scheme/drawing/template/DrawingTemplateProcesser" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { SchemeElementPerformerContext } from "sk/data/scheme/performer/element/SchemeElementPerformerContext";
    import { DrawingTemplateProcessInfo } from "sk/data/scheme/drawing/template/info/DrawingTemplateProcessInfo";
    export class DrawingTemplateProcesser extends InstanceObject {
        protected familyType_bathroom: string;
        protected familyType_flatwall: string;
        protected familyType_levelingfloor: string;
        protected familyType_levelingwall: string;
        protected familyType_flatceiling: string;
        processAsync(context: SchemeElementPerformerContext, scheme: FamilyDataDocument, templateId?: string): Promise<ResultObject<DrawingTemplateProcessInfo>>;
        protected findChildrenByClass(parentNode: DataNode, clazz: Function, targets?: Array<DataNode>): Array<DataNode>;
        protected fetchNodesByTypeCodeAsync(context: SchemeElementPerformerContext, nodes: Array<ContentInstanceNode>, typeCode: string, targets?: Array<ContentInstanceNode>): Promise<Array<ContentInstanceNode>>;
        protected fetchChildrenByTypeCodeFromNodeClassAsync(context: SchemeElementPerformerContext, parentNode: DataNode, clazz: Function, typeCode: string, targets?: Array<ContentInstanceNode>): Promise<Array<ContentInstanceNode>>;
        protected isFamilyInstanceSubByCodeAsync(context: SchemeElementPerformerContext, node: ContentInstanceNode, code: string): Promise<boolean>;
        protected getFamilyInfoByNodeAsync(context: SchemeElementPerformerContext, node: ContentInstanceNode): Promise<ISpecificationFamilyInfo>;
    }
}
declare module "sk/data/scheme/drawing/template/service/DrawingTemplateProcessService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Service } from 'cross/runtime/module/Service';
    import { DrawingTemplateProcesser } from "sk/data/scheme/drawing/template/DrawingTemplateProcesser";
    export class DrawingTemplateProcessService extends Service {
        protected _processes: TypeMap<string, DrawingTemplateProcesser>;
        register(type: string, process: DrawingTemplateProcesser): void;
        getProcesser(type: string): DrawingTemplateProcesser;
    }
}
declare module "sk/data/scheme/drawing/template/service/DrawingTemplateProcessDeclare" {
    export function DrawingTemplateProcessDeclare(type: string): (target: any) => any;
}
declare module "sk/data/scheme/drawing/util/DrawingNodeConfiguration" {
    import { DrawingNodeConfigTypeEnum } from "sk/data/scheme/drawing/constants/DrawingNodeConfigTypeEnum";
    export type DrawingNodeConfigInfo = {
        name: string;
        code: string;
        type: DrawingNodeConfigTypeEnum;
        clazz?: Function;
        parentClazz?: Function;
        logicCode?: string;
        drawingCode?: string;
        familyType?: string;
        splitCd?: string;
        items: DrawingNodeConfigCodeMapItem[];
    };
    export type DrawingNodeConfigCodeMapItem = {
        name: string;
        drawingName: string;
        code: string;
        process: string;
        sizeConfig: string;
        defaultSize: string;
        parameter?: any;
        splitCd?: string;
        filterCd?: string;
        convertCad?: boolean;
    };
    export type DrawingNodeConfigCodeMap = {
        [key: string]: DrawingNodeConfigCodeMapItem;
    };
    export class DrawingNodeConfiguration {
        private static _codeMap;
        private static _totalNodeMatchList;
        static formatName(name: string, ...params: string[]): string;
        static get codeMap(): DrawingNodeConfigCodeMap;
        static get totalNodeMatchList(): DrawingNodeConfigInfo[];
    }
}
declare module "sk/data/scheme/drawing/util/NodeProjectionUtil" {
    export class NodeProjectionUtil {
    }
}
declare module "sk/data/scheme/enumeration/SchemeAreaCodeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeAreaCodeEnum extends EnumerationObject {
        static Unknown: string;
        static BathroomShower: string;
        static BathroomToilet: string;
        static BathroomWash: string;
        static BathroomLaundry: string;
        static CompositeCeilingPlane: string;
        static CompositeCeilingEdge: string;
        static CompositeCeilingLeveling: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/enumeration/SchemeFamilyTypeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeFamilyTypeEnum extends EnumerationObject {
        static Unknown: string;
        static normal: string;
        static ceiling: string;
        static wall: string;
        static floor: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/enumeration/SchemeGroupCodeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeGroupCodeEnum extends EnumerationObject {
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/enumeration/SchemeRoomCodeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeRoomCodeEnum extends EnumerationObject {
        static Unknown: string;
        static Bathroom: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/enumeration/SchemeStyleCodeEnum" {
    import { EnumItem } from 'cross/runtime/lang/EnumItem';
    import { EnumerationObject } from 'cross/runtime/framework/base/EnumerationObject';
    export class SchemeStyleCodeEnum extends EnumerationObject {
        static Unknown: string;
        static Minimalist: string;
        static Classic: string;
        private static _items;
        static get Items(): Array<EnumItem>;
    }
}
declare module "sk/data/scheme/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/data/scheme/model/area/SchemeAreaBlueprintNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { GridNode } from 'sk/data/family/model/assistant/GridNode';
    import { FamilyBlueprintNode } from 'sk/data/family/model/FamilyBlueprintNode';
    export class SchemeAreaBlueprintNode extends FamilyBlueprintNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_GRID: string;
        grid: GridNode;
        constructor();
        dispose(): void;
        static create(document: Document): SchemeAreaBlueprintNode;
    }
    export type SchemeAreaBlueprintNodeMap = {
        [key: string]: SchemeAreaBlueprintNode;
    };
}
declare module "sk/data/scheme/model/bom/BomBlueprintNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { DataBlueprintNode } from 'foundation/data/common/model/DataBlueprintNode';
    export class BomBlueprintNode extends DataBlueprintNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): BomBlueprintNode;
    }
    export type BomBlueprintNodeMap = {
        [key: string]: BomBlueprintNode;
    };
}
declare module "sk/data/scheme/model/bom/BomDocument" {
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { BomStructureElement } from "sk/data/scheme/database/bom/element/BomStructureElement";
    import { BomFamilyStructure } from "sk/data/scheme/database/bom/BomFamilyStructure";
    import { BomBlueprintNode } from "sk/data/scheme/model/bom/BomBlueprintNode";
    export class BomDocument extends FamilyDocument {
        blueprint: BomBlueprintNode;
        protected constructor();
        get rootFamilyStructure(): BomFamilyStructure;
        get rootStructure(): BomStructureElement;
        setup(): void;
        reset(): void;
    }
}
declare module "sk/data/scheme/model/bom/BomDataDocument" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { BomDocument } from "sk/data/scheme/model/bom/BomDocument";
    export class BomDataDocument extends BomDocument {
        protected static _factory: PersistentFactory;
        static get Factory(): PersistentFactory;
        get factory(): PersistentFactory;
        static createEmptyDocument(): BomDataDocument;
        static createDefaultDocument(): BomDataDocument;
    }
}
declare module "sk/data/scheme/model/bom/BomMaterialAdditionNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class BomMaterialAdditionNode extends DataNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_CODE: string;
        static FIELD_NAME: string;
        static FIELD_DATA_TYPE: string;
        static FIELD_VALUE: string;
        code: string;
        name: string;
        dataType: string;
        value: string;
        constructor();
        dispose(): void;
        static create(document: Document): BomMaterialAdditionNode;
    }
    export type BomMaterialAdditionNodeMap = {
        [key: string]: BomMaterialAdditionNode;
    };
}
declare module "sk/data/scheme/model/bom/BomMeteringNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class BomMeteringNode extends DataNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_CODE: string;
        static FIELD_NAME: string;
        static FIELD_VALUE: string;
        static FIELD_UNIT_CODE: string;
        static FIELD_UNIT_NAME: string;
        static FIELD_UNIT_TYPE: string;
        code: string;
        name: string;
        value: string;
        unitCode: string;
        unitName: string;
        unitType: number;
        valuePrecisionCd: string;
        valuePrecision: number;
        valueMin: number;
        valueMax: number;
        rules: any;
        constructor();
        dispose(): void;
        static create(document: Document): BomMeteringNode;
    }
    export type BomMeteringNodeMap = {
        [key: string]: BomMeteringNode;
    };
}
declare module "sk/data/scheme/model/bom/BomMaterialNode" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Document } from 'cross/runtime/framework/document/Document';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { BomMaterialAdditionNode } from "sk/data/scheme/model/bom/BomMaterialAdditionNode";
    import { BomMeteringNode } from "sk/data/scheme/model/bom/BomMeteringNode";
    export class BomMaterialNode extends DataNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        static FIELD_REFERENCE_INFO_ID: string;
        static FIELD_REFERENCE_INFO_TYPE: string;
        static FIELD_FLAT_WALL_NODE_ID: string;
        static FIELD_LINK_NODE_ID: string;
        static FIELD_DECLARE_ID: string;
        static FIELD_FAMILY_ID: string;
        static FIELD_FAMILY_CODE: string;
        static FIELD_FAMILY_NAME: string;
        static FIELD_FAMILY_TYPE_ID: string;
        static FIELD_FAMILY_TYPE_CODE: string;
        static FIELD_FAMILY_TYPE_NAME: string;
        static FIELD_PRODUCT_BUSINESS_TYPE: string;
        static FIELD_PRODUCT_SYMBOL_ID: string;
        static FIELD_MATERIAL_ID: string;
        static FIELD_MATERIAL_CODE: string;
        static FIELD_MATERIAL_NAME: string;
        static FIELD_MATERIAL_TYPE_ID: string;
        static FIELD_MATERIAL_TYPE_NAME: string;
        static FIELD_SERIAL_NUMBER: string;
        static FIELD_IDENTIFY_CODE: string;
        static FIELD_NODE_TYPE: string;
        static FIELD_EXPAND_FIELDS: string;
        static FIELD_LENGTH_X: string;
        static FIELD_LENGTH_Y: string;
        static FIELD_LENGTH_Z: string;
        static FIELD_UNIT_CODE: string;
        static FIELD_UNIT_TYPE: string;
        static FIELD_UNIT_VALUE: string;
        static FIELD_SUPPLY_SYMBOL: string;
        static FIELD_UNIT_PRICE: string;
        static FIELD_TOTAL_PRICE: string;
        static FIELD_VALUATION_RULE_NAME: string;
        static FIELD_STATISTICS_CODE: string;
        static FIELD_STATISTICS_VALUE: string;
        static FIELD_OPTION_CONTAINER: string;
        static FIELD_FEATURES: string;
        static FIELD_MACHINING_INFO: string;
        static FIELD_METERING_INFOS: string;
        static FIELD_VALUATIONS: string;
        static FIELD_VARIABLES: string;
        static FIELD_ADDITIONS: string;
        static FIELD_REMARK: string;
        referenceInfoId: string;
        referenceInfoType: string;
        flatWallNodeId: string;
        linkNodeId: string;
        declareId: string;
        familyId: string;
        familyCode: string;
        familyName: string;
        familyTypeId: string;
        familyTypeCode: string;
        familyTypeName: string;
        productBusinessType: number;
        productSymbolId: string;
        materialId: string;
        materialCode: string;
        materialName: string;
        materialTypeId: string;
        materialTypeName: string;
        serialNumber: string;
        identifyCode: string;
        nodeType: string;
        expandFields: any;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        unitCode: string;
        unitType: number;
        unitValue: number;
        supplySymbol: any;
        unitPrice: number;
        totalPrice: number;
        valuationRuleName: string;
        statisticsCode: string;
        statisticsValue: number;
        optionContainer: boolean;
        features: string;
        machiningInfo: any;
        meteringInfos: Types<BomMeteringNode>;
        valuations: Dictionary<any>;
        variables: Dictionary<any>;
        additions: Types<BomMaterialAdditionNode>;
        remark: string;
        referenceNode: DataNode;
        referenceInfo: ISpecificationFamilyInfo;
        decorateAreaAdd: number;
        isDecorateLayout: boolean;
        constructor();
        dispose(): void;
        static create(document: Document): BomMaterialNode;
    }
    export type BomMaterialNodeMap = {
        [key: string]: BomMaterialNode;
    };
}
declare module "sk/data/scheme/model/SchemeDataDocumentChecker" {
    import { DataDocumentChecker } from 'foundation/data/common/model/DataDocumentChecker';
    export class SchemeDataDocumentChecker extends DataDocumentChecker {
    }
}
declare module "sk/data/scheme/model/SchemeDocumentContext" {
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    export class SchemeDocumentContext extends PersistentContext {
    }
}
declare module "sk/data/scheme/model/SchemeDocumentStorage" {
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Element } from 'sk/data/family/element/base/Element';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class SchemeDocumentStorage extends BaseObject {
        id: string;
        protected _document: SchemeDocument;
        protected _previewJson: any;
        protected _previewEncrypt: any;
        setDocument(document: SchemeDocument): void;
        onElementFilter(element: Element): boolean;
        processAsync(context: IContext): Promise<ResultObject>;
        getPreviewString(): string;
    }
}
declare module "sk/data/scheme/model/SchemeObserverEnum" {
    export class SchemeObserverEnum {
        static FirstPerson: string;
        static AerialView: string;
        static NormalRender: string;
        static BirdRender: string;
        static PanoRender: string;
        static Orthogonal: string;
    }
}
declare module "sk/data/scheme/model/SchemeStructureDataDocument" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class SchemeStructureDataDocument extends SchemeDocument {
        protected static _factory: PersistentFactory;
        static get Factory(): PersistentFactory;
        protected constructor();
        get factory(): PersistentFactory;
        static createEmptyDocument(json?: any): SchemeStructureDataDocument;
        static createDefaultDocument(): SchemeStructureDataDocument;
        loadSchemeDocumentJson(jconfig: any, options?: any): void;
        loadSchemeDocumentBinary(documentSource: any, options?: any): void;
    }
}
declare module "sk/data/scheme/model/spliter/SpliterUtil" {
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { SegmentSplitterBase } from 'foundation/runtime/graphics/spatial/box/SegmentRelation';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ChestNode } from "sk/data/scheme/database/furniture/model/ChestNode";
    import { EntireSpace } from "sk/data/scheme/model/spliter/EntireSpace";
    export class SpliterUtil {
        static computePivotLocalBox(node: FamilyInstanceNode): BoxSolid;
        static compute(context: ElementPerformerContext, chest: ChestNode, filterSpaceSize?: number): EntireSpace;
        static convert(segmentSplitters: SegmentSplitterBase[]): EntireSpace;
    }
}
declare module "sk/data/scheme/model/spliter/surface/SurfaceBase" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class SurfaceBase {
        normal: Vector3;
        constructor();
    }
}
declare module "sk/data/scheme/model/spliter/surface/SurfaceRectangle" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SurfaceBase } from "sk/data/scheme/model/spliter/surface/SurfaceBase";
    export class SurfaceRectangle extends SurfaceBase {
        p1: Vector3;
        p2: Vector3;
        p3: Vector3;
        p4: Vector3;
    }
}
declare module "sk/data/scheme/model/structure/SchemeStructureBlueprintNode" {
    import { Document } from 'cross/runtime/framework/document/Document';
    import { FamilyBlueprintNode } from 'sk/data/family/model/FamilyBlueprintNode';
    export class SchemeStructureBlueprintNode extends FamilyBlueprintNode {
        static CLASS_ID: string;
        static CLASS_NAME: string;
        constructor();
        dispose(): void;
        static create(document: Document): SchemeStructureBlueprintNode;
    }
    export type SchemeStructureBlueprintNodeMap = {
        [key: string]: SchemeStructureBlueprintNode;
    };
}
declare module "sk/data/scheme/model/util/CompositeUtil" {
    import { CompositeNode } from "sk/data/scheme/database/furniture/model/CompositeNode";
    export class CompositeUtil {
        static setChildrenFlag(composite: CompositeNode, type: Function, flag: number, value: boolean): void;
        static setChildrenVisible(composite: CompositeNode, type: Function, visible: boolean): void;
        static setChildrenRandomColor(composite: CompositeNode, type: Function): void;
    }
}
declare module "sk/data/scheme/model/util/OctreeUtil" {
    import { Octree } from 'foundation/runtime/geometry/Octree';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class OctreeUtil {
        static compute(node: ContentNode, octree?: Octree<ContentNode>): void;
    }
}
declare module "sk/data/scheme/util/SchemeCollisionUtil" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContactSurfaceNode } from 'sk/data/family/model/assistant/contact/ContactSurfaceNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    export class SchemeCollisionResult {
        a: ContentNode;
        d: ContentNode;
        constructor(a: ContentNode, d: ContentNode);
    }
    export class SchemeCollisionUtil {
        static snapContentToContent(targetContent: ContentInstanceNode, targetContactCode: string, sourceContent: ContentInstanceNode, sourceContactCode: string): boolean;
        static getContentContactSurfaceLocalMatrix(content: ContentInstanceNode, target?: Matrix4): Matrix4;
        static getContactSurfaceLocalMatrix(contactSurface: ContactSurfaceNode, target?: Matrix4): Matrix4;
        static getLocalMatrixByAxisData(origin: Vector3, normal: Vector3, axisX: Vector3, target?: Matrix4): Matrix4;
        static collisionTest(attacks: Array<ContentNode>, defenses: Array<ContentNode>): TypeMap<string, SchemeCollisionResult>;
    }
}
declare module "sk/data/scheme/model/validator/PlankCollisionValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { NodeStatusService } from 'foundation/data/common/service/NodeStatusService';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class PlankMaterialThicknessValidator extends DataDocumentValidator {
        protected _nodeStatusService: NodeStatusService;
        process(context: ValidateContext, content: SchemeDocument): ResultEnum;
    }
}
declare module "sk/data/scheme/util/FurnitureMaterialUtil" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    export class FurnitureMaterialUtil {
        static getMaterialThickness(variableProvider: BrepElement, valueProvider: any): number;
    }
}
declare module "sk/data/scheme/model/validator/PlankMaterialThicknessValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { NodeStatusService } from 'foundation/data/common/service/NodeStatusService';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class PlankMaterialThicknessValidator extends DataDocumentValidator {
        protected _nodeStatusService: NodeStatusService;
        process(context: ValidateContext, content: SchemeDocument): ResultEnum;
    }
}
declare module "sk/data/scheme/model/validator/SchemeRelationValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class SchemeRelationValidator extends DataDocumentValidator {
        process(context: ValidateContext, content: SchemeDocument): ResultEnum;
    }
}
declare module "sk/data/scheme/model/validator/SchemeTechnologyValidateFactory" {
    import { FamilyValidateFactory } from 'sk/data/family/validator/FamilyValidateFactory';
    export class SchemeTechnologyValidateFactory extends FamilyValidateFactory {
        constructor();
    }
}
declare module "sk/data/scheme/model/validator/SchemeValidateFactory" {
    import { FamilyValidateFactory } from 'sk/data/family/validator/FamilyValidateFactory';
    export class SchemeValidateFactory extends FamilyValidateFactory {
        constructor();
    }
}
declare module "sk/data/scheme/molding/furniture/CountertopGraphic3dStructure" {
    import { BrepBody } from 'foundation/runtime/geometry/brep/BrepBody';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    export class CountertopGraphic3dStructure extends MoldingGeometryStructure {
        data: BrepBody;
        surfaces: Array<{
            mesh: BufferGeometry;
            surface: Surface;
        }>;
        constructor();
        reset(): void;
        dispose(): void;
        merges(): void;
    }
}
declare module "sk/data/scheme/molding/MoldingEventEnum" {
    export class MoldingEventEnum {
        static readonly MoldingError = "molding.error";
    }
}
declare module "sk/data/scheme/molding/util/PlankCollisionUtil" {
    import { ComplexHoleSurface } from 'foundation/runtime/geometry/surface/ComplexHoleSurface';
    import { FloorplanNode } from "sk/data/scheme/database/floorplan/model/FloorplanNode";
    import { PlankNode } from "sk/data/scheme/database/furniture/model/PlankNode";
    export type ClipPlankList = {
        planks: Array<{
            plank: PlankNode;
            polygon: Array<ComplexHoleSurface>;
        }>;
    };
    export class PlankCollisionUtil {
        static floorPlanCollidByPlanks(floorPlan: FloorplanNode, planks: Array<PlankNode>, tolerance?: number): ClipPlankList;
    }
}
declare module "sk/data/scheme/performer/element/DeclareCache" {
    import { NumberDictionary } from 'cross/runtime/lang/collection/NumberDictionary';
    import { Element } from 'sk/data/family/element/base/Element';
    import { DataCache } from 'sk/data/family/performer/DataCache';
    export class DeclareCache extends DataCache {
        id: number;
        sourceElement: Element;
        targetElement: Element;
        protected _pool: NumberDictionary<Element>;
        constructor();
        allocByType(type: any): Element;
        allocByFamilyInfoId(familyInfoId: string): Element;
        allocByPatternId(patternId: String): Element;
        lock(): void;
        unlock(): void;
        dispose(flag?: boolean): void;
    }
}
declare module "sk/data/scheme/performer/element/DeclarePerformerContext" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementBasePerformerContext } from 'sk/data/family/performer/element/ElementBasePerformerContext';
    import { SchemeConfigService } from "sk/data/scheme/config/SchemeConfigService";
    import { DeclareCache } from "sk/data/scheme/performer/element/DeclareCache";
    import { DeclareElementPerformer } from "sk/data/scheme/performer/element/DeclareElementPerformer";
    export class DeclarePerformerContext extends ElementBasePerformerContext {
        cacheName: string;
        protected _declareCaches: Map<number, DeclareCache>;
        protected _familyInfoIds: Dictionary<any>;
        protected _familyTypePerformers: Dictionary<DeclareElementPerformer>;
        protected _schemeConfigService: SchemeConfigService;
        getCache(element: Element): DeclareCache;
        findPerformerByCode(code: string): DeclareElementPerformer;
        findPerformerByClass(clazz: any, typeCd?: string): DeclareElementPerformer;
        findPerformerAsync(element: Element): Promise<ResultObject<DeclareElementPerformer>>;
        getTypePerformerByFamilyIdAsync(familyId: string): Promise<ResultObject<DeclareElementPerformer>>;
        getFamilyInfoIdByFamilyIdAsync(familyId: string): Promise<ResultObject<string>>;
        free(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/performer/element/DeclareElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { DataPerformer } from 'sk/data/family/performer/DataPerformer';
    import { DeclarePerformerContext } from "sk/data/scheme/performer/element/DeclarePerformerContext";
    export abstract class DeclareElementPerformer extends DataPerformer {
        optionReleation: boolean;
        optionReleationRecursive: boolean;
        createElement(context: DeclarePerformerContext, container: NestElement, reference: Element, parameters?: any): Element;
        createElementAsync(context: DeclarePerformerContext, container: NestElement, reference: Element, parameters?: any): Promise<ResultObject<Element>>;
        computeProperty(context: DeclarePerformerContext, source: Element, target: Element): void;
        computePropertyAsync(context: DeclarePerformerContext, source: Element, target: Element): Promise<ResultObject>;
        buildStructureBefore(context: DeclarePerformerContext, source: Element, target: Element): void;
        buildStructureReleation(context: DeclarePerformerContext, element: Element, recursive?: boolean): void;
        buildStructureAfter(context: DeclarePerformerContext, source: Element, target: Element): void;
        checkValid(context: DeclarePerformerContext, target: Element): boolean;
        buildStructureAsync(context: DeclarePerformerContext, source: Element, target: Element): Promise<ElementPerformerResult>;
    }
}
declare module "sk/data/scheme/performer/element/DrawingSchemeElementPerformerContext" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Text2dNode } from 'sk/data/family/model/assistant/text/Text2dNode';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { DrawingFrameNode } from 'sk/data/family/drawing/model/DrawingFrameNode';
    import { SchemeElementPerformerContext } from "sk/data/scheme/performer/element/SchemeElementPerformerContext";
    export class DrawingSchemeElementPerformerContext extends SchemeElementPerformerContext {
        protected framePropertyTextMap: Dictionary<any>;
        protected frameTextNodes: Dictionary<Array<Text2dNode>>;
        getFrameTextMapById(frameId: string): any;
        setFrameTextMap(frameId: string, map: any): void;
        createEmptyFrameTextMap(frameId: string): any;
        getFrameTextNodesById(frameId: string): any;
        setFrameTextNodes(frameId: string, nodes: Array<Text2dNode>): void;
        createEmptyFrameTextNodes(frameId: string): Array<Text2dNode>;
        findFrameNodeByDomainNode(domain: DrawingDomainNode): DrawingFrameNode;
        free(): void;
        dispose(): void;
    }
}
declare module "sk/data/scheme/render/RenderEnvironmentEnum" {
    export class RenderEnvironmentEnum {
        static Day: string;
        static Dusk: string;
        static Night: string;
    }
}
declare module "sk/data/scheme/render/RenderSizeEnum" {
    export class RenderSizeEnum {
        static SAA: string;
        static SAB: string;
        static SAC: string;
        static SAD: string;
        static SBA: string;
        static SBB: string;
        static SBC: string;
        static SBD: string;
        static SCA: string;
        static SCB: string;
        static SCC: string;
        static SCD: string;
        static BAA: string;
        static BAB: string;
        static BAC: string;
        static BAD: string;
        static BBA: string;
        static BBB: string;
        static BBC: string;
        static BBD: string;
        static BCA: string;
        static BCB: string;
        static BCC: string;
        static BCD: string;
        static PDA: string;
        static PDB: string;
        static PDC: string;
        static PDD: string;
        static FAA: string;
        static FAB: string;
        static FAC: string;
        static FAD: string;
        static GAA: string;
        static GAB: string;
        static GAC: string;
        static GAD: string;
        static HAA: string;
        static HAB: string;
        static HAC: string;
        static HAD: string;
        static JAA: string;
        static JAB: string;
        static JAC: string;
        static JAD: string;
        static JAE: string;
        static KAA: string;
        static KAB: string;
        static KAC: string;
        static KAD: string;
        static KAE: string;
        static KAF: string;
        static toDisplay(sizeCd: string): string;
        static getClarityByResolution(renderSize: string): string;
        private static getNameMap;
        private static RENDER_SIZE_NAME_MAP;
        static getClarityBySize(size: string): string;
    }
}
declare module "sk/data/scheme/render/RenderUtil" {
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    export class RenderUtil {
        static setSchemeObserver(document: DataDocument, renderParams: any): void;
    }
}
declare module "sk/data/scheme/service/BusinessService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { JsonService } from 'cross/core/module/json/JsonService';
    import { LogicSessionService } from 'cross/data/module/logic/session/LogicSessionService';
    export class BusinessService {
        protected _jsonService: JsonService;
        protected _environmentService: EnvironmentService;
        protected _sessionService: LogicSessionService;
        commitContractAsync(context: ContextObject, parameter: {
            purchaseOrderCode: string;
            schemeIds: number;
            token: string;
        }): Promise<ResultObject>;
        commitHomeContractAsync(context: ContextObject, parameter: {
            orderCode: string;
            schemeId: number;
            token: string;
        }): Promise<ResultObject>;
        getHomeContractStatusAsync(context: ContextObject, parameter: {
            token: string;
            orderCode: string;
        }): Promise<ResultObject<{
            success: boolean;
            msg: string;
            data: any;
            orderCode?: string;
            statusCd?: number;
            changeReason: string;
        }>>;
        getContractStatusAsync(context: ContextObject, parameter: {
            purchaseOrderCode: string;
            schemeIds: number;
            token: string;
        }): Promise<ResultObject<{
            success: boolean;
            msg: string;
            data: any;
            purchaseOrderCode?: string;
            statusCd?: number;
            changeReason: string;
        }>>;
        getUserInfoAsync(context: ContextObject, parameter: {
            token: string;
            orderCode?: string;
            schemeId?: string;
        }): Promise<ResultObject<{
            success: boolean;
            msg: string;
            data: {
                id: string;
                userName: string;
                orgTypeCd: number;
                orgId: string;
            };
        }>>;
        loginByUserInfoAsync(context: ContextObject, userInfo: {
            userId: string;
            userName: string;
            orgTypeCd: number;
            orgId: string;
        }): Promise<ResultObject>;
        loginAsync(context: ContextObject): Promise<ResultObject>;
        businessSaveAsync(context: ContextObject, schemeInfo: {
            schemeName: string;
            coverPicture: string;
            parameterId: string;
            storageId: string;
            linkSchemeId: string;
            linkSchemeVersion: string;
            bomFileUri: string;
            drawingResults: Array<any>;
            ipdResults: Array<any>;
        }): Promise<ResultObject>;
    }
}
declare module "sk/data/scheme/service/CatalogLogicService" {
    import { CatalogBaseLogicService } from 'foundation/data/common/service/CatalogBaseLogicService';
    export class CatalogLogicService extends CatalogBaseLogicService {
        constructor();
    }
}
declare module "sk/data/scheme/service/DesignLogicUnit" {
    import { LogicUnit } from 'foundation/data/common/logic/LogicUnit';
    export class DesignLogicUnit extends LogicUnit {
        guid: string;
        name: string;
        houseType: string;
        houseStyle: string;
        area: number;
        aHousingEstate: string;
        colourScheme: number;
        instruction: string;
        province: string;
        city: string;
        packageId: string;
        labels: Array<string>;
        labelName: string;
    }
}
declare module "sk/data/scheme/service/DesignService" {
    import { LogicUnitService } from 'foundation/data/common/logic/LogicUnitService';
    import { DesignLogicUnit } from "sk/data/scheme/service/DesignLogicUnit";
    export class DesignService extends LogicUnitService<DesignLogicUnit> {
        findByGuid(guid: string): DesignLogicUnit;
        createLogicUnit(): DesignLogicUnit;
    }
}
declare module "sk/data/scheme/service/MetaInfo" {
    export class MetaInfo {
        id: string;
        skuid: string;
        name: string;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        previewUrl: string;
        topviewUrl: string;
        modelUrl: string;
        modelTextureUrl: string;
        entityCount: number;
        loadFromJson(obj: any): void;
    }
}
declare module "sk/data/scheme/service/SchemeStructureDocumentService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ProcessPipeService } from 'cross/runtime/module/pipe/ProcessPipeService';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { DataDocumentResult } from 'cross/data/module/document/DataDocumentResult';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { WorkflowProcesResult } from 'foundation/data/common/workflow/process/WorkflowProcesResult';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { WorkflowProcessService } from 'sk/data/family/workflow/WorkflowProcessService';
    import { SchemeDataDocument } from "sk/data/scheme/model/SchemeDataDocument";
    import { SchemeTechnologyDataDocument } from "sk/data/scheme/model/SchemeTechnologyDataDocument";
    export type SchemeStructureWorkflowBuildOptions = {
        cacheName: string;
        sourceDocument: FamilyDocument;
        sourceElement?: Element;
        targetDocument: FamilyDocument;
        targetElement?: Element;
        calculatorTypeCd?: string;
        calculatorCd?: string;
        parameters?: any;
        processForce?: boolean;
    };
    export type SchemeStructureWorkflowOptions = {
        document?: FamilyDocument;
        element?: Element;
        calculatorTypeCd?: string;
        calculatorCd?: string;
        processForce?: boolean;
        processComposite?: boolean;
        processRule?: boolean;
        processBoundary?: boolean;
        processMolding?: boolean;
        processCollision?: boolean;
        parameters?: any;
        force?: boolean;
        roomMode?: boolean;
        clearCache?: boolean;
        createAll?: boolean;
    };
    export class SchemeStructureDocumentService extends DataDocumentService<SchemeDataDocument> {
        protected _workflowProcessService: WorkflowProcessService;
        protected _processPipeService: ProcessPipeService;
        constructor();
        loadDocumentAsync(context: ContextObject, id: string, version?: AssetVersionType, force?: boolean): Promise<DataDocumentResult>;
        loadMetaAsync(context: ContextObject, id: string): Promise<ResultObject>;
        loadDataAsync(context: ContextObject, id: string, version?: AssetVersionType, parameters?: DataDocumentParameters): Promise<DataDocumentResult>;
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeDataDocument;
        loadSchemeDocumentByStorageIdAsync(storageId: string): Promise<ResultObject<SchemeTechnologyDataDocument>>;
        computeWorkflow(context: ContextObject, name: string, options: SchemeStructureWorkflowOptions): WorkflowProcesResult;
        computeWorkflowAsync(context: ContextObject, name: string, options: SchemeStructureWorkflowOptions): Promise<WorkflowProcesResult>;
        buildWorkflowAsync(context: ContextObject, name: string, options: SchemeStructureWorkflowBuildOptions): Promise<WorkflowProcesResult>;
    }
}
declare module "sk/data/scheme/service/SchemeTechnologyDocumentService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { WorkflowProcesResult } from 'foundation/data/common/workflow/process/WorkflowProcesResult';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { WorkflowProcessService } from 'sk/data/family/workflow/WorkflowProcessService';
    import { SchemeTechnologyDataDocument } from "sk/data/scheme/model/SchemeTechnologyDataDocument";
    type SchemeWorkflowOptions = {
        document: FamilyDocument;
        element?: Element;
        calculatorTypeCd?: string;
        calculatorCd?: string;
        processForce?: boolean;
        processComposite?: boolean;
        processRule?: boolean;
        processBoundary?: boolean;
        processMolding?: boolean;
        parameters?: any;
        force?: boolean;
    };
    export class SchemeTechnologyDocumentService extends DataDocumentService<SchemeTechnologyDataDocument> {
        protected _workflowProcessService: WorkflowProcessService;
        constructor();
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeTechnologyDataDocument;
        computeWorkflow(context: ContextObject, name: string, options: SchemeWorkflowOptions): WorkflowProcesResult;
        loadSchemeDocumentByStorageIdAsync(context: ContextObject, storageId: string): Promise<ResultObject<SchemeTechnologyDataDocument>>;
    }
}
declare module "sk/data/scheme/service/SchemeWorkflowOptions" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class SchemeWorkflowOptions {
        document: FamilyDocument;
        element: Element;
        content: any;
        calculatorTypeCd: string;
        calculatorCd: string;
        processSyncLock: boolean;
        processSyncPipe: boolean;
        processForce: boolean;
        processComposite: boolean;
        processShape: boolean;
        processRule: boolean;
        processBoundary: boolean;
        processStructure: boolean;
        processTechnology: boolean;
        processMolding: boolean;
        processCollision: boolean;
        processSkipFamily: boolean;
        disableFieldChanged: boolean;
        parameters: any;
        force: boolean;
        roomMode: boolean;
        clearCache: boolean;
        createAll: boolean;
    }
}
declare module "sk/data/scheme/service/StructureSchemeDocumentService" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataDocumentParameters } from 'cross/data/module/document/DataDocumentParameters';
    import { MongoStorageDownloadParameters } from 'foundation/data/common/storage/mongo/MongoStorageDownloadParameters';
    import { WorkflowProcesResult } from 'foundation/data/common/workflow/process/WorkflowProcesResult';
    import { DataDocumentService } from 'foundation/data/common/service/DataDocumentService';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { WorkflowProcessService } from 'sk/data/family/workflow/WorkflowProcessService';
    import { SchemeDataDocument } from "sk/data/scheme/model/SchemeDataDocument";
    import { SchemeTechnologyDataDocument } from "sk/data/scheme/model/SchemeTechnologyDataDocument";
    export type SchemeWorkflowOption = {
        document: FamilyDocument;
        element?: Element;
        calculatorTypeCd?: string;
        calculatorCd?: string;
        processForce?: boolean;
        processComposite?: boolean;
        processRule?: boolean;
        processBoundary?: boolean;
        processMolding?: boolean;
        parameters?: any;
        force?: boolean;
        roomMode?: boolean;
    };
    export class StructureSchemeDocumentService extends DataDocumentService<SchemeDataDocument> {
        protected _workflowProcessService: WorkflowProcessService;
        constructor();
        protected makeUrl(parameters: DataDocumentParameters): string;
        protected makeStorageDownloadParameters(parameters: DataDocumentParameters): MongoStorageDownloadParameters;
        protected makeDocument(parameters: DataDocumentParameters, content: any): SchemeDataDocument;
        loadSchemeDocumentByStorageIdAsync(storageId: string): Promise<ResultObject<SchemeTechnologyDataDocument>>;
        computeWorkflow(context: ContextObject, name: string, options: SchemeWorkflowOption): WorkflowProcesResult;
        computeWorkflowAsync(context: ContextObject, name: string, options: SchemeWorkflowOption): Promise<WorkflowProcesResult>;
    }
}
declare module "sk/data/scheme/service/TechniqueLogicUnit" {
    import { LogicUnit } from 'foundation/data/common/logic/LogicUnit';
    export class TechniqueLogicUnit extends LogicUnit {
        contentType: string;
        skuId: string;
        name: string;
        catalogTypeCd: string;
        loadJson(jconfig: any): void;
    }
}
declare module "sk/data/scheme/shape/ShapeDesignFactory" {
    import { MoldingFactory } from 'foundation/core/module/molding/MoldingFactory';
    import { MoldingOptions } from 'foundation/core/module/molding/MoldingOptions';
    import { MoldingResult } from 'foundation/core/module/molding/MoldingResult';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { DataShapeContext } from 'foundation/data/common/shape/DataShapeContext';
    export class ShapeDesignFactory extends MoldingFactory {
        convertNode(context: DataShapeContext, content: DataNode): void;
        convert(document: DataDocument, options?: MoldingOptions): MoldingResult;
    }
}
declare module "sk/data/scheme/util/ComponentUtil" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { SchemeElementPerformerContext } from "sk/data/scheme/performer/element/SchemeElementPerformerContext";
    import { SchemeLibraryFamilyDocumentService } from "sk/data/scheme/config/SchemeLibraryFamilyDocumentService";
    type ComponentElementMap = {
        instance?: ComponentInstanceElement;
        structure?: ComponentElement;
        reference?: ComponentElement;
    };
    export class ComponentUtil {
        protected static _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        protected static _calculatorService: CalculatorService;
        static findComponentElementMapByInstanceElementAsync(context: IContext, element: ContentInstanceElement): Promise<ResultObject<ComponentElementMap>>;
        static findInstanceStructureByContentInstanceElementAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement): Promise<ResultObject<ComponentInstanceElement>>;
        static findStructureByFamilyInstanceElementAsync(context: SchemeElementPerformerContext, element?: FamilyInstanceElement, referenceInfoId?: string): Promise<ResultObject<ComponentElement>>;
        static findComponentElementByFamilyInfoIdAsync(context: SchemeElementPerformerContext, familyInfoId: string): Promise<ResultObject<ComponentElement>>;
    }
}
declare module "sk/data/scheme/util/SchemeAssetUtil" {
    import { StorageDigitizationTypeEnum } from 'foundation/data/common/enumeration/StorageDigitizationTypeEnum';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    export class SchemeAssetUtil {
        static makePathUrl(id: string, version?: AssetVersionType): string;
        static makeConfigUrl(id: string, version?: AssetVersionType, typeCd?: StorageDigitizationTypeEnum): string;
    }
}
declare module "sk/data/scheme/util/SchemeBlueprintUtil" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { SchemeBlueprintNode } from "sk/data/scheme/model/SchemeBlueprintNode";
    export class SchemeBlueprintUtil {
        static getContentBoundaryBox(blueprint: SchemeBlueprintNode): Box3;
        private static expandWallBox;
    }
}
declare module "sk/data/scheme/util/SchemePickerUtil" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Ray3 } from 'foundation/runtime/geometry/Ray3';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class SchemePikcerItem {
        node: ContentNode;
        distance: number;
        point: Vector3;
    }
    export class SchemePickerUtil {
        static picker(ray: Ray3, node: DataNode, filters?: Array<any>): Array<SchemePikcerItem>;
        static pickerLine(ray: Ray3, buff: BufferGeometry): Array<SchemePikcerItem>;
        private static sort;
        private static pickerSphere;
        static pickerFirst(ray: Ray3, node: DataNode, filters?: Array<any>): SchemePikcerItem;
    }
}
declare module "sk/data/scheme/validator/FurnitureValidateFactory" {
    import { ValidateFactory } from 'foundation/core/module/validate/ValidateFactory';
    export class FurnitureValidateFactory extends ValidateFactory {
        constructor();
    }
}
declare module "sk/data/scheme/validator/SchemeElementValidateMessage" {
    import { ValidateMessage } from 'foundation/core/module/validate/ValidateMessage';
    import { Element } from 'sk/data/family/element/base/Element';
    export class SchemeElementValidateMessage extends ValidateMessage {
        content: Element;
        constructor(content: Element, message?: string, ...parameters: Array<any>);
    }
}
declare module "sk/data/scheme/validator/SchemeValidateProcessor" {
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataValidateProcessor } from 'foundation/data/common/validator/DataValidateProcessor';
    import { SchemeDocument } from "sk/data/scheme/model/SchemeDocument";
    export class SchemeValidateProcessor extends DataValidateProcessor {
        content: SchemeDocument;
        validate(context: ValidateContext, document: SchemeDocument): void;
    }
}
declare module "sk/data/scheme/validator/SchemeValidateFactory" {
    import { ValidateFactory } from 'foundation/core/module/validate/ValidateFactory';
    export class SchemeValidateFactory extends ValidateFactory {
        constructor();
    }
}