/// <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-logic.d.ts" />
/// <reference path="../typings/private/sk-data-family.d.ts" />
/// <reference path="../typings/private/sk-data-resource.d.ts" />
/// <reference path="../typings/private/sk-data-scheme.d.ts" />
declare module "copyright" {
    export class RuleDataCopyright {
        static toString(): string;
    }
}
declare module "sk/rule/data/algorithm/AlgorithmInput" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { FreeObject } from 'cross/runtime/lang/FreeObject';
    export type AlgorithmParameterInfo = {
        code: string;
        type: any;
        isArray: boolean;
    };
    export class AlgorithmInput extends FreeObject {
        context: ContextObject;
        private _parameterInfos;
        private _parameters;
        constructor(algorithmParameterInfos: AlgorithmParameterInfo[]);
        set(code: string, value: any): void;
        get(code: string): any;
        dispose(): void;
    }
}
declare module "sk/rule/data/algorithm/AlgorithmOutput" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { DeclareResult } from 'cross/data/module/declare/DeclareResult';
    export type AlgorithmResultInfo = {
        code: string;
        type: any;
        isArray: boolean;
    };
    export class AlgorithmOutput extends DeclareResult {
        context: ContextObject;
        _content: Dictionary<any>;
        _resultInfos: Dictionary<any>;
        constructor(algorithmResultInfos: AlgorithmResultInfo[]);
        get(code: string): any;
        set(code: string, value: any): void;
    }
}
declare module "sk/rule/data/algorithm/AlgorithmProcess" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AlgorithmInput } from "sk/rule/data/algorithm/AlgorithmInput";
    import { AlgorithmOutput } from "sk/rule/data/algorithm/AlgorithmOutput";
    export class AlgorithmProcess extends Dispatcher {
        processAsync(context: ContextObject, input: AlgorithmInput, output: AlgorithmOutput): Promise<ResultObject>;
        process(context: ContextObject, input: AlgorithmInput, output: AlgorithmOutput): void;
    }
}
declare module "sk/rule/data/algorithm/AlgorithmTypeEnum" {
    export class AlgorithmTypeEnum {
        static Line: string;
    }
}
declare module "sk/rule/data/algorithm/AlgorithmService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { AlgorithmParameterInfo } from "sk/rule/data/algorithm/AlgorithmInput";
    import { AlgorithmOutput, AlgorithmResultInfo } from "sk/rule/data/algorithm/AlgorithmOutput";
    import { AlgorithmTypeEnum } from "sk/rule/data/algorithm/AlgorithmTypeEnum";
    export type AlgorithmDeclareInfo = {
        name: string;
        code: string;
        type: AlgorithmTypeEnum;
        clazz: any;
        optionProcessAsync: boolean;
        parameterInfos: AlgorithmParameterInfo[];
        resultInfos: AlgorithmResultInfo[];
    };
    export class AlgorithmService extends Service {
        protected _declares: Types<AlgorithmDeclareInfo>;
        get declares(): Types<AlgorithmDeclareInfo>;
        findDeclareByCode(code: string): AlgorithmDeclareInfo;
        findDeclareByClazz(clazz: any): AlgorithmDeclareInfo;
        registerDeclare(name: string, code: string, type: AlgorithmTypeEnum, clazz: any, parameterInfos: AlgorithmParameterInfo[], resultInfos: AlgorithmResultInfo[], optionProcessAsync: boolean): void;
        processAsync(context: ContextObject, code: string, params?: any): Promise<ResultObject<AlgorithmOutput>>;
    }
}
declare module "sk/rule/data/algorithm/AlgorithmProcessDeclare" {
    import { AlgorithmParameterInfo } from "sk/rule/data/algorithm/AlgorithmInput";
    import { AlgorithmResultInfo } from "sk/rule/data/algorithm/AlgorithmOutput";
    import { AlgorithmTypeEnum } from "sk/rule/data/algorithm/AlgorithmTypeEnum";
    export function AlgorithmProcessDeclare(code: string, name: string, type: AlgorithmTypeEnum, parameterInfos: AlgorithmParameterInfo[], resultInfos: AlgorithmResultInfo[], optionProcessAsync?: boolean): (target: any) => void;
}
declare module "sk/rule/data/algorithm/process/TrisectionAlgorithmProcess" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { AlgorithmInput } from "sk/rule/data/algorithm/AlgorithmInput";
    import { AlgorithmOutput } from "sk/rule/data/algorithm/AlgorithmOutput";
    import { AlgorithmProcess } from "sk/rule/data/algorithm/AlgorithmProcess";
    export class TrisectionAlgorithmProcess extends AlgorithmProcess {
        process(context: ContextObject, input: AlgorithmInput, output: AlgorithmOutput): void;
    }
}
declare module "sk/rule/data/base/CalculateElementPerformerContext" {
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    export class CalculateElementPerformerContext extends SchemeElementPerformerContext {
    }
}
declare module "sk/rule/data/base/DataPerformerUtil" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    export class DataPerformerUtil {
        static dirtyNodeGeometry(node: DataNode, dirty: boolean): void;
        static dirtyNodeGeometryFlag(node: BrepNode): void;
    }
}
declare module "sk/rule/data/base/node/performer/AdjustXYZWDHNodePerformerUtil" {
    import { SizeRelationElement } from 'sk/data/family/element/config/relation/SizeRelationElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class AdjustXYZWDHNodePerformerUtil {
        static computeAdjustXYZWDHReleation(context: ElementPerformerContext, element: ContentElement, relation: SizeRelationElement): void;
    }
}
declare module "sk/rule/data/base/node/performer/ContactNodePerformerUtil" {
    import { Ray3 } from 'foundation/runtime/geometry/Ray3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { HostRelationElement } from 'sk/data/family/element/config/relation/HostRelationElement';
    import { ContactPointNode } from 'sk/data/family/model/assistant/contact/ContactPointNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class ContactNodePerformerUtil {
        static snapPointPoint(master: ContentElement, masterNode: ContentNode, masterCatactNode: ContactPointNode, slave: ContentElement, slaveNode: ContentNode, slaveContactNode: ContactPointNode): void;
        static snapLinePoint(master: ContentElement, masterNode: ContentNode, masterCatactNode: ContactPointNode, slave: ContentElement, slaveNode: ContentNode, slaveContactNode: ContactPointNode): void;
        static snapSurfacePoint(master: ContentElement, masterNode: ContentNode, masterCatactNode: ContactPointNode, slave: ContentElement, slaveNode: ContentNode, slaveContactNode: ContactPointNode): void;
        static computeHostReleation(context: ElementPerformerContext, element: ContentElement, relation: HostRelationElement): void;
        static createHostRelation(master: BrepElement, masterCode: string, slave: FamilyInstanceElement, slaveCode: string): HostRelationElement;
        private static instersectChildren;
        static intersectWithBoundarySphere(ray: Ray3, entity: ContentNode): boolean;
    }
}
declare module "sk/rule/data/base/element/DataElementPerformerUtil" {
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementCloneOptions } from 'sk/data/family/performer/element/ElementPerformer';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class DataElementPerformerUtil {
        static copyProperty(context: ElementPerformerContext, persistentContext: PersistentContext, source: Element, target: Element, options?: ElementCloneOptions): Element;
        static hasHostReleation(element: Element): boolean;
    }
}
declare module "sk/rule/data/base/element/DataElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { FormulaReference } from 'sk/data/family/element/config/formula/FormulaReference';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementCloneOptions, ElementPerformer } from 'sk/data/family/performer/element/ElementPerformer';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    export class DataElementCache extends ElementCache {
        statusConfigure: boolean;
        statusCondition: boolean;
    }
    export abstract class DataElementPerformer extends ElementPerformer {
        optionChild: boolean;
        optionMultiChild: boolean;
        static componentElementOptions: ElementCloneOptions;
        protected _familyConfigService: FamilyConfigService;
        createElementAsync(context: ElementPerformerContext, containerElement: NestElement, element: Element, parameters?: any): Promise<ResultObject<Element>>;
        computeElementProperty(context: ElementPerformerContext, source: Element, target: Element, parameters?: any): void;
        buildElementReleation(context: ElementPerformerContext, element: NestElement): void;
        prepareAsync(context: ElementPerformerContext, containerElement: NestElement, element: Element, parameters?: any): Promise<ElementPerformerResult>;
        computeCondition(context: ElementPerformerContext, element: NestElement, node: DataNode, parameters?: any): ResultEnum;
        computeStructureShapeAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ResultObject>;
        computeStructureRuleAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ResultObject>;
        computeStructureRuleBeforeAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ResultObject>;
        computeStructureRuleAfterAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ResultObject>;
        computeStructureBefore(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): ResultEnum;
        testStructureBuild(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): boolean;
        computeStructureBuildAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ResultObject>;
        computeStructureBeforeAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ResultObject>;
        computeStructureChildren(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): ResultEnum;
        computeStructureAfterAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ResultObject>;
        computeStructure(context: ElementPerformerContext, element: NestElement, node: DataNode, parameters?: any): ResultEnum;
        rebuildStructureChildrenAsync(context: ElementPerformerContext, element: Element): Promise<ResultObject>;
        computeChildrenRefrancePropertys(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): void;
        computeFormulaReference(context: ElementPerformerContext, formulaReference: FormulaReference): void;
        computeStructureChildrenAsync(context: ElementPerformerContext, element: Element, node: DataNode, parameters?: any): Promise<ElementPerformerResult>;
        computeStructureAsync(context: ElementPerformerContext, element: NestElement, node: DataNode, parameters?: any): Promise<ElementPerformerResult>;
        computeElementStructureAsync(context: ElementPerformerContext, parentElement: NestElement, element: NestElement, parameters?: any): Promise<ElementPerformerResult>;
        computeDecorateAsync(context: ElementPerformerContext, element: Element, parameters?: any): Promise<ResultObject>;
        computeShapeChildReleation(context: ElementPerformerContext, element: NestElement, parameters?: any): ResultEnum;
        computeShapeReleationAsync(context: ElementPerformerContext, element: Element, parameters?: any): Promise<ResultEnum>;
        protected computeCloneDeep(context: ElementPerformerContext, persistentContext: PersistentContext, element: Element, newElement: Element, options?: ElementCloneOptions): Element;
        protected computeCloneReleation(context: ElementPerformerContext, persistentContext: PersistentContext, element: Element, newEement: Element, options?: ElementCloneOptions): void;
        getElementFromDifferentDocument(context: ElementPerformerContext, persistentContext: PersistentContext, element: Element, document: FamilyDocument): Element;
        copy(source: Element, target: Element, options?: ElementCloneOptions): void;
        copyDeep(context: ElementPerformerContext, source: Element, target: Element, options?: ElementCloneOptions): void;
        clone(element: Element, options?: ElementCloneOptions): Element;
        deepClone(element: Element, options?: ElementCloneOptions): Element;
    }
}
declare module "sk/rule/data/performer/util/PlaneSurfaceElementUtil" {
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    export class PlaneSurfaceElementUtil {
        static setNodeMaterialRotation(node: PlaneSurfaceNode, features?: any): void;
    }
}
declare module "sk/rule/data/performer/util/ElementPerformerBindingValueUtil" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { VariableValueStructure } from 'sk/data/family/element/config/variable/VariableValueStructure';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class ElementPerformerBindingValueUtil {
        static computeElementDecorateVariableSubstrate(context: ElementPerformerContext, element: BrepElement, node: BrepNode, bindingValue: DecorateValueStructure, variable: VariableValueStructure): void;
        static computeElementDecorateVariableMaterial(context: ElementPerformerContext, element: BrepElement, node: BrepNode, bindingValue: DecorateValueStructure, variable: VariableValueStructure): void;
        static computeElementDecorateVariableDepth(context: ElementPerformerContext, element: BrepElement, node: BrepNode, bindingValue: DecorateValueStructure, variable: VariableValueStructure): void;
        static computeElementDecorateVariableRotation(context: ElementPerformerContext, element: BrepElement, node: BrepNode, bindingValue: DecorateValueStructure, variable: VariableValueStructure): void;
        static computeElementDecorateVariableCollection(context: ElementPerformerContext, element: BrepElement, node: BrepNode, bindingValue: DecorateValueStructure, variable: VariableValueStructure): void;
        static computeSurfaceRotation(context: ElementPerformerContext, element: PlaneElement, node: PlaneNode): void;
        static computeElementDecorateItem(context: ElementPerformerContext, element: BrepElement, node: BrepNode, bindingValue: DecorateValueStructure): void;
        static computeElementBindingValues(context: ElementPerformerContext, element: BrepElement, node: BrepNode): void;
        static computeElementToNodeBeforeComputeStructure(context: ElementPerformerContext, element: BrepElement, node: BrepNode): void;
        static computeElementToNodeAfterComputeStructure(context: ElementPerformerContext, element: BrepElement, node: BrepNode): void;
        static hasDecorateCollectionProperty(element: BrepElement): boolean;
        static hasDecorateCollectionValue(element: BrepElement): boolean;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeNestElementPerformer" {
    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 { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { DataElementCache, DataElementPerformer } from "sk/rule/data/base/element/DataElementPerformer";
    export class SchemeNestElementCache extends DataElementCache {
    }
    export class SchemeNestElementPerformer extends DataElementPerformer {
        buildChildElementAsync(context: SchemeElementPerformerContext, parentElement: NestElement, element: Element): Promise<ResultObject>;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: NestElement, element: NestElement, parameters?: any): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/layout/LayoutResultTile" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { ClipBoundary } from 'foundation/data/common/model/base/ClipBoundary';
    export class TileLocation {
        x: number;
        y: number;
        z: number;
        surface: SectionSurface;
        materialInfoId: string;
        refrenceInfoId: string;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        constructor();
    }
    export class LayoutResultTile {
        tiles: Types<TileLocation>;
        tileId: string;
        proifleId: string;
        clipBoundary: ClipBoundary;
        constructor();
    }
}
declare module "sk/rule/data/layout/LayoutDocumentComputeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { LayoutTileInstanceElement } from 'sk/data/family/structure/layout/element/LayoutTileInstanceElement';
    import { LayoutDocument } from 'sk/data/family/structure/layout/LayoutDocument';
    import { LayoutResultTile } from "sk/rule/data/layout/LayoutResultTile";
    export class LayoutDocumentComputeUtil {
        static layoutTileCompute(context: IContext, tileInstance: LayoutTileInstanceElement, w: number, d: number): LayoutResultTile;
        static layoutCompute(context: IContext, document: LayoutDocument): Types<LayoutResultTile>;
    }
}
declare module "sk/rule/data/profile/ProfileSerialPoints" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class ProfileSerialPoints {
        points: Types<Vector3>;
        anchor: Vector3;
        constructor();
    }
}
declare module "sk/rule/data/profile/ProfileDocumentComputeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { CurveElement } from 'sk/data/family/element/brep/geometric/CurveElement';
    import { VariableElement } from 'sk/data/family/element/config/variable/VariableElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ProfileDocument } from 'sk/data/family/structure/profile/ProfileDocument';
    import { ProfileSerialPoints } from "sk/rule/data/profile/ProfileSerialPoints";
    export class ProfileDocumentComputeUtil {
        static profileCompute(context: ElementPerformerContext, document: ProfileDocument, lengthX?: number, lengthY?: number, segment?: number): ProfileSerialPoints;
        static profilePointsChangeByAnchor(profilePoints: Vector3[], anchor: Vector3): void;
        static profileSerialPointsAsync(context: ElementPerformerContext, profileId: string, parameters: Array<VariableElement>): Promise<ProfileSerialPoints>;
        static profileSerialPointsSync(context: ElementPerformerContext, document: ProfileDocument, parameters: Array<VariableElement>): any;
        static profileCurvesAsync(context: ElementPerformerContext, profileId: string, parameters: Array<VariableElement>): Promise<Types<CurveElement>>;
        private static changePointsByLength;
        private static changePointsByAnchor;
        private static toPointsByLine;
        private static toPointsByCircle;
        private static toPointsByCircleArc;
        private static uniquePointsByCurves;
        private static toPointsByCurves;
        static calCircleCenter(p1: Vector3, p2: Vector3, r: number): Array<Vector3>;
    }
}
declare module "sk/rule/data/base/element/brep/AreaPerformerUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { TilePropertyStructure } from 'sk/data/family/element/config/tile/TilePropertyStructure';
    import { TileValueStructure } from 'sk/data/family/element/config/tile/TileValueStructure';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { LayoutComponentElement } from 'sk/data/family/element/component/LayoutComponentElement';
    import { PropertyStructure } from 'sk/data/family/element/config/PropertyStructure';
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { WareElement } from 'sk/data/family/element/instance/WareElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { LayoutDocument } from 'sk/data/family/structure/layout/LayoutDocument';
    import { ProfileDocument } from 'sk/data/family/structure/profile/ProfileDocument';
    import { DecorateBindTypeEnum } from 'sk/data/family/enumeration/DecorateBindTypeEnum';
    import { LayoutResultTile } from "sk/rule/data/layout/LayoutResultTile";
    export class AreaPerformerUtil {
        static findTileBindingValue(bindingValues: Types<TileValueStructure>, tileId: string): TileValueStructure;
        static findBindingProperty(bindingProperties: Types<PropertyStructure>, tileId: string): TilePropertyStructure;
        static parametersLayoutTransmit(context: ElementPerformerContext, document: LayoutDocument, element: LayoutComponentElement | LayoutElement | AreaPolygonElement, node: DataNode): void;
        static parametersProfileTransmit(context: ElementPerformerContext, document: ProfileDocument, element: LayoutComponentElement | LayoutElement | AreaPolygonElement): void;
        static getProfileDocumentAsync(context: ElementPerformerContext, profileId: string, version?: string): Promise<ProfileDocument>;
        private static loadMeshResourceDataAsync;
        private static addMeshElement;
        private static resetMeshElementProperty;
        private static addFamilyElementAsync;
        private static resetFamilyElementProperty;
        private static loadFamilyDataAsync;
        static createLayoutElementAsync(context: ElementPerformerContext, element: LayoutComponentElement | LayoutElement | AreaPolygonElement, layoutTiles: LayoutResultTile, linkCd: DecorateBindTypeEnum, linkId: string, version: string, node: ContentNode): Promise<ResultObject>;
        static buildLayoutAsync(context: ElementPerformerContext, element: LayoutComponentElement | LayoutElement | AreaPolygonElement, node: ContentNode): Promise<ResultObject>;
        static loadLayoutDocumentAsync(context: ElementPerformerContext, element: LayoutComponentElement | LayoutElement | AreaPolygonElement): Promise<ResultObject>;
        static buildLayoutChildElementAsync(context: ElementPerformerContext, parentElement: NestElement, element: WareElement | ComponentInstanceElement): Promise<void>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/HoleTypeEnum" {
    export enum HoleTypeEnum {
        HOLE_DOOR = 1,
        HOLE_WINDOW = 2,
        HOLE_BEAM = 3,
        HOLE_CEILING = 4,
        HOLE_NORMAL = 5,
        HOLE_CUT = 6,
        HOLE_SUBDOOR = 7,
        HOLE_MAINDOOR = 8
    }
}
declare module "sk/rule/data/layout/LayoutInfoComputeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { LayoutResultTile } from "sk/rule/data/layout/LayoutResultTile";
    export class LayoutInfoCompouteUtil {
        static layoutCompute(context: IContext, element: LayoutElement): Types<LayoutResultTile>;
    }
}
declare module "sk/rule/data/base/element/brep/LayoutPerformerUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { TilePropertyStructure } from 'sk/data/family/element/config/tile/TilePropertyStructure';
    import { TileValueStructure } from 'sk/data/family/element/config/tile/TileValueStructure';
    import { LayoutComponentElement } from 'sk/data/family/element/component/LayoutComponentElement';
    import { PropertyStructure } from 'sk/data/family/element/config/PropertyStructure';
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { LayoutDocument } from 'sk/data/family/structure/layout/LayoutDocument';
    export class LayoutPerformerUtil {
        static findTileBindingValue(bindingValues: Types<TileValueStructure>, tileId: string): TileValueStructure;
        static findBindingProperty(bindingProperties: Types<PropertyStructure>, tileId: string): TilePropertyStructure;
        static parametersLayoutTransmit(context: ElementPerformerContext, document: LayoutDocument, element: LayoutComponentElement | LayoutElement, node: DataNode): void;
        private static computeNewPositionSizeByClipboundary;
        private static getDefaultSizeByFamilyIdAsync;
        private static getDefaultSizeByMeshResourceIdAsync;
        static buildLayoutInfoAsync(context: ElementPerformerContext, element: LayoutComponentElement | LayoutElement, node: ContentNode): Promise<ResultObject>;
        static loadLayoutDocumentAsync(context: ElementPerformerContext, element: LayoutComponentElement | LayoutElement): Promise<ResultObject>;
    }
    export class LayoutInfo {
        type: string;
        referenceId: string;
        position: Vector3;
        size: Vector3;
        index: number;
        materialId: string;
        surface: Surface;
        tileClipOffsetX: number;
        tileClipOffsetY: number;
        referenceInfoId: string;
        tileLengthX: number;
        tileLengthY: number;
        tileLengthZ: number;
    }
}
declare module "sk/rule/data/base/element/brep/LayoutElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BooleanOperation } from 'foundation/runtime/math/Operator';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { LayoutNode } from 'sk/data/family/model/instance/LayoutNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeWorkflowOptions } from 'sk/data/scheme/service/SchemeDocumentService';
    type SurfaceBOPResult = {
        surfaces?: SectionSurface[];
        similarSurfaces?: SectionSurface[];
        diffSurfaces?: SectionSurface[];
    };
    export class LayoutElementUtil {
        static buildLayoutInfoAsync(context: ElementPerformerContext, element: LayoutElement, node: LayoutNode): Promise<ResultObject>;
        static computeWorkflowVison(element?: BrepElement, options?: SchemeWorkflowOptions): void;
        static computeTileSurfaceIntersectTargetSurface(tileSurface: SectionSurface[], layoutSurface: Surface, openingSurfaces: Surface[], op: BooleanOperation): SurfaceBOPResult;
        static computeTileSurfaceIntersectTargetSurface1(tileSurface: Surface, layoutSurface: Surface, openingSurfaces: Surface[], op: BooleanOperation): Surface;
        static createSectionSurfaceByPoints(points: any): SectionSurface;
        private static findLayoutOpeningSurface;
        static array2Polygon(polygon: Array<number>, offsetX?: number, offsetY?: number): Array<any>;
    }
}
declare module "sk/rule/data/layout/MaterialLayoutInfoComputeUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { MaterialLayoutElement } from 'sk/data/family/element/instance/layout/MaterialLayoutElement';
    import { DockEnum } from 'sk/data/family/enumeration/frame/DockEnum';
    import { MaterialLayoutArrangeTypeEnum } from 'sk/data/family/enumeration/MaterialLayoutArrangeTypeEnum';
    import { LayoutResultTile } from "sk/rule/data/layout/LayoutResultTile";
    export class MaterialLayoutInfoComputeUtil {
        static layoutTileCompute(tileGapX: number, tileGapY: number, layoutLengthX: number, layoutLengthY: number, beginPoint: Vector2, layoutBegin: Vector2, arrangeType: MaterialLayoutArrangeTypeEnum, tileLengthX: number, tileLengthY: number): LayoutResultTile;
        static layoutCompute(context: IContext, element: MaterialLayoutElement): Types<LayoutResultTile>;
        private static testIsFloorNode;
        private static computeRotateLayoutArrange;
        static computeBeginPoint(layoutBox: Box2, beginEnum: DockEnum, tileLengthX: number, tileLengthY: number, offset: Vector2, anchor: Vector2, isFloor: boolean): Vector2;
        private static buildMatrixByBeginPoint;
        static createSectionSurfaceByPoints(points: Vector2[]): SectionSurface;
    }
}
declare module "sk/rule/data/base/element/brep/MaterialLayoutElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BooleanOperation } from 'foundation/runtime/math/Operator';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { MaterialLayoutElement } from 'sk/data/family/element/instance/layout/MaterialLayoutElement';
    import { MaterialLayoutNode } from 'sk/data/family/model/instance/layout/MaterialLayoutNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    type SurfaceBOPResult = {
        surfaces?: SectionSurface[];
        similarSurfaces?: SectionSurface[];
        diffSurfaces?: SectionSurface[];
    };
    export class MaterialLayoutElementUtil {
        static buildLayoutInfoAsync(context: ElementPerformerContext, element: MaterialLayoutElement, node: MaterialLayoutNode): Promise<ResultObject>;
        static computeTileSurfaceIntersectTargetSurface(tileSurface: SectionSurface[], layoutSurface: Surface, openingSurfaces: Surface[], op: BooleanOperation): SurfaceBOPResult;
        static computeTileSurfaceIntersectTargetSurface1(tileSurface: Surface, layoutSurface: Surface, openingSurfaces: Surface[], op: BooleanOperation): Surface;
        static createSectionSurfaceByPoints(points: any): SectionSurface;
        private static findLayoutOpeningSurface;
        static getOpeningOfDecorateAreaPolygon(element: any, openingPoints: Array<any>): void;
    }
}
declare module "sk/rule/data/base/element/brep/PlaneHoleChamferPerformerUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { ComplexHoleSurface } from 'foundation/runtime/geometry/surface/ComplexHoleSurface';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { PathSolidMoldingOptions } from 'foundation/runtime/graphics/molding/path/PathSolidMoldingOptions';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { MoldingBrepOptions } from 'foundation/data/common/model/molding/MoldingBrepOptions';
    import { MoldingCollision3dOptions } from 'foundation/data/common/model/molding/MoldingCollision3dOptions';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    import { PlaneGraphic3dStructure } from 'sk/data/family/molding/instance/PlaneGraphic3dStructure';
    export class PlaneHoleChamferPerformerUtil {
        static isNeedDigAHole(node: PlaneNode, child: DataNode, options?: MoldingGeometricOptions | MoldingCollision3dOptions | MoldingBrepOptions, size?: number): boolean;
        static allHoleIntoOutline(s: ComplexHoleSurface): Array<Surface>;
        static compute_Old(node: PlaneNode, structure: PlaneGraphic3dStructure, options?: MoldingGeometricOptions): void;
        static line2d_NormalDistance(pt0: Vector2, pt1: Vector2): Vector3;
        static line2d_PerpendPt(line: Vector3, pt: Vector2): Vector2;
        static point2d_GivenLineDistanceAndY(line: Vector3, distance: number, y0: number): number;
        static champerCompute(section: PathCurve2d, yTop: number, yBottom: number, radius: number, tolerance?: number): {
            sectionMiddle: Curve2d;
            champerTop: Curve2d;
            champerBottom: Curve2d;
            tanPtTop: Vector2;
            tanPtBottom: Vector2;
        };
        static recutChamfers(oldChamperTops: Array<Curve2d>, oldChamperBottoms: Array<Curve2d>, oldMiddleSections: Array<Curve2d>): {
            champerTops: Array<Curve2d>;
            champerBottoms: Array<Curve2d>;
            middleSections: Array<Curve2d>;
        };
        static compute(node: PlaneNode, structure: PlaneGraphic3dStructure, options?: MoldingGeometricOptions): void;
        protected static pathSegment(path: PathCurve2d, seg: [number]): void;
        protected static computeSurfaceUV(surface: PlaneSurfaceNode): UVOptions;
        protected static computeSideSurfaceUV(surface: EdgeSurfaceNode): PathSolidMoldingOptions;
    }
}
declare module "sk/rule/data/base/element/brep/PlaneHoleUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    export class PlaneHoleUtil {
        static subtract(plane: BufferGeometry, hole: Array<Vector2>, uvoptions?: UVOptions): BufferGeometry;
        private static pointSplitBg;
        private static isPointOnPolygon;
        private static isPointOnSegment;
        private static interOfSegAndSeg;
        private static deleteSamePoints;
        private static getIndex;
        private static resetParseBg;
        private static createBg;
        private static polygonUV;
    }
}
declare module "sk/rule/data/base/element/brep/PlaneMillingUtil" {
    import { Curve2dStructure } from 'foundation/data/common/structure/geometric/Curve2dStructure';
    export class PlaneMillingUtil {
        static compute(milling: Array<Curve2dStructure>, plane: Array<Curve2dStructure>): Array<Curve2dStructure>;
        private static millingOnce;
        private static pointAndPolygon1;
        private static pointAndPolygon;
        private static isValidCurve;
        private static resetCurve;
        private static cloneCurve;
        private static interOfCurveAndCurve;
        private static interOfSegAndSeg;
        private static interOfSegAndArc;
        private static interOfArcAndArc;
        private static isPointOnCurve;
    }
}
declare module "sk/rule/data/base/element/brep/PlaneHolePerformerUtil" {
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { Curve2dStructure } from 'foundation/data/common/structure/geometric/Curve2dStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneGraphic3dStructure } from 'sk/data/family/molding/instance/PlaneGraphic3dStructure';
    export class PlaneHolePerformerUtil {
        static isNeedDigAHole(node: PlaneNode, child: DataNode, options?: MoldingGeometricOptions, size?: number): boolean;
        static compute(node: PlaneNode, structure: PlaneGraphic3dStructure, uvOption?: UVOptions, options?: MoldingGeometricOptions): void;
        static isHaveDigHole(node: PlaneNode, options?: MoldingGeometricOptions): boolean;
        static millingHole(node: PlaneNode, plane: Array<Curve2dStructure>, options?: MoldingGeometricOptions): Array<Curve2dStructure>;
        private static isPointOnPolygon;
        private static isPointOnSegment;
        private static interOfSegAndSeg;
        private static deleteSamePoints;
        private static getIndex;
        private static v3ToV2;
        private static cloneCurve;
    }
}
declare module "sk/rule/data/base/element/brep/PlanePerformerUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { EdgeSurfaceComponentElement } from 'sk/data/family/element/component/EdgeSurfaceComponentElement';
    import { PlaneComponentElement } from 'sk/data/family/element/component/PlaneComponentElement';
    import { PlaneSurfaceComponentElement } from 'sk/data/family/element/component/PlaneSurfaceComponentElement';
    import { EdgeSurfaceElement } from 'sk/data/family/element/instance/EdgeSurfaceElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class PlanePerformerUtil {
        static validateCheck(context: ElementPerformerContext, element: PlaneComponentElement | PlaneElement): boolean;
        static computeSurfaceRotation(context: ElementPerformerContext, element: PlaneElement, node: PlaneNode): void;
        static processPlaneSurfaceProperty(context: ElementPerformerContext, surfaceNode: PlaneSurfaceNode, surfaceElement: PlaneSurfaceComponentElement, edgeSurfaceElements: Types<EdgeSurfaceComponentElement>, plane: PlaneComponentElement | PlaneElement): void;
        static caculateSurfacePolygon(surfaceNode: PlaneSurfaceNode, offset: number): void;
        static caculatePlanSurfaceOffset(context: ElementPerformerContext, sectionSurface: any, directionCd: RelativeDirectionEnum): number;
        static processEdgePathCurveProperty(context: ElementPerformerContext, element: EdgeSurfaceComponentElement | EdgeSurfaceElement, node: EdgeSurfaceNode): void;
        static processEdgeSectionCurveProperty(context: ElementPerformerContext, element: EdgeSurfaceComponentElement | EdgeSurfaceElement, node: EdgeSurfaceNode): void;
        static reComputeCompare(node: PlaneNode): boolean;
        static processEdgeProperty(context: ElementPerformerContext, element: EdgeSurfaceComponentElement | EdgeSurfaceElement, node: EdgeSurfaceNode): EdgeSurfaceNode;
        static arrangeEdgeSurfaces(edgeSurfaceElements: Types<EdgeSurfaceComponentElement>): Types<EdgeSurfaceComponentElement>;
        static copyEdgeChildren(context: ElementPerformerContext, element: PlaneElement, caches: Types<EdgeSurfaceElement>): void;
        static copyEdgeNodeChildren(context: ElementPerformerContext, node: PlaneNode, caches: Array<EdgeSurfaceNode>): void;
        static copyProperties(node: PlaneNode): void;
        static cacheNodeEdges(context: ElementPerformerContext, plane: PlaneNode, dispose?: boolean): Array<EdgeSurfaceNode>;
        static cacheElementsEdges(context: ElementPerformerContext, plane: PlaneElement, dispose?: boolean): Array<EdgeSurfaceElement>;
        static addCacheNodeEdges(edges: Array<EdgeSurfaceNode>, plane: PlaneNode): void;
        static addCacheElementEdges(context: ElementPerformerContext, plane: PlaneElement, edges: Array<EdgeSurfaceElement>): void;
        static disposeCacheNodeEdges(edges: Array<EdgeSurfaceNode>): void;
        static disposeCacheElementEdges(context: ElementPerformerContext, edges: Array<EdgeSurfaceElement>): void;
        static removePropertyNodeEdges(context: ElementPerformerContext, plane: PlaneNode, isDeletePoints?: boolean): void;
        static removePropertyElementEdges(context: ElementPerformerContext, planeElement: PlaneElement, isDeletePoints?: boolean): void;
        static computeBoundaryEdge(node: PlaneNode): void;
        static clearEdgesOnPlane(context: ElementPerformerContext, element: PlaneComponentElement | PlaneElement, node: PlaneNode): ResultEnum;
        static computeProfileProperty(context: ElementPerformerContext, element: PlaneComponentElement | PlaneElement, node: PlaneNode): ResultEnum;
        static computeProfilePropertyByNode(context: ElementPerformerContext, planeNode: PlaneNode): ResultEnum;
        static processEdgePropertyByNode(context: ElementPerformerContext, edgeNode: EdgeSurfaceNode, planeNode: PlaneNode): EdgeSurfaceNode;
        static buildPlanePolygonEdges(context: ElementPerformerContext, planeNode: PlaneNode): ResultObject;
        static computePlaneBoundaryEdges(context: ElementPerformerContext, planeNode: PlaneNode): ResultObject;
        static computePlanePolygonEdges(context: ElementPerformerContext, planeNode: PlaneNode): ResultObject;
        private static copyBindingPropety;
        private static copyBindingValue;
        static resetEdgeCurves(context: ElementPerformerContext, planeNode: PlaneNode): ResultObject;
        static computePointIdentify(planeNode: PlaneNode): ResultObject;
        static reComputePointPosition(planeNode: PlaneNode): ResultObject;
    }
}
declare module "sk/rule/data/base/element/brep/PlaneMillingPerformerUtil3" {
    import { Curve2dStructure } from 'foundation/data/common/structure/geometric/Curve2dStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class PlaneMillingPerformerUtil3 {
        static isNeedMillingMolding(node: PlaneNode): boolean;
        static compute2(context: ElementPerformerContext, node: PlaneNode): void;
        static compute(context: ElementPerformerContext, node: PlaneNode): void;
        private static resetPlane;
        private static copyEdgeProperty;
        private static getEdgeCurve;
        static isValidCurve(curve: Curve2dStructure): boolean;
        private static cloneCurve;
        private static isSameCurve;
        private static isValidPath;
    }
}
declare module "sk/rule/data/base/node/performer/ContentNodePerformerUtil" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    import { DrawingLinkNode } from 'sk/data/scheme/model/drawing/DrawingLinkNode';
    export interface INodeMatrixContext {
        processPlaceCd: boolean;
    }
    export class ContentNodePerformerUtil {
        static computePivotMatrix(node: ContentNode): Matrix4;
        static computeMatrixByPlaceCd(matrix: Matrix4, placeCd: ContentPlaceTypeEnum): void;
        static computeLocalMatrix(node: ContentNode): Matrix4;
        static computeDrawingLinkNode(node: DrawingLinkNode): void;
        static computeDrawingLinkNodeRecursion(rootLinkNode: DrawingLinkNode, node: DrawingLinkNode): void;
        static computeRelatedDrawingLinkNode(node: DrawingLinkNode, child: DrawingLinkNode): void;
        static computeMatrix2Matrix(matrix1: Matrix4, matrix2: Matrix4): Matrix3d;
        static computeMatrixAndPosition(node: ContentNode): void;
        static computeNodeMatrix(context: INodeMatrixContext, node: ContentNode, force?: boolean): void;
    }
}
declare module "sk/rule/data/base/node/performer/ContentInstanceNodePerformerUtil" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { PointBox3 } from 'foundation/data/common/model/spatial/PointBox3';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    export class ContentInstanceNodePerformerUtil {
        protected static INNER_MATRIX: Matrix4;
        protected static INNER_BOX: PointBox3;
        protected static OUTER_BOX: Box3;
        static computePivotMatrix(node: ContentInstanceNode): Matrix4;
    }
}
declare module "sk/rule/data/base/node/performer/ContentNodePerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { NodePerformer } from 'sk/data/family/performer/node/NodePerformer';
    import { NodePerformerContext } from 'sk/data/family/performer/node/NodePerformerContext';
    export class ContentNodePerformer extends NodePerformer {
        constructor();
        computeLocalMatrix(context: NodePerformerContext, node: ContentNode): void;
        computeShapeMatrix(context: NodePerformerContext, node: ContentNode): ResultEnum;
        computeShapeMolding(context: NodePerformerContext, node: ContentNode): ResultEnum;
        computeShapeBoundary(context: NodePerformerContext, node: ContentNode): ResultEnum;
        computeShape(context: NodePerformerContext, node: ContentNode): ResultEnum;
        protected computeOctreeNode(node: ContentNode): void;
    }
}
declare module "sk/rule/data/base/node/performer/SpatialNodePerformerUtil" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    export class SpatialNodePerformerUtil {
        static computeLocalMatrix(node: SpatialNode): Matrix3d;
    }
}
declare module "sk/rule/data/base/node/performer/VertexNodePerformerUtil" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    export class VertexNodePerformerUtil {
        static computeLocalMatrix(node: VertexNode): Matrix3d;
        static computeNodeMatrix(node: VertexNode): void;
    }
}
declare module "sk/rule/data/base/ProfileRectUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { LineAndType } from 'sk/data/family/util/PolygonRectangleSplitUtil';
    import { BathroomFloorDryPlankElement } from 'sk/data/scheme/database/assemble/element/BathroomFloorDryPlankElement';
    import { BathroomFloorDryPlankNode } from 'sk/data/scheme/database/assemble/node/BathroomFloorDryPlankNode';
    export class ProfileRectUtil {
        protected static _profileDocumentService: ProfileDocumentService;
        static rectProfileCalculateAsync(option: any, data: Array<Vector2>, data2: Array<Array<Vector2>>, data3: Array<Array<Vector2>>, element: BathroomFloorDryPlankElement, node: BathroomFloorDryPlankNode): Promise<ResultObject>;
        static judgeLineType(arrayLine: LineAndType[]): void;
    }
}
declare module "sk/rule/data/base/rule/SchemeRuleProcessContext" {
    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 { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    export class SchemeRuleProcessContext extends RuleProcessContext {
        performerContext: SchemeElementPerformerContext;
        createElementByFamilyIdAsync(parentElement: NestElement, familyId: string): Promise<ResultObject<Element>>;
        createElementBySymbolIdAsync(parentElement: NestElement, familyId: string, familySymbolId: string): Promise<ResultObject<Element>>;
        createElementByInfoIdAsync(parentElement: NestElement, familyInfoId: string): Promise<ResultObject<Element>>;
        free(): void;
    }
}
declare module "sk/rule/data/base/rule/SchemeGlobalRuleProcessOutput" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { GlobalRuleProcessOutput } from 'sk/data/family/rule/process/GlobalRuleProcessOutput';
    import { SchemeRuleProcessContext } from "sk/rule/data/base/rule/SchemeRuleProcessContext";
    export class SchemeGlobalRuleProcessOutput extends GlobalRuleProcessOutput {
        context: SchemeRuleProcessContext;
        element: NestElement;
        node: DataNode;
        addChild(element: Element, parentElement?: NestElement): void;
        addChildAsync(element: Element, parentElement?: NestElement): Promise<ResultObject>;
        addChildNodeAsync(node: ContentNode, parentNode: ContentNode): Promise<ResultObject>;
        private computeDataNode;
        dispose(): void;
    }
}
declare module "sk/rule/data/base/rule/SchemeRuleProcessInput" {
    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 { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    export class SchemeRuleProcessInput extends RuleProcessInput {
        infoContent: ISpecificationFamilyInfo;
        instanceNode: ContentInstanceNode | DataNode;
        dispose(): void;
    }
}
declare module "sk/rule/data/base/rule/SchemeMaterialRuleProcessInput" {
    import { MaterialRuleFunctionTypeEnum } from 'sk/data/family/enumeration/MaterialRuleFunctionTypeEnum';
    import { BomMaterialNode } from 'sk/data/scheme/model/bom/BomMaterialNode';
    import { SchemeRuleProcessInput } from "sk/rule/data/base/rule/SchemeRuleProcessInput";
    export class SchemeMaterialRuleProcessInput extends SchemeRuleProcessInput {
        businessTypeId: string;
        materialNode: BomMaterialNode;
        ruleFunctionType: MaterialRuleFunctionTypeEnum;
        meteringTypeCode?: string;
        meteringTypeName?: string;
    }
}
declare module "sk/rule/data/base/rule/SchemeRuleProcessOutput" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { SchemeRuleProcessContext } from "sk/rule/data/base/rule/SchemeRuleProcessContext";
    export class SchemeRuleProcessOutput extends RuleProcessOutput {
        context: SchemeRuleProcessContext;
        element: NestElement;
        node: DataNode;
        addChild(element: Element, parentElement?: NestElement): void;
        addChildAsync(element: Element, parentElement?: NestElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/base/variable/ElementPerformerVariable" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { IVariableProvider } from 'foundation/data/common/core/IVariableProvider';
    import { VariableObject } from 'sk/data/family/element/config/variable/VariableObject';
    export class ElementPerformerVariable extends VariableObject {
        protected _calculatorService: CalculatorService;
        methodName: string;
        constructor(code: string, methodName: string);
        resolve(valueProvider?: IValueProvider, variableProvider?: IVariableProvider): number;
    }
}
declare module "sk/rule/data/base/variable/ElementContentLengthVariable" {
    import { ElementPerformerVariable } from "sk/rule/data/base/variable/ElementPerformerVariable";
    export class ElementContentLengthVariable extends ElementPerformerVariable {
    }
}
declare module "sk/rule/data/bom/BomConvertService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    export type BomConvertInfo = {
        logicCode: string;
        type: any;
        instance: any;
    };
    export class BomConvertService extends Service {
        protected _declares: Dictionary<BomConvertInfo>;
        get declares(): Dictionary<BomConvertInfo>;
        registeDeclare(declare: BomConvertInfo): void;
        getDeclare(name: string): BomConvertInfo;
        convertAsync(name: string): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/bom/BomConvertDeclare" {
    export function BomConvertDeclare(logicCode: string): (target: any) => void;
}
declare module "sk/rule/data/bom/structure/BomStructureContext" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class BomStructureContext extends InstanceObject {
    }
}
declare module "sk/rule/data/bom/structure/BomStructureConverter" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { MaterialConfigService } from 'foundation/data/common/config/MaterialConfigService';
    import { BomStructureContext } from "sk/rule/data/bom/structure/BomStructureContext";
    export class BomStructureConverter extends InstanceObject {
        protected _materialConfigService: MaterialConfigService;
        convertAsync(context: BomStructureContext, node: DataNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/bom/structure/BomStructureNode" {
    import { Node } from 'cross/runtime/framework/node/Node';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class BomStructureNode extends Node {
        linkNode: DataNode;
    }
}
declare module "sk/rule/data/calculate/base/LogicContext" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class LogicContext extends InstanceObject {
    }
}
declare module "sk/rule/data/calculate/base/LogicInput" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class LogicInput extends InstanceObject {
    }
}
declare module "sk/rule/data/calculate/base/LogicOutput" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class LogicOutput extends InstanceObject {
    }
}
declare module "sk/rule/data/calculate/base/LogicCalculator" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LogicContext } from "sk/rule/data/calculate/base/LogicContext";
    import { LogicInput } from "sk/rule/data/calculate/base/LogicInput";
    import { LogicOutput } from "sk/rule/data/calculate/base/LogicOutput";
    export class LogicCalculator extends InstanceObject {
        processAsync(context: LogicContext, input: LogicInput, output: LogicOutput): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/calculate/data/LogicPoint" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class LogicPoint extends InstanceObject {
        protected _position: Vector2;
        constructor();
        position(): Vector2;
        dispose(): void;
    }
}
declare module "sk/rule/data/calculate/data/LogicPolygon" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { LogicPoint } from "sk/rule/data/calculate/data/LogicPoint";
    export class LogicPolygon extends InstanceObject {
        protected _points: Types<LogicPoint>;
        constructor();
        points(): Types<LogicPoint>;
        dispose(): void;
    }
}
declare module "sk/rule/data/calculate/data/LogicArea" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { LogicPolygon } from "sk/rule/data/calculate/data/LogicPolygon";
    export class LogicArea extends InstanceObject {
        protected _outline: LogicPolygon;
        protected _holes: Types<LogicPolygon>;
        constructor();
        outline(): LogicPolygon;
        holes(): Types<LogicPolygon>;
        dispose(): void;
    }
}
declare module "sk/rule/data/calculate/calculate/util/NumberSplitArranger" {
    type NumberArrangerOption = {
        begin: number;
        end: number;
        start?: number;
        avoidanceNumbers?: number[];
        avoidanceLength?: number;
        sections?: {
            begin: number;
            end: number;
        }[];
        maxAcrossLength?: number;
        sectionsSideAvoidanceLength?: number;
        splitLength: number;
        minSplitLength: number;
        tryGap: number | number[];
    };
    export class NumberSplitArranger {
        option: NumberArrangerOption;
        tryValue: number;
        current: number;
        remain: number;
        values: number[];
        isReverse: boolean;
        tryListMode: boolean;
        tryListIndex: number[];
        constructor(option: NumberArrangerOption);
        process(): {
            begin: number;
            length: number;
        }[];
        arrange(): boolean;
        changeSplitValue(): boolean;
        pop(): void;
        checkValid(): boolean;
        isBetweenValues(value: any, value1: any, value2: any, onSide?: boolean): boolean;
        addValue(): boolean;
    }
}
declare module "sk/rule/data/calculate/calculate/LogicPolygonSplitterInput" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { LogicInput } from "sk/rule/data/calculate/base/LogicInput";
    import { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    import { LogicPoint } from "sk/rule/data/calculate/data/LogicPoint";
    export type LogicPolygonSplitterInputOption = {
        width: number;
        minWidth: number;
        height: number;
        minHieght: number;
        verticalOffset: number;
        acrossHole?: boolean;
        reflines?: Line2[];
        avoidanceLength?: number;
        verticalSpaces?: Array<number>;
        horizontalSpaces?: Array<number>;
    };
    export class LogicPolygonSplitterInput extends LogicInput {
        area: LogicArea;
        origin: LogicPoint;
        direction: LogicPoint;
        options: LogicPolygonSplitterInputOption;
        constructor(option: LogicPolygonSplitterInputOption);
    }
}
declare module "sk/rule/data/calculate/calculate/LogicPolygonSplitterOutput" {
    import { LogicOutput } from "sk/rule/data/calculate/base/LogicOutput";
    import { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    export class LogicPolygonSplitterOutput extends LogicOutput {
        polygons: LogicArea[];
    }
}
declare module "sk/rule/data/calculate/calculate/LogicPolygonSplitterCalculator" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LogicCalculator } from "sk/rule/data/calculate/base/LogicCalculator";
    import { LogicContext } from "sk/rule/data/calculate/base/LogicContext";
    import { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    import { LogicPolygonSplitterInput, LogicPolygonSplitterInputOption } from "sk/rule/data/calculate/calculate/LogicPolygonSplitterInput";
    import { LogicPolygonSplitterOutput } from "sk/rule/data/calculate/calculate/LogicPolygonSplitterOutput";
    type Row = {
        y: number;
        height: number;
    };
    type Column = {
        x: number;
        y: number;
        height: number;
        width: number;
        rows: Row[];
        offset: number;
    };
    export class LogicPolygonSplitterCalculator extends LogicCalculator {
        processAsync(context: LogicContext, input: LogicPolygonSplitterInput, output: LogicPolygonSplitterOutput): Promise<ResultObject>;
        splitAreaToRects(area: {
            outline: Vector2[];
            holes: Vector2[][];
        }, reflines: Line2[], options: LogicPolygonSplitterInputOption): Vector2[][];
        columnsToMath(columns: Column[]): Vector2[][];
        reConvertAreas(origin: Value2, direction: Value2, surfaces: Vector2[][][]): Types<LogicArea>;
        cut(area: {
            outline: Vector2[];
            holes: Vector2[][];
        }, polygons: Vector2[][], scale?: number): Vector2[][][];
        cutRows(originY: number, columns: Column[], holes: Vector2[][], reflines: Line2[], options: LogicPolygonSplitterInputOption, isLeft?: boolean): void;
        getVerticalOffset(column: Column, lastColumn: Column, options: LogicPolygonSplitterInputOption, reflines: Line2[], originY: number): number;
        nearReflines(value: number, reflines: Line2[], avoidanceLength: number, type: "x" | "y"): boolean;
        getReflinesByColum(column: Column): Line2[];
        getColumns(originX: number, box: Box2, holes: Vector2[][], reflines: Line2[], options: LogicPolygonSplitterInputOption, isLeft?: boolean): Column[];
        getHorizontalReflines(lines: Line2[]): Line2[];
        getVerticalReflines(lines: Line2[]): Line2[];
        getConvertedLines(origin: Value2, direction: Value2, lines: Line2[]): Line2[];
        getConvertedArea(origin: Value2, direction: Value2, area: LogicArea): {
            outline: Vector2[];
            holes: Vector2[][];
        };
        translate(x: number, y: number, polygon: Value2[]): void;
        rotate(radian: number, polygon: Value2[]): void;
    }
}
declare module "sk/rule/data/calculate/data/LogicDataUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { LogicPolygon } from "sk/rule/data/calculate/data/LogicPolygon";
    export class LogicDataUtil {
        static logicPolygonToMath(logicPolygon: LogicPolygon): Value2[];
        static logicPolygonsToMath(logicPolygons: Types<LogicPolygon>): Value2[][];
        static mathToLogicPolygon(polygonPoints: Value2[], logicPolygon?: LogicPolygon): LogicPolygon;
    }
}
declare module "sk/rule/data/calculate/calculate/util/PointArranger" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { EllipseCurve2d } from 'foundation/runtime/geometry/curve2d/EllipseCurve2d';
    export type PointArrangerOption = {
        polygon: Value2[];
        holes: Value2[][];
        horizontalGap: number;
        verticalGap: number;
        minGap: number;
    };
    export type PointInfo = {
        x: number;
        y: number;
        type: PointPositionEnum;
    };
    export class PointPositionEnum {
        static content: number;
        static side: number;
        static point: number;
    }
    export class PointArranger {
        option: PointArrangerOption;
        points: PointInfo[];
        gapEllipse: EllipseCurve2d;
        constructor(option: PointArrangerOption);
        process(): PointInfo[];
        addPointsByContent(): void;
        isTooClose(point: Value2, types: PointPositionEnum[]): boolean;
        isPointOnSurface(point: Value2): boolean;
        getInnerValueList(length: number, gap: number, minGap: number): number[];
        addPointsBySide(begin: Value2, end: Value2): void;
        addPointsByPolygon(polygon: Value2[]): void;
        addPointsByPolyons(): void;
        getGapBySide(begin: Value2, end: Value2): number;
        computeGap(): void;
        addPointsByPoints(): void;
        addPointsByPolygonPoints(polygon: Value2[]): void;
    }
}
declare module "sk/rule/data/calculate/calculate/util/PointExtrusionArranger" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PointInfo } from "sk/rule/data/calculate/calculate/util/PointArranger";
    export type PointExtrusionArrangerOption = {
        polygons: Value2[][];
        holes: Value2[][];
        points: Value2[];
        minGap: number;
        padding: number;
        inLineRange?: number;
        verticalExtrusion?: boolean;
    };
    type PointExtrusionArrangerPoint = {
        x: number;
        y: number;
        priority: 3 | 2 | 1;
        momentum: Vector2;
        status: "moved" | "moving" | "static";
        nextMove: boolean;
        valid: boolean;
        isOnOutline: boolean;
    };
    export class PointExtrusionArranger {
        option: PointExtrusionArrangerOption;
        outlines: Vector2[][];
        points: PointExtrusionArrangerPoint[];
        movePoints: PointExtrusionArrangerPoint[];
        constructor(option: PointExtrusionArrangerOption);
        process(): PointInfo[];
        initPoints(): void;
        arrange(): void;
        movePoint(point: PointExtrusionArrangerPoint): void;
        checkValidPoint(point: PointExtrusionArrangerPoint): void;
        getAvoidMomentumByPoints(point: PointExtrusionArrangerPoint, movePoint: PointExtrusionArrangerPoint): Vector2;
        initPoint(point: Value2): PointExtrusionArrangerPoint;
        isOnOutline(point: Value2): boolean;
        filterLines(lines: Line2[]): void;
        initOutlines(): void;
        addConnectLine(point: Value2, polygon: Value2[], lines: Line2[]): void;
        static isPointInLine(point: Value2, line: {
            from: Value2;
            to: Value2;
        }, inLineRange?: number): boolean;
    }
}
declare module "sk/rule/data/calculate/calculate/LogicSupportPointInput" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { LogicInput } from "sk/rule/data/calculate/base/LogicInput";
    import { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    export class LogicSupportPointInput extends LogicInput {
        planks: Types<LogicArea>;
        holes: Value2[][];
        horizontalGap: number;
        verticalGap: number;
        minGap: number;
        padding: number;
    }
}
declare module "sk/rule/data/calculate/calculate/LogicSupportPointCalculator" {
    import { LogicCalculator } from "sk/rule/data/calculate/base/LogicCalculator";
    import { LogicContext } from "sk/rule/data/calculate/base/LogicContext";
    import { PointInfo } from "sk/rule/data/calculate/calculate/util/PointArranger";
    import { LogicSupportPointInput } from "sk/rule/data/calculate/calculate/LogicSupportPointInput";
    export class LogicSupportPointCalculator extends LogicCalculator {
        process(context: LogicContext, input: LogicSupportPointInput): PointInfo[];
        private isLevellerCover;
        private removeConflictPoint;
    }
}
declare module "sk/rule/data/calculate/calculate/LogicSupportPointOutput" {
    import { LogicOutput } from "sk/rule/data/calculate/base/LogicOutput";
    export class LogicSupportPointOutput extends LogicOutput {
        x: number;
        y: number;
    }
}
declare module "sk/rule/data/calculate/calculate/util/PointAlignArrange" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { PointInfo } from "sk/rule/data/calculate/calculate/util/PointArranger";
    type MoveRange = {
        min: number;
        max: number;
        points: PointInfo[];
    };
    type PositionType = 'x' | 'y';
    export type PointAlignArrangeOption = {
        polygon: Value2[];
        holes: Value2[][];
        points: Value2[];
        pointInfos?: PointInfo[];
        maxHorizontalGap: number;
        maxVerticalGap: number;
        alignRange: number;
        minGap: number;
        padding: number;
        alignX?: boolean;
        alignY?: boolean;
    };
    export class PointAlignArrange {
        option: PointAlignArrangeOption;
        pointInfos: PointInfo[];
        groupsMap: {
            [key: string]: PointInfo[][];
        };
        constructor(option: PointAlignArrangeOption);
        process(): PointInfo[];
        initPointInfos(): void;
        alignPoint(type: PositionType): void;
        movePointsByRange(range: MoveRange, type: PositionType): void;
        getOverlapRanges(ranges: MoveRange[]): MoveRange[];
        getMoveRange(point: PointInfo, type: PositionType): MoveRange;
        getPointMoveRangeByLine(point: PointInfo, line: Line2, type: PositionType): {
            min: number;
            max: number;
        };
        splitGroup(type: PositionType): PointInfo[][];
        sortPointFun: (type: PositionType) => (point1: PointInfo, point2: PointInfo) => number;
        sortNumberFun(v1: number, v2: number): number;
    }
}
declare module "sk/rule/data/compute/ProfileElementInstancePlain" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementAsyncTraversal, IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { ProfileDocument } from 'sk/data/family/structure/profile/ProfileDocument';
    export class ProfileElementInstancePlain extends WorkflowPlainAsyncProcess implements IElementTraversal, IElementAsyncTraversal {
        document: ProfileDocument;
        protected _calculatorService: CalculatorService;
        createContext(context?: ContextObject): ElementPerformerContext;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
        processElementAsync(context: ElementPerformerContext, element: Element, isBefore: boolean): Promise<ResultEnum>;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/compute/ProfileElementPropertyPlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { ProfileDocument } from 'sk/data/family/structure/profile/ProfileDocument';
    export class ProfileElementPropertyPlain extends WorkflowPlainProcess implements IElementTraversal {
        document: ProfileDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/compute/ProfileElementShapePlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { ProfileDocument } from 'sk/data/family/structure/profile/ProfileDocument';
    export class ProfileElementShapePlain extends WorkflowPlainProcess implements IElementTraversal {
        document: ProfileDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/config/decorate/FurnitureDecorate" {
    import { VariableObject } from 'sk/data/family/element/config/variable/VariableObject';
    export class FurnitureDecorate extends VariableObject {
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    export class DrawerDoorVariable extends BrepBindingVariable {
        getAssemblyPlaneValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorCodeVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorCodeVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorCoverBootomVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorCoverBootomVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorCoverLeftVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorCoverLeftVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorCoverRightVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorCoverRightVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorCoverTopVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorCoverTopVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorDriftBottomVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorDriftBottomVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorDriftLeftVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorDriftLeftVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorDriftRightVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorDriftRightVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorDriftTopVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorDriftTopVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorMaterialCodeVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorMaterialCodeVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorNameVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorNameVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorPositionVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorPositionVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorSeamReduceBottomVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorSeamReduceBottomVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorSeamReduceLeftVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorSeamReduceLeftVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorSeamReduceRightVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorSeamReduceRightVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorSeamReduceTopVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorSeamReduceTopVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorTextureCodeVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorTextureCodeVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorThicknessBottomVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorThicknessBottomVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorThicknessLeftVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorThicknessLeftVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorThicknessRightVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorThicknessRightVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorThicknessTopVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorThicknessTopVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/drawer/DrawerDoorThicknessVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { DrawerDoorVariable } from "sk/rule/data/config/variable/drawer/DrawerDoorVariable";
    export class DrawerDoorThicknessVariable extends DrawerDoorVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurnitureDoorOpenDirectionVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { IVariableProvider } from 'foundation/data/common/core/IVariableProvider';
    import { VariableObject } from 'sk/data/family/element/config/variable/VariableObject';
    export class FurnitureDoorOpenDirectionVariable extends VariableObject {
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: IVariableProvider, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: IVariableProvider, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurnitureDoorThicknessVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    export class FurnitureDoorThicknessVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: any, parametersStr?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurnitureHandlePositionVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    export class FurnitureHandlePositionVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: any, parametersStr?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurnitureHandleRotationZVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    export class FurnitureHandleRotationZVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: any, parametersStr?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurniturePlankSeamReduceBottomVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    export class FurniturePlankSeamReduceTopVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: BrepElement, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurniturePlankSeamReduceLeftVariable " {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    export class FurniturePlankSeamReduceTopVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: BrepElement, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurniturePlankSeamReduceRightVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    export class FurniturePlankSeamReduceTopVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: BrepElement, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/FurniturePlankSeamReduceTopVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    export class FurniturePlankSeamReduceTopVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: BrepElement, parameters?: any): any;
    }
}
declare module "sk/rule/data/config/variable/MaterialRotationVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    export class MaterialRotationVariable extends BrepBindingVariable {
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: any, parametersStr?: any): any;
    }
}
declare module "sk/rule/data/config/variable/MaterialThicknessVariable" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { IValueProvider } from 'foundation/data/common/core/IValueProvider';
    import { BrepBindingVariable } from 'sk/data/family/element/brep/BrepBindingVariable';
    import { DecorateCacheService } from 'sk/data/family/service/DecorateCacheService';
    export class MaterialThicknessVariable extends BrepBindingVariable {
        protected _decorateCacheService: DecorateCacheService;
        constructor(code?: string, id?: string, name?: string);
        getValue(context: IContext, valueProvider?: IValueProvider, variableProvider?: any, parameters?: any): any;
        setValue(context: IContext, value: any, valueProvider?: IValueProvider, variableProvider?: any, parametersStr?: any): any;
    }
}
declare module "sk/rule/data/scehme/util/SchemeRuleDataPerformerUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { UniqueTypes } from 'cross/runtime/lang/collection/UniqueTypes';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Element } from 'sk/data/family/element/base/Element';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { DataPerformerContext } from 'sk/data/family/performer/DataPerformerContext';
    export class SchemeRuleDataPerformerUtil {
        static copyVariableElementPropertyToBindingValue(context: DataPerformerContext, containerElement: BrepElement, referenceElement: BrepElement): void;
        static copyElementPropertyToBindingValueAsync(context: DataPerformerContext, containerElement: BrepElement, referenceElement: BrepElement): Promise<void>;
        static copyPropertyToBindingValueAsync(context: DataPerformerContext, containerElement: BrepElement, rootElement?: BrepElement): Promise<ResultObject>;
        static overrideBindingValueByBindingProperty(sourceElement: BrepElement, targetElement: BrepElement): void;
        static syncChildrenBindingDefaultValue(element: BrepElement, children: Types<Element> | UniqueTypes<Element>): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/DeclareNestElementPerformer" {
    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 { DeclareCache } from 'sk/data/scheme/performer/element/DeclareCache';
    import { DeclareElementPerformer } from 'sk/data/scheme/performer/element/DeclareElementPerformer';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    export class DeclareNestElementPerformer extends DeclareElementPerformer {
        optionCache: boolean;
        constructor();
        buildChildStructureAsync(context: DeclarePerformerContext, source: NestElement, target: NestElement): Promise<ElementPerformerResult>;
        lockElement(context: DeclarePerformerContext, cache: DeclareCache, source: NestElement, target: NestElement): void;
        unlockElement(context: DeclarePerformerContext, cache: DeclareCache, source: NestElement, target: NestElement): void;
        buildChildElementAsync(context: DeclarePerformerContext, source: NestElement, target: NestElement): Promise<ElementPerformerResult>;
        buildStructureAsync(context: DeclarePerformerContext, source: Element, target: Element): Promise<ElementPerformerResult>;
        buildStructureReleation(context: DeclarePerformerContext, element: NestElement, recursive?: boolean): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/DeclareInstanceElementPerformer" {
    import { DeclareNestElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareNestElementPerformer";
    export class DeclareInstanceElementPerformer extends DeclareNestElementPerformer {
    }
}
declare module "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareInstanceElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareInstanceElementPerformer";
    export class DeclareBrepElementPerformer extends DeclareInstanceElementPerformer {
        computeProperty(context: DeclarePerformerContext, source: BrepElement, target: BrepElement): void;
        computePropertyAsync(context: DeclarePerformerContext, source: BrepElement, target: BrepElement): Promise<ResultObject>;
        buildStructureAfter(context: DeclarePerformerContext, source: BrepElement, target: BrepElement): void;
    }
}
declare module "sk/rule/data/declare/performer/assistant/DeclareAssistantElementPerformer" {
    import { AssistantElement } from 'sk/data/family/element/assistant/AssistantElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareAssistantElementPerformer extends DeclareBrepElementPerformer {
        computeProperty(context: DeclarePerformerContext, source: AssistantElement, target: AssistantElement): void;
    }
}
declare module "sk/rule/data/declare/performer/assistant/DeclareAnchorElementPerformer" {
    import { AnchorElement } from 'sk/data/family/element/assistant/AnchorElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareAssistantElementPerformer } from "sk/rule/data/declare/performer/assistant/DeclareAssistantElementPerformer";
    export class DeclareAnchorElementPerformer extends DeclareAssistantElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: AnchorElement, parameters?: any): AnchorElement;
        computeProperty(context: DeclarePerformerContext, source: AnchorElement, target: AnchorElement): void;
    }
}
declare module "sk/rule/data/declare/performer/assistant/reference/DeclareReferenceAxisElementPerformer" {
    import { ReferenceAxisElement } from 'sk/data/family/element/assistant/reference/ReferenceAxisElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareAssistantElementPerformer } from "sk/rule/data/declare/performer/assistant/DeclareAssistantElementPerformer";
    export class DeclareReferenceAxisElementPerformer extends DeclareAssistantElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ReferenceAxisElement, parameters?: any): ReferenceAxisElement;
        computeProperty(context: DeclarePerformerContext, source: ReferenceAxisElement, target: ReferenceAxisElement): void;
    }
}
declare module "sk/rule/data/declare/performer/assistant/reference/DeclareReferenceLineElementPerformer" {
    import { ReferenceLineElement } from 'sk/data/family/element/assistant/reference/ReferenceLineElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareAssistantElementPerformer } from "sk/rule/data/declare/performer/assistant/DeclareAssistantElementPerformer";
    export class DeclareReferenceLineElementPerformer extends DeclareAssistantElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ReferenceLineElement, parameters?: any): ReferenceLineElement;
        computeProperty(context: DeclarePerformerContext, source: ReferenceLineElement, target: ReferenceLineElement): void;
    }
}
declare module "sk/rule/data/declare/performer/assistant/reference/DeclareReferencePlaneElementPerformer" {
    import { ReferencePlaneElement } from 'sk/data/family/element/assistant/reference/ReferencePlaneElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareAssistantElementPerformer } from "sk/rule/data/declare/performer/assistant/DeclareAssistantElementPerformer";
    export class DeclareReferencePlaneElementPerformer extends DeclareAssistantElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ReferencePlaneElement, parameters?: any): ReferencePlaneElement;
        computeProperty(context: DeclarePerformerContext, source: ReferencePlaneElement, target: ReferencePlaneElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/DeclareVertexElementPerformer" {
    import { VertexElement } from 'sk/data/family/element/brep/VertexElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareVertexElementPerformer extends DeclareBrepElementPerformer {
        computeProperty(context: DeclarePerformerContext, source: VertexElement, target: VertexElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/DeclareSpatialElementPerformer" {
    import { SpatialElement } from 'sk/data/family/element/brep/SpatialElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareVertexElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareVertexElementPerformer";
    export class DeclareSpatialElementPerformer extends DeclareVertexElementPerformer {
        computeProperty(context: DeclarePerformerContext, source: SpatialElement, target: SpatialElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareSpatialElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareSpatialElementPerformer";
    export class DeclareContentElementPerformer extends DeclareSpatialElementPerformer {
        computeProperty(context: DeclarePerformerContext, source: ContentElement, target: ContentElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareBoxSolidElementPerformer" {
    import { BoxSolidElement } from 'sk/data/family/element/brep/geometric/solid/BoxSolidElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareSpatialElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareSpatialElementPerformer";
    export class DeclareBoxSolidElementPerformer extends DeclareSpatialElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: BoxSolidElement, parameters?: any): Element;
        buildStructureAfter(context: DeclarePerformerContext, source: BoxSolidElement, target: BoxSolidElement): void;
        checkValid(context: DeclarePerformerContext, target: BoxSolidElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareCurveElementPerformer" {
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareCurveElementPerformer extends DeclareBrepElementPerformer {
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer" {
    import { DeclareCurveElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurveElementPerformer";
    export class DeclareCurve2dElementPerformer extends DeclareCurveElementPerformer {
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareCircleArc2Curve2dElementPerformer" {
    import { CircleArc2Curve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArc2Curve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareCircleArc2Curve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: CircleArc2Curve2dElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: CircleArc2Curve2dElement, target: CircleArc2Curve2dElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: CircleArc2Curve2dElement, target: CircleArc2Curve2dElement): void;
        checkValid(context: DeclarePerformerContext, target: CircleArc2Curve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareCircleArc2Curve3dElementPerformer" {
    import { CircleArc2Curve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/CircleArc2Curve3dNode';
    import { CircleArc2Curve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/CircleArc2Curve3dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareCircleArc2Curve3dElementPerformer extends DeclareBrepElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: CircleArc2Curve3dElement, parameters?: any): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: CircleArc2Curve3dElement): CircleArc2Curve3dNode;
        computeProperty(context: DeclarePerformerContext, source: CircleArc2Curve3dElement, target: CircleArc2Curve3dElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: CircleArc2Curve3dElement, target: CircleArc2Curve3dElement): void;
        checkValid(context: DeclarePerformerContext, target: CircleArc2Curve3dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareCircleArc3Curve2dElementPerformer" {
    import { CircleArc3Curve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArc3Curve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareCircleArc3Curve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: CircleArc3Curve2dElement, parameters?: any): Element;
        buildStructureAfter(context: DeclarePerformerContext, source: CircleArc3Curve2dElement, target: CircleArc3Curve2dElement): void;
        checkValid(context: DeclarePerformerContext, target: CircleArc3Curve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareCircleArcCurve2dElementPerformer" {
    import { CircleArcCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArcCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareCircleArcCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: CircleArcCurve2dElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: CircleArcCurve2dElement, target: CircleArcCurve2dElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: CircleArcCurve2dElement, target: CircleArcCurve2dElement): void;
        checkValid(context: DeclarePerformerContext, target: CircleArcCurve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareCircleCurve2dElementPerformer" {
    import { CircleCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareCircleCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: CircleCurve2dElement, parameters?: any): Element;
        buildStructureAfter(context: DeclarePerformerContext, source: CircleCurve2dElement, target: CircleCurve2dElement): void;
        checkValid(context: DeclarePerformerContext, target: CircleCurve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareEllipseArcCurve2dElementPerformer" {
    import { EllipseArcCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/EllipseArcCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareEllipseArcCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: EllipseArcCurve2dElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: EllipseArcCurve2dElement, target: EllipseArcCurve2dElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: EllipseArcCurve2dElement, target: EllipseArcCurve2dElement): void;
        checkValid(context: DeclarePerformerContext, target: EllipseArcCurve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareEllipseCurve2dElementPerformer" {
    import { EllipseCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/EllipseCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareEllipseCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: EllipseCurve2dElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: EllipseCurve2dElement, target: EllipseCurve2dElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: EllipseCurve2dElement, target: EllipseCurve2dElement): void;
        checkValid(context: DeclarePerformerContext, target: EllipseCurve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareEllipsoidSolidElementPerformer" {
    import { EllipsoidSolidElement } from 'sk/data/family/element/brep/geometric/solid/EllipsoidSolidElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareSpatialElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareSpatialElementPerformer";
    export class DeclareEllipsoidSolidElementPerformer extends DeclareSpatialElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: EllipsoidSolidElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: EllipsoidSolidElement, target: EllipsoidSolidElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: EllipsoidSolidElement, target: EllipsoidSolidElement): void;
        checkValid(context: DeclarePerformerContext, target: EllipsoidSolidElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareLineCurve2dElementPerformer" {
    import { LineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/LineCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareLineCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        constructor();
        createElement(context: DeclarePerformerContext, container: NestElement, reference: LineCurve2dElement, parameters?: any): Element;
        buildStructureReleation(context: DeclarePerformerContext, element: LineCurve2dElement, recursive?: boolean): void;
        checkValid(context: DeclarePerformerContext, target: LineCurve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareLineCurve3dElementPerformer" {
    import { LineCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/LineCurve3dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurveElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurveElementPerformer";
    export class DeclareLineCurve3dElementPerformer extends DeclareCurveElementPerformer {
        constructor();
        createElement(context: DeclarePerformerContext, container: NestElement, reference: LineCurve3dElement, parameters?: any): Element;
        buildStructureReleation(context: DeclarePerformerContext, element: LineCurve3dElement, recursive?: boolean): void;
        checkValid(context: DeclarePerformerContext, target: LineCurve3dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareNurbsCurve2dElementPerformer" {
    import { NurbsCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/NurbsCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclareNurbsCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: NurbsCurve2dElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: NurbsCurve2dElement, target: NurbsCurve2dElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: NurbsCurve2dElement, target: NurbsCurve2dElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclarePathCurve2dElementPerformer" {
    import { PathCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PathCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclarePathCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PathCurve2dElement, parameters?: any): Element;
        buildStructureAfter(context: DeclarePerformerContext, source: PathCurve2dElement, target: PathCurve2dElement): void;
        checkValid(context: DeclarePerformerContext, target: PathCurve2dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclarePathCurve3dElementPerformer" {
    import { PathCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/PathCurve3dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurveElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurveElementPerformer";
    export class DeclarePathCurve3dElementPerformer extends DeclareCurveElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PathCurve3dElement, parameters?: any): Element;
        buildStructureAfter(context: DeclarePerformerContext, source: PathCurve3dElement, target: PathCurve3dElement): void;
        checkValid(context: DeclarePerformerContext, target: PathCurve3dElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclarePointElementPerformer" {
    import { PointElement } from 'sk/data/family/element/brep/geometric/PointElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareVertexElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareVertexElementPerformer";
    export class DeclarePointElementPerformer extends DeclareVertexElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PointElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: PointElement, target: PointElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclarePolygonCurve2dElementPerformer" {
    import { PolygonCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PolygonCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclarePolygonCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PolygonCurve2dElement, parameters?: any): Element;
        buildStructureAfter(context: DeclarePerformerContext, source: PolygonCurve2dElement, target: PolygonCurve2dElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclarePolylineCurve2dElementPerformer" {
    import { PolylineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PolylineCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareCurve2dElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclareCurve2dElementPerfermer";
    export class DeclarePolylineCurve2dElementPerformer extends DeclareCurve2dElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PolylineCurve2dElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: PolylineCurve2dElement, target: PolylineCurve2dElement): void;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareSectionSurfaceElementPerformer" {
    import { SectionSurfaceElement } from 'sk/data/family/element/brep/geometric/surface/SectionSurfaceElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareSpatialElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareSpatialElementPerformer";
    export class DeclareSectionSurfaceElementPerformer extends DeclareSpatialElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: SectionSurfaceElement, parameters?: any): SectionSurfaceElement;
        buildStructureAfter(context: DeclarePerformerContext, source: SectionSurfaceElement, target: SectionSurfaceElement): void;
        checkValid(context: DeclarePerformerContext, target: SectionSurfaceElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/brep/geometric/DeclareSphereSolidElementPerformer" {
    import { SphereSolidElement } from 'sk/data/family/element/brep/geometric/solid/SphereSolidElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareSpatialElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareSpatialElementPerformer";
    export class DeclareSphereSolidElementPerformer extends DeclareSpatialElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: SphereSolidElement, parameters?: any): Element;
        computeProperty(context: DeclarePerformerContext, source: SphereSolidElement, target: SphereSolidElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: SphereSolidElement, target: SphereSolidElement): void;
        checkValid(context: DeclarePerformerContext, target: SphereSolidElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { ComponentReferenceElement } from 'sk/data/family/element/component/ComponentReferenceElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { DeclareContentElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer";
    export class DeclareComponentInstanceElementPerformer extends DeclareContentElementPerformer {
        protected _familyConfigService: FamilyConfigService;
        protected _schemeConfigService: SchemeConfigService;
        protected _familyDocumentService: FamilyDocumentService;
        createElementAsync(context: DeclarePerformerContext, container: NestElement, reference: ComponentElement | ComponentInstanceElement, parameters?: any): Promise<ResultObject<Element>>;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        buildElementStructureProperty(context: DeclarePerformerContext, instanceElement: ContentInstanceElement, componentElement: any): ResultEnum;
        buildElementStructureAsync(context: DeclarePerformerContext, element: FamilyInstanceElement, structure: StructureElement): Promise<ResultObject>;
        getFamilyStructure(document: FamilyDocument): FamilyStructure;
        buildElementDocumentAsync(context: DeclarePerformerContext, element: FamilyInstanceElement, familyDocument: FamilyDocument, buildChild?: boolean): Promise<ResultObject>;
        computeProperty(context: DeclarePerformerContext, source: any, target: any): void;
        buildProperty(context: DeclarePerformerContext, element: FamilyInstanceElement, componentElement: ComponentElement, familyDocument: FamilyDocument): ResultEnum;
        appendPropertyAsync(context: DeclarePerformerContext, element: FamilyInstanceElement, componentElement: ComponentElement, familyDocument: FamilyDocument): Promise<ResultEnum>;
        setPropertyFromComponentInstanceChildrenAsync(context: DeclarePerformerContext, componentInstanceElement: ComponentInstanceElement, familyInstanceElement: FamilyInstanceElement): Promise<ResultObject>;
        setPropertyFromComponentReferenceElementAsync(context: DeclarePerformerContext, componentReferenceElement: ComponentReferenceElement | ComponentInstanceElement, contentInstanceElement: ContentInstanceElement | Types<ContentInstanceElement>): Promise<ResultObject>;
        buildStructureAsync(context: DeclarePerformerContext, source: BrepElement, target: FamilyInstanceElement): Promise<ElementPerformerResult>;
        buildStructureAfter(context: DeclarePerformerContext, source: BrepElement, target: ContentInstanceElement): void;
        private hideElement;
    }
}
declare module "sk/rule/data/declare/performer/container/DeclareContainerComponentElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContainerComponentElement } from 'sk/data/family/element/component/ContainerComponentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareContainerComponentElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, element: ContainerComponentElement): ContainerElement;
    }
}
declare module "sk/rule/data/declare/performer/DeclareStructureElementPerformer" {
    import { SpatialStructureElement } from 'sk/data/family/element/brep/SpatialStructureElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { DeclareNestElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareNestElementPerformer";
    export class DeclareStructureElementPerformer extends DeclareNestElementPerformer {
        protected _schemeConfigService: SchemeConfigService;
        buildStructureAsync(context: DeclarePerformerContext, source: SpatialStructureElement, target: FloorplanElement): Promise<ElementPerformerResult>;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareLightElementPerformer" {
    import { DeclareContentElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer";
    export class DeclareLightElementPerformer extends DeclareContentElementPerformer {
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareAreaLightElementPerformer" {
    import { AreaLightComponentElement } from 'sk/data/family/database/light/element/AreaLightComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AreaLightElement } from 'sk/data/scheme/database/light/element/AreaLightElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareLightElementPerformer } from "sk/rule/data/declare/performer/family/DeclareLightElementPerformer";
    export class DeclareAreaLightElementPerformer extends DeclareLightElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: AreaLightComponentElement, parameters?: any): AreaLightElement;
        computeProperty(context: DeclarePerformerContext, source: AreaLightComponentElement, target: AreaLightElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareAssemblyElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    import { ChestElement } from 'sk/data/scheme/database/furniture/element/ChestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareAssemblyElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: AssemblyElement, parameters?: any): ChestElement;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): BrepElement;
    }
}
declare module "sk/rule/data/scehme/util/AssemblyPlanePropertyUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { IContext } from 'cross/runtime/lang/IContext';
    import { DoorPropertiesOptionsStructure } from 'sk/data/family/database/furniture/element/door/DoorPropertiesOptionsStructure';
    import { DoorPropertiesStructure } from 'sk/data/family/database/furniture/element/door/DoorPropertiesStructure';
    import { EdgeCoverTypeEnum } from 'sk/data/family/database/furniture/enumeration/EdgeCoverTypeEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { AssemblyPlaneComponentElement } from 'sk/data/family/element/component/AssemblyPlaneComponentElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { AssemblyPlaneElement } from 'sk/data/family/element/instance/AssemblyPlaneElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    export type AssemblyPlanePropertyConfig = {
        code: string;
        cover: {
            borderPy: number;
            borderNy: number;
            borderPx: number;
            borderNx: number;
        };
        drift: {
            borderPy: number;
            borderNy: number;
            borderPx: number;
            borderNx: number;
        };
        groupId: string;
    };
    export class AssemblyPlanePropertyUtil {
        protected static _ruleDocumentService: RuleDocumentService;
        static changeEntityCoverValue(element: AssemblyPlaneElement, property: string, coverValue: number, driftValue: number, coverenum?: EdgeCoverTypeEnum): void;
        static getDoorPropertyConfig(element: ComponentElement): AssemblyPlanePropertyConfig;
        static getDoorPropertyByParent(componentElement: ComponentInstanceElement | AssemblyPlaneElement, groupId?: string): DoorPropertiesStructure;
        static getCurrentDoorPropertyByParent(componentElement: ComponentInstanceElement | AssemblyPlaneElement, groupId?: string, familyId?: string): DoorPropertiesOptionsStructure;
        static setDecorateBindingValueAsync(context: IContext, element: FamilyInstanceElement, componentElement: ComponentInstanceElement | AssemblyPlaneElement, newElements?: Types<Element>, groupId?: string, familyId?: string): Promise<void>;
        static setRuleBindingValue(rootElement: AssemblyPlaneComponentElement, componentElement: AssemblyPlaneComponentElement | ComponentInstanceElement | AssemblyPlaneElement, element: AssemblyPlaneElement, groupId?: string, familyId?: string): Promise<void>;
        static installTypeName2Number(ruleInstance: any, installType: string): string;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclarePlaneElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { PlaneComponentElement } from 'sk/data/family/element/component/PlaneComponentElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { DeclareCache } from 'sk/data/scheme/performer/element/DeclareCache';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclarePlaneElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PlaneComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        lockElement(context: DeclarePerformerContext, cache: DeclareCache, source: ComponentInstanceElement, target: PlaneElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: PlaneComponentElement, target: PlaneElement): void;
        checkValid(context: DeclarePerformerContext, target: PlaneElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareAssemblyPlaneElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { AssemblyPlaneComponentElement } from 'sk/data/family/element/component/AssemblyPlaneComponentElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { AssemblyPlaneElement } from 'sk/data/family/element/instance/AssemblyPlaneElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclarePlaneElementPerformer } from "sk/rule/data/declare/performer/family/DeclarePlaneElementPerformer";
    export class DeclareAssemblyPlaneElementPerformer extends DeclarePlaneElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: AssemblyPlaneComponentElement, parameters?: any): AssemblyPlaneElement;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): BrepElement;
        checkValid(context: DeclarePerformerContext, target: AssemblyPlaneElement): boolean;
        buildProperty(context: DeclarePerformerContext, element: AssemblyPlaneElement, componentElement: ComponentElement, familyDocument: FamilyDocument): ResultEnum;
        appendPropertyAsync(context: DeclarePerformerContext, element: FamilyInstanceElement, componentElement: ComponentElement, familyDocument: FamilyDocument): Promise<ResultEnum>;
    }
    export enum RuleInstanceItemParamsCodeEnum {
        positionCd = "position_cd",
        installTypeCd = "install_type_cd",
        reverse = "reverse",
        lengthX = "length_x",
        lengthY = "length_y",
        embedding = "embedding",
        rotationZ = "rotationZ",
        inversionCd = "inversion_cd"
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareLinearElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { LinearComponentElement } from 'sk/data/family/element/component/LinearComponentElement';
    import { LinearElement } from 'sk/data/family/element/instance/LinearElement';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { CurveDocumentService } from 'sk/data/resource/curve/service/CurveDocumentService';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareLinearElementPerformer extends DeclareComponentInstanceElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        protected _curveDocumentService: CurveDocumentService;
        constructor();
        createElement(context: DeclarePerformerContext, container: NestElement, reference: LinearComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        computeProperty(context: DeclarePerformerContext, source: LinearComponentElement, target: LinearElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: LinearComponentElement, target: LinearElement): void;
        private closeGeometricElementVision;
        checkValid(context: DeclarePerformerContext, target: LinearElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareBaseboardElementPerformer" {
    import { CorniceComponentElement } from 'sk/data/family/database/architecture/element/CorniceComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareLinearElementPerformer } from "sk/rule/data/declare/performer/family/DeclareLinearElementPerformer";
    export class DeclareBaseboardElementPerformer extends DeclareLinearElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: CorniceComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareBeamElementPerformer" {
    import { BeamComponentElement } from 'sk/data/family/database/architecture/element/BeamComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareBeamElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: BeamComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareChestElementPerformer" {
    import { ChestComponentElement } from 'sk/data/family/database/furniture/element/ChestComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ChestElement } from 'sk/data/scheme/database/furniture/element/ChestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareChestElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ChestComponentElement, parameters?: any): ChestElement;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareColumnElementPerformer" {
    import { ColumnComponentElement } from 'sk/data/family/database/architecture/element/ColumnComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareColumnElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ColumnComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareCorniceElementPerformer" {
    import { CorniceComponentElement } from 'sk/data/family/database/architecture/element/CorniceComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareLinearElementPerformer } from "sk/rule/data/declare/performer/family/DeclareLinearElementPerformer";
    export class DeclareCorniceElementPerformer extends DeclareLinearElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: CorniceComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareDoorElementPerformer" {
    import { DoorComponentElement } from 'sk/data/family/database/architecture/element/DoorComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareDoorElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: DoorComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        buildStructureBefore(context: DeclarePerformerContext, source: Element, target: Element): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareEdgeSurfaceElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { EdgeSurfaceComponentElement } from 'sk/data/family/element/component/EdgeSurfaceComponentElement';
    import { EdgeSurfaceElement } from 'sk/data/family/element/instance/EdgeSurfaceElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareVertexElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareVertexElementPerformer";
    export class DeclareEdgeSurfaceElementPerformer extends DeclareVertexElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: EdgeSurfaceComponentElement, parameters?: any): EdgeSurfaceElement;
        buildStructureAfter(context: DeclarePerformerContext, source: EdgeSurfaceComponentElement, target: EdgeSurfaceElement): void;
        checkValid(context: DeclarePerformerContext, target: EdgeSurfaceElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareFamilyContainerElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { FamilyContainerElement } from 'sk/data/family/element/instance/FamilyContainerElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareFamilyContainerElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ComponentInstanceElement, parameters?: any): FamilyContainerElement;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/rule/frameddoor/FramedDoorBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FramedDoorComponentElement } from 'sk/data/family/database/furniture/element/frameddoor/FramedDoorComponentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FramedDoorElement } from 'sk/data/scheme/database/furniture/element/FramedDoorElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class FramedDoorBuilder {
        element: FramedDoorElement;
        componentElement: FramedDoorComponentElement;
        context: ElementPerformerContext;
        private dataInfo;
        private borders;
        private cores;
        protected _schemeConfigService: SchemeConfigService;
        constructor(element?: FramedDoorElement);
        buildAsync(context: ElementPerformerContext, element: FramedDoorElement): Promise<ResultObject>;
        private testData2;
        private getBorders;
        private getCores;
        private getParameterValue;
        private clearFramedDoor;
        private createFramedDoorAsync;
        private createBordersAsync;
        private createCoresAsync;
        private createContentElementAsync;
        private replaceFormula;
    }
}
declare module "sk/rule/data/rule/frameddoor/FramedDoorElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FramedDoorComponentElement } from 'sk/data/family/database/furniture/element/frameddoor/FramedDoorComponentElement';
    import { FramedDoorElement } from 'sk/data/scheme/database/furniture/element/FramedDoorElement';
    export class FramedDoorElementUtil {
        static buildFramedDoorFromComponentAsync(element: FramedDoorElement, component: FramedDoorComponentElement): Promise<void>;
        static buildFramedDoorAsync(element: FramedDoorElement, component?: FramedDoorComponentElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareFramedDoorElementPerformer" {
    import { FramedDoorComponentElement } from 'sk/data/family/database/furniture/element/frameddoor/FramedDoorComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FramedDoorElement } from 'sk/data/scheme/database/furniture/element/FramedDoorElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareFramedDoorElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: FramedDoorComponentElement, parameters?: any): FramedDoorElement;
        buildChildElementAsync(context: DeclarePerformerContext, source: FramedDoorComponentElement, target: FramedDoorElement): Promise<ElementPerformerResult>;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeElementPerformerUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { RuleInputElement } from 'sk/data/family/rule/element/instance/RuleInputElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigDecorateInfo } from 'sk/data/scheme/config/SchemeConfigDecorateInfo';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class DecorateInfo {
        linkId: string;
    }
    export class SchemeElementPerformerUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _familyConfigService: FamilyConfigService;
        static computeSurfaceChildMatrix(node: BrepNode): ResultEnum;
        static setSurfaceNodeFromFamilyInfoAsync(context: SchemeElementPerformerContext, node: SurfaceNode, infoId: string): Promise<void>;
        static getFarestNodeAsync(sourceNode: ContentNode, nodes: ContentNode[]): Promise<ResultObject<ContentNode>>;
        static getNearestNodeAsync(sourceNode: ContentNode, nodes: ContentNode[]): Promise<ResultObject<ContentNode>>;
        static searchChildrenByTypeIdAsync(context: ContextObject, parentNode: DataNode, typeId: string): Promise<ResultObject<Types<ContentNode>>>;
        static searchChildrenByCategoryIdAsync(context: ContextObject, parentNode: DataNode, categoryId: string): Promise<ResultObject<Types<ContentNode>>>;
        static searchChildrenByFamilyIdAsync(context: ContextObject, parentNode: DataNode, familyId: string): Promise<ResultObject<Types<ContentNode>>>;
        static searchChildrenByFeaturesAsync(context: ContextObject, parentNode: DataNode, features: any, recursive?: boolean): Promise<ResultObject<Types<ContentNode>>>;
        static doFamilyFeatureFilterAsync(context: ContextObject, code: string, value: any, familyInfoId: string): Promise<ResultObject<boolean>>;
        static getDecorateDefaultAsync(context: SchemeElementPerformerContext, decorateId: string): Promise<ResultObject<DecorateInfo>>;
        static getMaterialResourceIdByElementAsync(context: ElementPerformerContext, materialInfoId: string): Promise<string>;
        static getMaterialResourceIdByConfigIdAsync(context: ElementPerformerContext, configId: string): Promise<string>;
        static getDecorateByConfigIdAsync(context: ContextObject, configId: string): Promise<ResultObject<Array<SchemeConfigDecorateInfo>>>;
        static findElementsByFamilyIdAsync(context: SchemeElementPerformerContext, document: SchemeDocument, familyId: string): Promise<ResultObject<Types<FamilyInstanceElement>>>;
        static findElementsByFamilyIdFromElementAsync(context: SchemeElementPerformerContext, element: NestElement, familyId: string): Promise<ResultObject<Types<FamilyInstanceElement>>>;
        static doFilterByRuleInputElementAsync(context: SchemeElementPerformerContext, inputElement: RuleInputElement, document: SchemeDocument): Promise<ResultObject<any>>;
        private static inputElementHasFilter;
        private static doFilterAsync;
        private static doFilterForNodeAsync;
        private static doFamilyTypeFilterWithFamilyIdAsync;
        private static doFamilyCategoryFilterWithFamilyIdAsync;
        private static doElementTypeFilterWithNode;
        private static doFamilyFeatureFilterByFamilyInfoIdAsync;
    }
}
declare module "sk/rule/data/rule/RuleProcessUtil" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ElementTypeFilterElement } from 'sk/data/family/rule/element/filter/ElementTypeFilterElement';
    import { FamilyCategoryFilterElement } from 'sk/data/family/rule/element/filter/FamilyCategoryFilterElement';
    import { FamilyFeatureFilterElement } from 'sk/data/family/rule/element/filter/FamilyFeatureFilterElement';
    import { FamilyTypeFilterElement } from 'sk/data/family/rule/element/filter/FamilyTypeFilterElement';
    import { RuleInputElement } from 'sk/data/family/rule/element/instance/RuleInputElement';
    import { RuleInstanceElement } from 'sk/data/family/rule/element/instance/RuleInstanceElement';
    import { RuleItemElement } from 'sk/data/family/rule/element/instance/RuleItemElement';
    import { RuleParameterElement } from 'sk/data/family/rule/element/instance/RuleParameterElement';
    import { RuleTypeItemElement } from 'sk/data/family/rule/element/instance/RuleTypeItemElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ComponentNode } from 'sk/data/family/model/component/ComponentNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { RuleProcessDocumentService } from 'sk/data/family/rule/RuleProcessDocumentService';
    import { RuleService } from 'sk/data/family/rule/RuleService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigRuleInfo } from 'sk/data/scheme/config/SchemeConfigRuleInfo';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { RuleFunctionTypeEnum } from 'sk/data/logic/module/enumeration/RuleFunctionTypeEnum';
    import { RuleProcessTypeEnum } from 'sk/data/logic/module/enumeration/RuleProcessTypeEnum';
    import { SchemeRuleProcessInput } from "sk/rule/data/base/rule/SchemeRuleProcessInput";
    type FilterMaps = {
        familyTypeFilterMap: Dictionary<ContentNode[]>;
        familyCategoryFilterMap: Dictionary<ContentNode[]>;
        familyFeatureFilterMap: Dictionary<ContentNode[]>;
        elementTypeFilterMap: Dictionary<ContentNode[]>;
    };
    export class RuleProcessUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _ruleService: RuleService;
        protected static _ruleProcessDocumentService: RuleProcessDocumentService;
        static _calculatorFunctionTypeMap: Dictionary<RuleFunctionTypeEnum[]>;
        static _calculatorProcessTypeMap: Dictionary<RuleProcessTypeEnum[]>;
        static get calculatorFunctionTypeMap(): Dictionary<RuleFunctionTypeEnum[]>;
        static get calculatorProcessTypeMap(): Dictionary<RuleFunctionTypeEnum[]>;
        static clearChildrenByRuleProcessId(element: ContentElement, ruleItemId: string): void;
        static clearChildrenByRuleItemElement(context: SchemeElementPerformerContext, element: ContentElement, ruleTypeInfosMap: Dictionary<SchemeConfigRuleInfo>, ruleInfosMap: Dictionary<SchemeConfigRuleInfo>, ruleItemElement: RuleItemElement): void;
        static processRuleByRuleIdAsync(context: ElementPerformerContext, ruleId: string, input: RuleProcessInput, output: RuleProcessOutput): Promise<ResultObject>;
        protected static addErrorResult(context: ElementPerformerContext, errorResult: ResultObject, element?: ContentElement): void;
        static setRuleInputByAttributes(context: SchemeElementPerformerContext, input: SchemeRuleProcessInput, ruleRootElement: RuleInstanceElement): void;
        private static setRuleInputOutputAsync;
        static clearRuleInputOutput(rule: RuleItemElement): void;
        static processBuildRuleAsync(context: SchemeElementPerformerContext, ruleProcessId: string, element: ContentElement, node: ContentNode, rule: RuleItemElement): Promise<ResultObject>;
        static processRuleForDocumentAsync(context: SchemeElementPerformerContext, ruleProcessId: string, document: FamilyDocument, isGlobal: boolean, rule: RuleItemElement): Promise<ResultObject>;
        static processRuleAsync(context: SchemeElementPerformerContext, ruleProcessId: string, element: ContentElement, node: ContentNode, isGlobal: boolean, rule: RuleItemElement, needClear: boolean): Promise<ResultObject>;
        static processValidateRuleAsync(context: SchemeElementPerformerContext, ruleProcessId: string, element: ContentElement, node: ContentNode, isGlobal: boolean, rule: RuleItemElement): Promise<ResultObject>;
        static processRuleIdAsync(context: SchemeElementPerformerContext, ruleId: string, element: Element, node: ComponentNode, isValidate?: boolean): Promise<ResultObject>;
        private static sortRuleByDataOrder;
        static processRulesByFunctionCdAsync(performerContext: SchemeElementPerformerContext, functionCd: string, element: Element, cache: ElementCache): Promise<ResultObject>;
        static getParametersByInputElement(ruleInputElement: RuleInputElement): Types<RuleParameterElement>;
        static getAllNodesFromBlueprintNode(node: DataNode, clazz: any, arr?: any[]): any[];
        static doFilterAsync(context: SchemeElementPerformerContext, ruleInputElement: RuleInputElement, node?: ContentNode): Promise<Array<ContentNode>>;
        static buildTreesAsync(context: SchemeElementPerformerContext, node: ContentNode, maps?: FilterMaps): Promise<void>;
        static inputElementHasFilter(ruleInputElement: RuleInputElement): boolean;
        static doFilterForNode(context: SchemeElementPerformerContext, ruleInputElement: RuleInputElement, maps?: FilterMaps): Array<ContentNode>;
        static doFamilyTypeFilterWithFamilyIdAsync(context: SchemeElementPerformerContext, filter: FamilyTypeFilterElement, familyId: string): Promise<boolean>;
        static doFamilyCategoryFilterWithFamilyIdAsync(context: SchemeElementPerformerContext, filter: FamilyCategoryFilterElement, familyId: string): Promise<boolean>;
        static doElementTypeFilterWithNode(context: ElementPerformerContext, filter: ElementTypeFilterElement, node: ContentNode): boolean;
        static doFamilyFeatureFilterByFamilyInfoIdAsync(context: SchemeElementPerformerContext, filter: FamilyFeatureFilterElement, familyInfoId: string): Promise<boolean>;
        static validateRuleParametersByRuleTypeAsync(context: ContextObject, componentElement: ComponentElement, ruleTypeItemElement: RuleTypeItemElement, familyDocument?: FamilyDocument): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/performer/NestElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { DataElementCache, DataElementPerformer } from "sk/rule/data/base/element/DataElementPerformer";
    export class NestElementCache extends DataElementCache {
    }
    export class NestElementPerformer extends DataElementPerformer {
        buildElementAsync(context: ElementPerformerContext, parentElement: NestElement, element: NestElement, parameters?: any): Promise<ResultObject>;
        buildChildElementAsync(context: ElementPerformerContext, parentElement: NestElement, element: NestElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer" {
    import { SchemeNestElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeNestElementPerformer";
    export class SchemeInstanceElementPerformer extends SchemeNestElementPerformer {
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeBrepElementPerformer extends SchemeInstanceElementPerformer {
        protected _schemeConfigService: SchemeConfigService;
        buildElementAsync(context: SchemeElementPerformerContext, containerElement: BrepElement, element: BrepElement, parameters?: any): Promise<ResultObject>;
        computePropertyTransform(context: SchemeElementPerformerContext, element: BrepElement, node: BrepNode): void;
        rebuildStructureChildrenAsync(context: ElementPerformerContext, element: BrepElement): Promise<ResultObject>;
        computeProperty(context: SchemeElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        computeBindingValues(context: ElementPerformerContext, element: BrepElement, node: BrepNode): ResultEnum;
        computePropertyAfter(context: ElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        testStructureBuild(context: SchemeElementPerformerContext, element: BrepElement, node: BrepNode): boolean;
        computeStructureBuildAsync(context: SchemeElementPerformerContext, element: BrepElement, node: BrepNode): Promise<ResultObject>;
        computeConfigure(context: SchemeElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        private getConditionValue;
        computeCondition(context: SchemeElementPerformerContext, element: BrepElement, node: BrepNode, parameters?: any): ResultEnum;
        computeShapeMolding(context: SchemeElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        computeShapeBoundary(context: SchemeElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeVertexElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { VertexElement } from 'sk/data/family/element/brep/VertexElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeBrepElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer";
    export class SchemeVertexElementPerformer extends SchemeBrepElementPerformer {
        computePropertyTransform(context: SchemeElementPerformerContext, element: VertexElement, node: VertexNode): void;
        computeProperty(context: SchemeElementPerformerContext, element: VertexElement, index: number, node: VertexNode): ResultEnum;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: VertexElement, index: number, node: VertexNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeSpatialElementPerformer" {
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { SpatialElement } from 'sk/data/family/element/brep/SpatialElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeVertexElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeVertexElementPerformer";
    export class SchemeSpatialElementPerformer extends SchemeVertexElementPerformer {
        computePropertyTransform(context: SchemeElementPerformerContext, element: SpatialElement, node: SpatialNode): void;
        computeLocalMatrix(node: SpatialNode): void;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { RuleItemElement } from 'sk/data/family/rule/element/instance/RuleItemElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleService } from 'sk/data/family/rule/RuleService';
    import { RuleTypeDocumentService } from 'sk/data/family/rule/RuleTypeDocumentService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigRuleInfo } from 'sk/data/scheme/config/SchemeConfigRuleInfo';
    import { SchemeSpatialElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeSpatialElementPerformer";
    export class SchemeContentElementPerformer extends SchemeSpatialElementPerformer {
        protected _ruleService: RuleService;
        protected _ruleTypeDocumentService: RuleTypeDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        protected computePropertyTransformByBorder(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode): void;
        computePropertyTransform(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode): void;
        computeProperty(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeStructureRuleAsync(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode): Promise<ResultObject>;
        protected addErrorResult(context: ElementPerformerContext, element: ContentElement, errorResult: ResultObject): void;
        processParentDocumentRuleAsync(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode): Promise<ResultObject>;
        processRulesByStructureElementAsync(context: SchemeElementPerformerContext, structure: ComponentElement, element: ContentElement, node: ContentNode): Promise<ResultObject>;
        processRuleElemntAsync(context: SchemeElementPerformerContext, ruleTypeInfosMap: Dictionary<SchemeConfigRuleInfo>, ruleInfosMap: Dictionary<SchemeConfigRuleInfo>, rule: RuleItemElement, element: ContentElement, node: ContentNode): Promise<ResultObject>;
        private getTickFormulaValue;
        computeShapeClippingPrepare(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeClippingApply(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        protected computeOctreeNode(node: ContentNode): void;
        computeShapeMatrixImpl(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode, force: boolean): ResultEnum;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeStructure(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode): ResultEnum;
        computeShapeTechnology(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode): ResultEnum;
        computeShapeMolding(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeBoundary(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShape(context: SchemeElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    import { RelationElement } from 'sk/data/family/element/config/relation/RelationElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { ElementCloneOptions } from 'sk/data/family/performer/element/ElementPerformer';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class ContentInstanceElementPerformer extends SchemeContentElementPerformer {
        rootStructureCd: string;
        constructor();
        testElementBuild(calculatorTypeCd: string, element: ContentInstanceElement): boolean;
        computeProperty(context: SchemeElementPerformerContext, element: ContentInstanceElement, index: number, node: ContentInstanceNode): ResultEnum;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        buildElementStructureProperty(context: SchemeElementPerformerContext, instanceElement: ContentInstanceElement, componentElement: any): ResultEnum;
        buildElementStructureAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement, structure: StructureElement, parameters?: any): Promise<ResultObject>;
        buildElementDocumentAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement, familyDocument: FamilyDocument, buildChild?: boolean, parameters?: any): Promise<ResultObject>;
        protected computeCloneReleation(context: ElementPerformerContext, persistentContext: PersistentContext, element: ContentInstanceElement, newElement: ContentInstanceElement, options?: ElementCloneOptions): void;
        protected computeCloneDeep(context: ElementPerformerContext, persistentContext: PersistentContext, element: ContentInstanceElement, newElement: ContentInstanceElement, options?: ElementCloneOptions): ContentInstanceElement;
        protected cloneReleation(context: ElementPerformerContext, persistentContext: PersistentContext, source: RelationElement, target: RelationElement, factory: PersistentFactory): void;
        buildElementByReferenceAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement, familyInfoId: string, parameters?: any): Promise<ResultObject>;
        computeLocalMatrix(node: ContentInstanceNode): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { ComponentReferenceElement } from 'sk/data/family/element/component/ComponentReferenceElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class FamilyInstanceElementPerformer extends ContentInstanceElementPerformer {
        protected _patternDocumentService: PatternDocumentService;
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: Element): FamilyInstanceElement;
        createElementAsync(context: SchemeElementPerformerContext, containerElement: FamilyInstanceElement, element: Element, param?: any): Promise<ResultObject<Element>>;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: FamilyInstanceElement): FamilyInstanceNode;
        prepareAsync(context: SchemeElementPerformerContext, containerElement: NestElement, element: FamilyInstanceElement, parameters?: any): Promise<ElementPerformerResult>;
        computeStructureChildrenAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: FamilyInstanceNode, parameters?: any): Promise<ElementPerformerResult>;
        computeStructureBuildAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: FamilyInstanceNode, parameters?: any): Promise<ResultObject>;
        computeStructureBeforeAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: FamilyInstanceNode, parameters?: any): Promise<ResultObject>;
        computeProperty(context: SchemeElementPerformerContext, element: any, index: number, node: FamilyInstanceNode): ResultEnum;
        onPrepareAsync(context: SchemeElementPerformerContext, containerElement: BrepElement, element: FamilyInstanceElement): Promise<ElementPerformerResult>;
        buildPropertyByFamilyDocument(context: SchemeElementPerformerContext, element: ContentInstanceElement, componentInstanceElement: ComponentInstanceElement, familyDocument: FamilyDocument): ResultEnum;
        appendPropertyAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement, componentInstanceElement: ComponentInstanceElement, familyDocument: FamilyDocument, newElements: Types<Element>): Promise<ResultEnum>;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: FamilyInstanceElement, element: ComponentElement | FamilyInstanceElement, parameters?: any): Promise<ResultObject>;
        setPropertyFromComponentInstanceChildrenAsync(context: SchemeElementPerformerContext, componentInstanceElement: ComponentInstanceElement, contentInstanceElementChildren: Types<ContentInstanceElement>): Promise<ResultObject>;
        setPropertyFromComponentReferenceElementAsync(context: SchemeElementPerformerContext, componentReferenceElement: ComponentReferenceElement, contentInstanceElement: ContentInstanceElement | Types<ContentInstanceElement>): Promise<ResultObject>;
        computeBindingValueAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement): Promise<ResultObject>;
        computeElementAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement): Promise<ResultObject>;
        computeStructureRuleAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: FamilyInstanceNode): Promise<ResultObject>;
        processFamilyRuleAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: FamilyInstanceNode): Promise<ResultObject>;
        loadStructureElementAsync(context: SchemeElementPerformerContext, element?: FamilyInstanceElement, referenceInfoId?: string): Promise<ResultObject<ComponentElement>>;
        processParentDocumentRuleAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: FamilyInstanceNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemePlaneElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { PlaneComponentElement } from 'sk/data/family/element/component/PlaneComponentElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemePlaneElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: PlaneElement): PlaneElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: PlaneElement): PlaneNode;
        computeProperty(context: SchemeElementPerformerContext, element: PlaneElement, index: number, node: PlaneNode): ResultEnum;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: FamilyInstanceElement, element: PlaneElement, parameters?: any): Promise<ResultObject>;
        testStructureBuild(context: SchemeElementPerformerContext, element: PlaneElement, node: PlaneNode): boolean;
        private setPlaneBoundaryEdgeAndShapeType;
        private computeRectangleProperty;
        private clearDynamicEdgesAndPoints;
        computeStructureBuildAsync(context: SchemeElementPerformerContext, element: PlaneElement, node: PlaneNode): Promise<ResultObject>;
        computeStructureBuildAsync2(context: SchemeElementPerformerContext, element: PlaneElement, node: PlaneNode): Promise<ResultObject>;
        computeStructureAfter(context: ElementPerformerContext, element: PlaneElement, node: PlaneNode, parameters?: any): ResultEnum;
        testElementBuild(calculatorTypeCd: string, element: ContentInstanceElement): boolean;
        buildElementStructureProperty(context: SchemeElementPerformerContext, instanceElement: PlaneElement, componentElement: PlaneComponentElement): ResultEnum;
        computeShapeTechnology(context: SchemeElementPerformerContext, element: PlaneElement, node: PlaneNode): ResultEnum;
        private checkPlaneElement;
        private fetchPlaneChildrenMapWithElement;
        computeStructureChildrenAsync(context: ElementPerformerContext, element: PlaneElement, node: PlaneNode, parameters?: any, computeBaseOnly?: boolean): Promise<ElementPerformerResult>;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemePlankElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemePlaneElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemePlaneElementPerformer";
    export class SchemePlankElementPerformer extends SchemePlaneElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: PlankElement): PlankElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: PlankElement): PlankNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        computeStructureBefore(context: ElementPerformerContext, element: PlankElement, node: PlankNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/util/ProfilePerformerUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Curve2dStructure } from 'foundation/data/common/structure/geometric/Curve2dStructure';
    import { ParameterElement } from 'sk/data/family/element/config/ParameterElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class ProfilePerformerUtil {
        static loadProfileAsync(context: ElementPerformerContext, profileId: string, parameters: Types<ParameterElement>, targetCurves: Types<Curve2dStructure>): Promise<void>;
        static sortStructuresAsPath(structs: Array<Curve2dStructure>, sortFoward?: boolean): any;
    }
}
declare module "sk/rule/data/scehme/performer/instance/LinearElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Vector4 } from 'foundation/runtime/math/Vector4';
    import { LineCurve2dStructure } from 'foundation/data/common/structure/geometric/curve2d/LineCurve2dStructure';
    import { ProfileElement } from 'sk/data/family/structure/profile/element/ProfileElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { LinearComponentElement } from 'sk/data/family/element/component/LinearComponentElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { LinearElement } from 'sk/data/family/element/instance/LinearElement';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { CurveDocumentService } from 'sk/data/resource/curve/service/CurveDocumentService';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class LinearElementPerformer extends FamilyInstanceElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        protected _curveDocumentService: CurveDocumentService;
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: LinearElement): FamilyInstanceElement;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: LinearElement): LinearNode;
        buildElementReleation(context: SchemeElementPerformerContext, element: LinearElement): void;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: LinearElement, node: LinearNode, parameters?: any): Promise<ResultObject>;
        computeProperty(context: SchemeElementPerformerContext, element: LinearElement, index: number, node: LinearNode): ResultEnum;
        computeElementProperty(context: SchemeElementPerformerContext, source: LinearComponentElement, target: LinearElement): void;
        buildElementStructureAsync(context: SchemeElementPerformerContext, element: LinearElement, structure: StructureElement): Promise<ResultObject>;
        protected onComputeStructureAfterAsync(context: SchemeElementPerformerContext, element: LinearElement, node: LinearNode): Promise<void>;
        processInstance(context: SchemeElementPerformerContext, element: LinearComponentElement): ResultEnum;
        createLineCurve2dStructure(begin: Vector3, end: Vector3): LineCurve2dStructure;
        processProfileProperty(context: SchemeElementPerformerContext, element: LinearComponentElement, points: Array<Vector3>, node: LinearNode): void;
        processPathCurveProperty(context: SchemeElementPerformerContext, node: LinearNode): void;
        protected updateFromProfileElement(context: SchemeElementPerformerContext, node: LinearNode, element: LinearElement, profile: ProfileElement): void;
        protected updateFromProfileId(context: SchemeElementPerformerContext, node: LinearNode, element: LinearElement, profileId: string): Promise<void>;
        protected updateProfileAsync(context: SchemeElementPerformerContext, node: LinearNode, element: LinearElement, profileId: string): Promise<void>;
        protected updateProfileCurveAsync(context: SchemeElementPerformerContext, node: LinearNode, element: LinearElement, curveID: string): Promise<void>;
        protected calBaseboardOrCornicePath(context: SchemeElementPerformerContext, node: LinearNode): void;
        protected calBaseboardOrCorniceAngle(wallSurface: WallSurfaceNode): Vector4;
    }
}
declare module "sk/rule/data/scehme/performer/technology/SchemeTechnologyElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class SchemeTechnologyElementPerformer extends SchemeContentElementPerformer {
        constructor();
        computeProperty(context: SchemeElementPerformerContext, element: TechnologyElement, index: number, node: TechnologyNode): ResultEnum;
    }
}
declare module "sk/rule/data/rule/assemble/CupboardTopElementUtil" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { ComplexHoleSurface } from 'foundation/runtime/geometry/surface/ComplexHoleSurface';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Curve2d, SingleCurve2d } from 'foundation/runtime/geometry/Curve2d';
    import { SingleSurface, Surface } from 'foundation/runtime/geometry/Surface';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class FamilyData {
        family: FamilyInstanceNode;
        section: Surface;
        normal: Vector3;
        hight: number;
        box: BoxSolid;
    }
    export class AvoidData {
        node: ContentNode;
        geometry: MoldingGeometryStructure;
        box: BoxSolid;
        section: SectionSurface;
    }
    export class CupboardTopInfo {
        plankElement: PlankElement;
        name: string;
        document: SchemeDocument;
        floorplan: FloorplanElement;
        nodes: Array<DataNode>;
        calculatorService: CalculatorService;
        schemeConfigService: SchemeConfigService;
    }
    export class CupboardSideInfo {
        plank: PlankNode;
        path: PathCurve2d;
        distance: number;
        avoids: Array<FamilyInstanceNode>;
        document: SchemeDocument;
        calculatorService: CalculatorService;
        schemeConfigService: SchemeConfigService;
    }
    export class SurfaceInfo {
        plankElement: PlankElement;
        plankNode: PlankNode;
        surface: SectionSurface;
        calculatorService: CalculatorService;
        document: SchemeDocument;
    }
    export class CupboardTopElementUtil {
        private static getRuleInputAsync;
        protected static getAvoidOutlineData(avoid: AvoidData, m: Matrix4, group: Array<FamilyData>): AvoidData;
        protected static processCutRoom(first: FamilyInstanceNode, proj: Matrix4, allSurface: Array<Surface>): Array<Surface>;
        protected static getRoom(first: FamilyInstanceNode, proj: Matrix4, surfaceBox: BoxSolid): ComplexHoleSurface;
        protected static getAllRoomData(): Array<ComplexHoleSurface>;
        protected static getRoomData(room: RoomNode): ComplexHoleSurface;
        protected static getFamilyData(family: FamilyInstanceNode, m: Matrix4, isHightest?: boolean, normal?: Vector3, plank?: PlankNode, is_boundary_box?: boolean): FamilyData;
        protected static getProjectMatrix(project_type_cd: number, first: FamilyInstanceNode): Matrix3d;
        protected static setSurfacPositive(surface: Surface): Surface;
        static createSectionSurfaceEdgeAsync(surfaceInfo: SurfaceInfo, edgeSections?: Array<Curve2d>, edgeCurves?: Array<SingleCurve2d>, tolerance?: number): Promise<void>;
        static createComplexHolesSurfaceEdge(plane: PlankElement, holes: Array<SingleSurface>): void;
        static execAsync(info: CupboardTopInfo): Promise<boolean>;
        static execSideAsync(info: CupboardSideInfo, context?: SchemeElementPerformerContext): Promise<void>;
        static resetLocalInfo(parent: ContentElement): void;
    }
}
declare module "sk/rule/data/rule/linear/FurnitureLinearTypeEnum" {
    export class FurnitureLinearTypeEnum {
        static TopLinear: string;
        static LegLinear: string;
        static LigthLinear: string;
        static FrontWaterBar: string;
        static BackWaterBar: string;
        static getValueByFamilyTypeCode(code: string): FurnitureLinearTypeEnum;
        static getTranslationInfo(value: FurnitureLinearTypeEnum): {
            type: "fixed" | "proportion";
            x: number;
            y: number;
        };
        static getFlipInfo(value: FurnitureLinearTypeEnum): {
            x: boolean;
            y: boolean;
        };
    }
}
declare module "sk/rule/data/rule/linear/FurnitureLinearBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Section3dSurface } from 'foundation/runtime/geometry/surface/Section3dSurface';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FurnitureCountertopElement } from 'sk/data/scheme/database/furniture/element/FurnitureCountertopElement';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { FurnitureCountertopItemStructure } from 'sk/data/scheme/database/furniture/structure/FurnitureCountertopItemStructure';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class CounterTopBindingValueCodeEnum {
        static sideSplicingCd: string;
        static backWaterBarAlignCd: string;
    }
    export type FurnitureLinearBuilderParameter = {
        techs: TechnologyNode[];
        matrix: Matrix4;
    };
    type Plank = {
        countertop: FurnitureCountertopItemStructure;
        section3d: Section3dSurface;
        section2d: SectionSurface;
        plankInfo: ISpecificationFamilyInfo;
        plank: PlankElement;
        buffer: BufferGeometry;
        box: BoxSolid;
        localMatrix: Matrix3d;
        worldMatrix: Matrix3d;
        container: ContainerElement;
        plankLengthZ: number;
        zOffset: number;
    };
    export class FurnitureLinearBuilder {
        protected static _calculatorService: CalculatorService;
        protected static _schemeConfigService: SchemeConfigService;
        private static isHaveFamilyType;
        private static getTransFilp;
        static buildAsync(context: SchemeElementPerformerContext, element: FurnitureCountertopElement, parameter: FurnitureLinearBuilderParameter): Promise<ResultObject>;
        static collisionFamilyTransmit(context: ElementPerformerContext, attacks: Array<TechnologyNode>, defenses: Array<Plank>, tolerance?: number): void;
        static updateAsync(context: SchemeElementPerformerContext, element: FurnitureCountertopElement, parameter: FurnitureLinearBuilderParameter): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/linear/FurnitureLinearUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BooleanOperation } from 'foundation/runtime/math/Operator';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { LineCurve3d } from 'foundation/runtime/geometry/curve3d/LineCurve3d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { BusinessDirectTypeEnum } from 'sk/data/family/database/furniture/enumeration/BusinessDirectTypeEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { LinearPathCurve3dNode } from 'sk/data/family/model/instance/LinearPathCurve3dNode';
    import { FamilyTypeEnum } from 'sk/data/family/enumeration/FamilyTypeEnum';
    import { FloorplanNode } from 'sk/data/scheme/database/floorplan/model/FloorplanNode';
    import { FurnitureCountertopElement } from 'sk/data/scheme/database/furniture/element/FurnitureCountertopElement';
    import { FurnitureProfileWareElement } from 'sk/data/scheme/database/furniture/element/FurnitureProfileWareElement';
    import { ChestNode } from 'sk/data/scheme/database/furniture/model/ChestNode';
    import { FurnitureCountertopNode } from 'sk/data/scheme/database/furniture/node/FurnitureCountertopNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { FurnitureLinearBuilderParameter } from "sk/rule/data/rule/linear/FurnitureLinearBuilder";
    export type LinearContainerElement = FurnitureCountertopElement | FurnitureProfileWareElement;
    export class FurnitureCounterTopReferenceEnum {
        static Front: string;
        static Back: string;
        static Plank: string;
        static Common: string;
        static Null: string;
    }
    export class FurnitureLinearCurveTypeEnum {
        static Normal: string;
        static Wall: string;
        static Chest: string;
    }
    export class LinearBindingValueCodeEnum {
        static SideOffsetOptions: string;
        static SideExpandOptions: string;
        static SideToGroundOptions: string;
        static CreateSide: string;
    }
    export type FurnitureCountertopPolygonInfo = {
        curveInfos: CountertopCurveInfo[];
        expandOptions?: number[];
        createSideOptions?: boolean[];
    };
    type CountertopCurveInfo = {
        curve: LineCurve3d;
        offsetDirection?: BusinessDirectTypeEnum;
        offset?: number;
        isOffsetValid: boolean;
        expand?: number;
        type: string;
        polygonInfo?: FurnitureCountertopPolygonInfo;
        createSide?: boolean;
    };
    type LoftPolygonInfo = {
        isMatched?: boolean;
        curves: LineCurve3d[];
        sourceCurveInfos: CountertopCurveInfo[];
    };
    export type FunritureMergePolygonInfo = {
        expandOptions: number[];
        polygon: FurnitureCountertopPolygonInfo;
        sourcePolygons?: FurnitureCountertopPolygonInfo[];
    };
    export class FurnitureLinearUtil {
        static setPropertyAsync(context: SchemeElementPerformerContext, counterTopEl: LinearContainerElement, group: GroupNode | ChestNode, type: FamilyTypeEnum, counterTopNode?: FurnitureCountertopNode): Promise<ResultObject>;
        static parseGroupsAsync(context: SchemeElementPerformerContext, counterTopEl: LinearContainerElement, group: GroupNode | ChestNode, type: FamilyTypeEnum, referenceCodeMap: {
            [key: string]: string;
        }, counterTopNode?: FurnitureCountertopNode): Promise<ResultObject<FunritureMergePolygonInfo[]>>;
        static computeLinearOffsetAsync(context: SchemeElementPerformerContext, counterTopEl: LinearContainerElement, mergePolygonInfos: FunritureMergePolygonInfo[], referenceCodeMap: {
            [key: string]: string;
        }): Promise<ResultObject>;
        static computeSide(mergePolygonInfos: FunritureMergePolygonInfo[], optionCreateSide: boolean): void;
        static getValidIntersectCurves(line: LineCurve2d, curves: LineCurve2d[], booleanOperation: BooleanOperation): Curve2d[];
        static matchLinearType(document: SchemeDocument, mergePolygonInfos: FunritureMergePolygonInfo[]): void;
        static getAssemblyPolygonInfos(floorplan: FloorplanNode, document: SchemeDocument, tolerance?: number): {
            type: "wall" | "chest" | "innerWall";
            polygon: Vector2[][];
            minZ?: number;
            maxZ?: number;
        }[];
        static getAllChestPolygonInfos(floorplan: FloorplanNode, tolerance?: number): {
            type: "wall" | "chest";
            polygon: Vector2[][];
            minZ?: number;
            maxZ?: number;
        }[];
        static getPolygon(polygonInfo: FurnitureCountertopPolygonInfo): Vector2[];
        static getFloorplanPolygon(floorplan: FloorplanNode, tolerance?: number): Vector2[][];
        static getPolygonInfosFromChestsAsync(context: SchemeElementPerformerContext, chests: ChestNode[], type: FamilyTypeEnum, groupMatrix: Matrix4): Promise<ResultObject<FurnitureCountertopPolygonInfo[]>>;
        static getExpandOptionsListFromInstance(countertopEl: LinearContainerElement): number[][];
        static getPolygonInfosFromInstance(countertopEl: LinearContainerElement, type: FamilyTypeEnum, matrix: Matrix4): FurnitureCountertopPolygonInfo[];
        static getMergePolygonInfos(polygons: FurnitureCountertopPolygonInfo[], itemExpandOptions?: number[][]): FunritureMergePolygonInfo[];
        static computeItemExpands(mergePolygonInfo: FunritureMergePolygonInfo): void;
        static getSubPolygonInfosList(mergePolygons: Vector2[][], sourcePolygonsInfos: FurnitureCountertopPolygonInfo[], loftPolygonInfos: LoftPolygonInfo[]): FurnitureCountertopPolygonInfo[][];
        static getMergePolygonInfo(mergePolygon: Vector2[], loftPolygonInfos: LoftPolygonInfo[], itemExpandOption: number[]): FunritureMergePolygonInfo;
        static checkOffsetValid(sourcePolygonsInfos: FurnitureCountertopPolygonInfo[], loftPolygonInfos: LoftPolygonInfo[]): void;
        static mergePolygonInfos(loftPolygonInfos: LoftPolygonInfo[]): Vector2[][];
        static loftPolygons(polygons: FurnitureCountertopPolygonInfo[], computeExpand?: boolean, addValues?: number[]): LoftPolygonInfo[];
        static loftPolygon(polygon: FurnitureCountertopPolygonInfo, computeExpand?: boolean, addValues?: number[]): LoftPolygonInfo;
        static getValidIndex(arr: number[], currentIndex: number, reverse: boolean): number;
        static getListByZValue(polygons: FurnitureCountertopPolygonInfo[]): {
            zValue: number;
            polygonInfos: FurnitureCountertopPolygonInfo[];
        }[];
        static sortByZValueFun(obj1: any, obj2: any): number;
        static convertPathFromInstance(pathNode: LinearPathCurve3dNode, groupMatrix: Matrix4, type: FamilyTypeEnum): FurnitureCountertopPolygonInfo;
        static getChestPolygon(chest: ChestNode, type: FamilyTypeEnum, z?: number): Array<LineCurve3d>;
        static getCurveOffset(chest: ChestNode, lineCurve: LineCurve3d, groupMatrix: Matrix4, type: FamilyTypeEnum): number;
        static getDefaultPolygonInfo(chest: ChestNode, type: FamilyTypeEnum, groupMatrix: Matrix4, z?: number): FurnitureCountertopPolygonInfo;
        static getChests(group: GroupNode): ChestNode[];
        static getSideOffsetOptions(element: BrepElement): number[];
        static getSideExpandOptions(element: BrepElement): number[];
        static getCreateSideOption(element: BrepElement): boolean;
        static bindingDataToElement(counterTopEl: LinearContainerElement, furnitureData: Array<FunritureMergePolygonInfo>, referenceCodeMap: {
            [key: string]: string;
        }): void;
        static buildElementAsync(context: SchemeElementPerformerContext, counterTopEl: LinearContainerElement, parameter: FurnitureLinearBuilderParameter): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareFurnitureCountertopElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { FurnitureCountertopComponentElement } from 'sk/data/family/database/furniture/element/FurnitureCountertopComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { CurveDocumentService } from 'sk/data/resource/curve/service/CurveDocumentService';
    import { FurnitureCountertopElement } from 'sk/data/scheme/database/furniture/element/FurnitureCountertopElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareFurnitureCountertopElementPerformer extends DeclareComponentInstanceElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        protected _curveDocumentService: CurveDocumentService;
        protected _schemeConfigService: SchemeConfigService;
        protected _calculatorService: CalculatorService;
        constructor();
        createElement(context: DeclarePerformerContext, container: NestElement, reference: FurnitureCountertopComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        buildStructureAsync(context: DeclarePerformerContext, source: FurnitureCountertopComponentElement, target: FurnitureCountertopElement): Promise<ElementPerformerResult>;
        computePropertyAsync(context: DeclarePerformerContext, source: FurnitureCountertopComponentElement, target: FurnitureCountertopElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareHardwareElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { HardwareComponentElement } from 'sk/data/family/element/component/HardwareComponentElement';
    import { HardwareElement } from 'sk/data/family/element/instance/HardwareElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareHardwareElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: HardwareComponentElement, parameters?: any): HardwareElement;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        buildStructureBefore(context: DeclarePerformerContext, source: HardwareComponentElement, target: HardwareElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareHoleElementPerformer" {
    import { HoleComponentElement } from 'sk/data/family/database/architecture/element/HoleComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareHoleElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: HoleComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareLayoutElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LayoutComponentElement } from 'sk/data/family/element/component/LayoutComponentElement';
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareLayoutElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: LayoutComponentElement, parameters?: any): LayoutElement;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareLinearLineCurve3dElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LinearLineCurve3dElement } from 'sk/data/family/element/instance/LinearLineCurve3dElement';
    import { LinearLineCurve3dNode } from 'sk/data/family/model/instance/LinearLineCurve3dNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareLinearLineCurve3dElementPerformer extends DeclareBrepElementPerformer {
        createElement(context: DeclarePerformerContext, containerElement: NestElement, element: LinearLineCurve3dElement): LinearLineCurve3dElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LinearLineCurve3dElement): LinearLineCurve3dNode;
        computeProperty(context: DeclarePerformerContext, source: LinearLineCurve3dElement, target: LinearLineCurve3dElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareLinearPathCurve3dElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LinearPathCurve3dElement } from 'sk/data/family/element/instance/LinearPathCurve3dElement';
    import { LinearPathCurve3dNode } from 'sk/data/family/model/instance/LinearPathCurve3dNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareLinearPathCurve3dElementPerformer extends DeclareBrepElementPerformer {
        createElement(context: DeclarePerformerContext, containerElement: NestElement, element: LinearPathCurve3dElement): LinearPathCurve3dElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LinearPathCurve3dElement): LinearPathCurve3dNode;
        buildStructureAfter(context: DeclarePerformerContext, source: LinearPathCurve3dElement, target: LinearPathCurve3dElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareMaterialLayoutElementPerformer" {
    import { MaterialLayoutElement } from 'sk/data/family/element/instance/layout/MaterialLayoutElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { MaterialLayoutComponentElement } from 'sk/data/family/element/component/MaterialLayoutComponentElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareLayoutElementPerformer } from "sk/rule/data/declare/performer/family/DeclareLayoutElementPerformer";
    export class DeclareMaterialComponentElementPreformer extends DeclareLayoutElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: MaterialLayoutComponentElement, parameters?: any): MaterialLayoutElement;
        buildStructureAsync(context: DeclarePerformerContext, source: MaterialLayoutComponentElement, target: MaterialLayoutElement): Promise<ElementPerformerResult>;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareSurfaceElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SurfaceComponentElement } from 'sk/data/family/element/component/SurfaceComponentElement';
    import { SurfaceElement } from 'sk/data/family/element/instance/SurfaceElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareVertexElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareVertexElementPerformer";
    export class DeclareSurfaceElementPerformer extends DeclareVertexElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: SurfaceComponentElement, parameters?: any): SurfaceElement;
        computeProperty(context: DeclarePerformerContext, source: SurfaceComponentElement, target: SurfaceElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclarePlaneSurfaceElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { PlaneSurfaceComponentElement } from 'sk/data/family/element/component/PlaneSurfaceComponentElement';
    import { PlaneSurfaceElement } from 'sk/data/family/element/instance/PlaneSurfaceElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareSurfaceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareSurfaceElementPerformer";
    export class DeclarePlaneSurfaceElementPerformer extends DeclareSurfaceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PlaneSurfaceComponentElement, parameters?: any): PlaneSurfaceElement;
        computeProperty(context: DeclarePerformerContext, source: PlaneSurfaceComponentElement, target: PlaneSurfaceElement): void;
        checkValid(context: DeclarePerformerContext, target: PlaneSurfaceElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclarePlankElementPerformer" {
    import { PlankComponentElement } from 'sk/data/family/database/furniture/element/PlankComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclarePlaneElementPerformer } from "sk/rule/data/declare/performer/family/DeclarePlaneElementPerformer";
    export class DeclarePlankElementPerformer extends DeclarePlaneElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PlankComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclarePlugInterfaceElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { PlugInterfaceComponentElement } from 'sk/data/family/element/component/PlugInterfaceComponentElement';
    import { PlugInterfaceElement } from 'sk/data/family/element/instance/PlugInterfaceElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclarePlaneElementPerformer } from "sk/rule/data/declare/performer/family/DeclarePlaneElementPerformer";
    export class DeclarePlugInterfaceElementPerformer extends DeclarePlaneElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PlugInterfaceComponentElement, parameters?: any): PlugInterfaceElement;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclarePointLightElementPerformer" {
    import { PointLightComponentElement } from 'sk/data/family/database/light/element/PointLightComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { PointLightElement } from 'sk/data/scheme/database/light/element/PointLightElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareLightElementPerformer } from "sk/rule/data/declare/performer/family/DeclareLightElementPerformer";
    export class DeclarePointLightElementPerformer extends DeclareLightElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PointLightComponentElement, parameters?: any): PointLightElement;
        computeProperty(context: DeclarePerformerContext, source: PointLightComponentElement, target: PointLightElement): void;
    }
}
declare module "sk/rule/data/rule/slidingdoor/SlidingDoorBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SlidingDoorComponentElement } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorComponentElement';
    import { FurnitureMaterialValueStructure } from 'sk/data/family/database/furniture/element/FurnitureMaterialValueStructure';
    import { HardwareElement } from 'sk/data/family/element/instance/HardwareElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { SlidingDoorElement } from 'sk/data/scheme/database/furniture/element/SlidingDoorElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class SlidingDoorBuilder {
        element: SlidingDoorElement;
        componentElement: SlidingDoorComponentElement;
        context: ElementPerformerContext;
        private layoutsAttr;
        private activeLeafAttr;
        private bedPlanksAttr;
        private activebedPlankAttrs;
        private hardwaresAttr;
        private activeHardwareAttrs;
        private leafAttr;
        private dataInfo;
        protected _schemeConfigService: SchemeConfigService;
        protected _documentService: FamilyDocumentService;
        constructor(element?: SlidingDoorElement, componentElement?: SlidingDoorComponentElement);
        buildAsync(context: ElementPerformerContext, element: SlidingDoorElement): Promise<ResultObject>;
        private getArrangeInfo;
        private getParameterValue;
        private getActiveLeafLayout;
        private getActiveBedPlanksAsync;
        private getSymbolAsync;
        private getActiveHardwares;
        private clearBuildContainer;
        private getBuildContainer;
        private createSlidingDoorAsync;
        private createTracksAndBedPlanksAsync;
        private createLeafAsync;
        private createLeafLayoutAsync;
        private createLeafHardwaresAsync;
        private createLeafCenterAsync;
        private createContentElementAsync;
        private setPlankDecorateAsync;
        protected setHardwareDecorateAsync(element: HardwareElement, defaultMaterial: FurnitureMaterialValueStructure): Promise<void>;
    }
}
declare module "sk/rule/data/rule/slidingdoor/SlidingDoorElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SlidingDoorComponentElement } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorComponentElement';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { SlidingDoorElement } from 'sk/data/scheme/database/furniture/element/SlidingDoorElement';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    export class SlidingDoorElementUtil {
        static buildSlidingDoorFromComponentAsync(element: SlidingDoorElement, component?: SlidingDoorComponentElement): Promise<ResultObject>;
        static buildSlidingDoorAsync(element: SlidingDoorElement, component?: SlidingDoorComponentElement): Promise<ResultObject>;
        static getSlidingDoorCorePlanks(slidingDoorElement: SlidingDoorElement): PlankElement[];
        static getSlidingDoorCorePlankNodes(entity: any): PlankNode[];
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareSlidingDoorElementPerformer" {
    import { SlidingDoorComponentElement } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SlidingDoorElement } from 'sk/data/scheme/database/furniture/element/SlidingDoorElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareSlidingDoorElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: SlidingDoorComponentElement, parameters?: any): SlidingDoorElement;
        buildChildElementAsync(context: DeclarePerformerContext, source: SlidingDoorComponentElement, target: SlidingDoorElement): Promise<ElementPerformerResult>;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareSpatialContainerElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SpatialContainerElement } from 'sk/data/family/element/instance/SpatialContainerElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareContentElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer";
    export class DeclareSpatialContainerElementPerformer extends DeclareContentElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: SpatialContainerElement, parameters?: any): SpatialContainerElement;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareSpotLightElementPerformer" {
    import { SpotLightComponentElement } from 'sk/data/family/database/light/element/SpotLightComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SpotLightElement } from 'sk/data/scheme/database/light/element/SpotLightElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareLightElementPerformer } from "sk/rule/data/declare/performer/family/DeclareLightElementPerformer";
    export class DeclareSpotLightElementPerformer extends DeclareLightElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: SpotLightComponentElement, parameters?: any): SpotLightElement;
        computeProperty(context: DeclarePerformerContext, source: SpotLightComponentElement, target: SpotLightElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareSubstrateElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SubstrateComponentElement } from 'sk/data/family/element/component/SubstrateComponentElement';
    import { SubstrateElement } from 'sk/data/family/element/instance/SubstrateElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareVertexElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareVertexElementPerformer";
    export class DeclareSubstrateElementPerformer extends DeclareVertexElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: SubstrateComponentElement, parameters?: any): SubstrateElement;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareVisionGridModelElementPerformer" {
    import { VisionGridModelElement } from 'sk/data/family/element/brep/vision/VisionGridModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareContentElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer";
    export class DeclareVisionGridModelElementPerformer extends DeclareContentElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: VisionGridModelElement, parameters?: any): VisionGridModelElement;
        computeProperty(context: DeclarePerformerContext, source: VisionGridModelElement, target: VisionGridModelElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareVisionLineModelElementPerformer" {
    import { VisionLineModelElement } from 'sk/data/family/element/brep/vision/VisionLineModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareContentElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer";
    export class DeclareVisionLineModelElementPerformer extends DeclareContentElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: VisionLineModelElement, parameters?: any): VisionLineModelElement;
        computeProperty(context: DeclarePerformerContext, source: VisionLineModelElement, target: VisionLineModelElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareVisionModelElementPerformer" {
    import { VisionModelElement } from 'sk/data/family/element/brep/vision/VisionModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareContentElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer";
    export class DeclareVisionModelElementPerformer extends DeclareContentElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: VisionModelElement, parameters?: any): VisionModelElement;
        computeProperty(context: DeclarePerformerContext, source: VisionModelElement, target: VisionModelElement): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareWareElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareWareElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: Element, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        buildStructureBefore(context: DeclarePerformerContext, source: Element, target: Element): void;
    }
}
declare module "sk/rule/data/declare/performer/family/DeclareWindowElementPerformer" {
    import { WindowComponentElement } from 'sk/data/family/database/architecture/element/WindowComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclareWindowElementPerformer extends DeclareComponentInstanceElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: WindowComponentElement, parameters?: any): Element;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/declare/performer/pattern/DeclarePatternElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { PatternComponentElement } from 'sk/data/family/element/component/PatternComponentElement';
    import { PatternComponentInstanceElement } from 'sk/data/family/element/component/PatternComponentInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareComponentInstanceElementPerformer } from "sk/rule/data/declare/performer/family/DeclareComponentInstanceElementPerformer";
    export class DeclarePatternElementPerformer extends DeclareComponentInstanceElementPerformer {
        protected _patternDocumentService: PatternDocumentService;
        createElement(context: DeclarePerformerContext, container: NestElement, reference: PatternComponentElement, parameters?: any): PatternInstanceElement;
        findStructureElement(context: DeclarePerformerContext, structure: StructureElement): Element;
        getFamilyStructure(document: PatternDocument): FamilyStructure;
        buildStructureAsync(context: DeclarePerformerContext, source: PatternComponentElement | PatternComponentInstanceElement, target: any): Promise<ElementPerformerResult>;
    }
}
declare module "sk/rule/data/declare/performer/structure/DeclareProfileCurveElementPerformer" {
    import { ProfileCurveElement } from 'sk/data/family/structure/profile/element/ProfileCurveElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareProfileCurveElementPerformer extends DeclareBrepElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ProfileCurveElement, parameters?: any): ProfileCurveElement;
        computeProperty(context: DeclarePerformerContext, source: ProfileCurveElement, target: ProfileCurveElement): void;
    }
}
declare module "sk/rule/data/declare/performer/structure/DeclareProfileElementPerformer" {
    import { ProfileElement } from 'sk/data/family/structure/profile/element/ProfileElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareBrepElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareBrepElementPerformer";
    export class DeclareProfileElementPerformer extends DeclareBrepElementPerformer {
        constructor();
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ProfileElement, parameters?: any): ProfileElement;
        computeProperty(context: DeclarePerformerContext, source: ProfileElement, target: ProfileElement): void;
        buildStructureReleation(context: DeclarePerformerContext, element: ProfileElement, recursive?: boolean): void;
    }
}
declare module "sk/rule/data/declare/performer/structure/DeclareProfilePointElementPerformer" {
    import { ProfilePointElement } from 'sk/data/family/structure/profile/element/ProfilePointElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclarePointElementPerformer } from "sk/rule/data/declare/performer/brep/geometric/DeclarePointElementPerformer";
    export class DeclareProfilePointElementPerformer extends DeclarePointElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: ProfilePointElement, parameters?: any): ProfilePointElement;
        computeProperty(context: DeclarePerformerContext, source: ProfilePointElement, target: ProfilePointElement): void;
    }
}
declare module "sk/rule/data/declare/performer/technology/DeclareTechnologyElementPerformer" {
    import { TechnologyComponentElement } from 'sk/data/family/element/component/TechnologyComponentElement';
    import { TechnologyElement } from 'sk/data/family/element/instance/TechnologyElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareContentElementPerformer } from "sk/rule/data/declare/performer/brep/DeclareContentElementPerformer";
    export class DeclareTechnologyElementPerformer extends DeclareContentElementPerformer {
        computeProperty(context: DeclarePerformerContext, source: TechnologyComponentElement, target: TechnologyElement): void;
    }
}
declare module "sk/rule/data/declare/performer/technology/DeclareTechnologyCavityElementPerformer" {
    import { TechnologyCavityComponentElement } from 'sk/data/family/database/technology/element/TechnologyCavityComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyCavityElement } from 'sk/data/scheme/database/technology/element/TechnologyCavityElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareTechnologyElementPerformer } from "sk/rule/data/declare/performer/technology/DeclareTechnologyElementPerformer";
    export class DeclareTechnologyCavityElementPerformer extends DeclareTechnologyElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: TechnologyCavityComponentElement, parameters?: any): TechnologyCavityElement;
        computeProperty(context: DeclarePerformerContext, source: TechnologyCavityComponentElement, target: TechnologyCavityElement): void;
    }
}
declare module "sk/rule/data/declare/performer/technology/DeclareTechnologyGrooveElementPerformer" {
    import { TechnologyGrooveComponentElement } from 'sk/data/family/database/technology/element/TechnologyGrooveComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyGrooveElement } from 'sk/data/scheme/database/technology/element/TechnologyGrooveElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareTechnologyElementPerformer } from "sk/rule/data/declare/performer/technology/DeclareTechnologyElementPerformer";
    export class DeclareTechnologyGrooveElementPerformer extends DeclareTechnologyElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: TechnologyGrooveComponentElement, parameters?: any): TechnologyGrooveElement;
        computeProperty(context: DeclarePerformerContext, source: TechnologyGrooveComponentElement, target: TechnologyGrooveElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: TechnologyGrooveElement, target: TechnologyGrooveElement): void;
        checkValid(context: DeclarePerformerContext, target: TechnologyGrooveElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/technology/DeclareTechnologyHoleElementPerformer" {
    import { TechnologyHoleComponentElement } from 'sk/data/family/database/technology/element/TechnologyHoleComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyHoleElement } from 'sk/data/scheme/database/technology/element/TechnologyHoleElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareTechnologyElementPerformer } from "sk/rule/data/declare/performer/technology/DeclareTechnologyElementPerformer";
    export class DeclareTechnologyHoleElementPerformer extends DeclareTechnologyElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: TechnologyHoleComponentElement, parameters?: any): TechnologyHoleElement;
        computeProperty(context: DeclarePerformerContext, source: TechnologyHoleComponentElement, target: TechnologyHoleElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: TechnologyHoleElement, target: TechnologyHoleElement): void;
        checkValid(context: DeclarePerformerContext, target: TechnologyHoleElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/technology/DeclareTechnologyMillingElementPerformer" {
    import { TechnologyMillingComponentElement } from 'sk/data/family/database/technology/element/TechnologyMillingComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyMillingElement } from 'sk/data/scheme/database/technology/element/TechnologyMillingElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareTechnologyElementPerformer } from "sk/rule/data/declare/performer/technology/DeclareTechnologyElementPerformer";
    export class DeclareTechnologyMillingElementPerformer extends DeclareTechnologyElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: TechnologyMillingComponentElement, parameters?: any): TechnologyMillingElement;
        computeProperty(context: DeclarePerformerContext, source: TechnologyMillingComponentElement, target: TechnologyMillingElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: TechnologyMillingElement, target: TechnologyMillingElement): void;
        checkValid(context: DeclarePerformerContext, target: TechnologyMillingElement): boolean;
    }
}
declare module "sk/rule/data/declare/performer/technology/DeclareTechnologyMillingTrackElementPerformer" {
    import { TechnologyMillingTrackComponentElement } from 'sk/data/family/database/technology/element/TechnologyMillingTrackComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyMillingTrackElement } from 'sk/data/scheme/database/technology/element/TechnologyMillingTrackElement';
    import { DeclarePerformerContext } from 'sk/data/scheme/performer/element/DeclarePerformerContext';
    import { DeclareTechnologyElementPerformer } from "sk/rule/data/declare/performer/technology/DeclareTechnologyElementPerformer";
    export class DeclareTechnologyMillingTrackElementPerformer extends DeclareTechnologyElementPerformer {
        createElement(context: DeclarePerformerContext, container: NestElement, reference: TechnologyMillingTrackComponentElement, parameters?: any): TechnologyMillingTrackElement;
        computeProperty(context: DeclarePerformerContext, source: TechnologyMillingTrackComponentElement, target: TechnologyMillingTrackElement): void;
        buildStructureAfter(context: DeclarePerformerContext, source: TechnologyMillingTrackElement, target: TechnologyMillingTrackElement): void;
    }
}
declare module "sk/rule/data/family/performer/FamilyNestElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformer } from 'sk/data/family/performer/element/ElementPerformer';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    export class NestElementCache extends ElementCache {
        statusConfigure: boolean;
        statusCondition: boolean;
    }
    export class FamilyNestElementPerformer extends ElementPerformer {
        computeCondition(context: ElementPerformerContext, element: NestElement, node: DataNode, parameters?: any): ResultEnum;
        computeStructureShapeAsync(context: ElementPerformerContext, element: Element, node: DataNode): Promise<ResultObject>;
        computeStructureRuleAsync(context: ElementPerformerContext, element: Element, node: DataNode): Promise<ResultObject>;
        computeStructureBefore(context: ElementPerformerContext, element: Element, node: DataNode): ResultEnum;
        computeStructureChildren(context: ElementPerformerContext, element: Element, node: DataNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: Element, node: DataNode): ResultEnum;
        computeStructure(context: ElementPerformerContext, element: NestElement, node: DataNode): ResultEnum;
        computeStructureChildrenAsync(context: ElementPerformerContext, element: Element, node: DataNode): Promise<ElementPerformerResult>;
        computeStructureAsync(context: ElementPerformerContext, element: NestElement, node: DataNode, parameters?: any): Promise<ElementPerformerResult>;
    }
}
declare module "sk/rule/data/familyrule/assembly/AssemblyFloorRuleOutline" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class AssemblyFloorRuleOutline {
        static plankTailor(outline: Array<Vector2>, plank: {
            position: Vector2;
            size: Vector2;
        }): Array<{
            point: Vector2;
            isOrigin: boolean;
            isOutline: boolean;
        }>;
        static pointAndPolygon(point: Vector2, polygon: Array<Vector2>): number;
        private static tailor;
    }
}
declare module "sk/rule/data/familyrule/assembly/AssemblyFloorRuleUtil" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    export type AssemblyFloorRuleInput = {
        plank: {
            plankEdgeToWallDis: number;
            plankGap: number;
            plankMinLength: number;
            plankMinWidth: number;
            plankThickness: number;
            plankLength: number;
            plankWidth: number;
        };
        hole: {
            holeToPlankEdgeDis: number;
            addHoleMinDis: number;
            holeRadius: number;
            holeRuleA: string;
            holeRuleB: string;
        };
        layout: {
            layoutPosition: Vector3;
            layoutDirect: number;
            floorArea: AssFloorArea;
        };
    };
    export enum AreaType {
    }
    export enum LayoutDirect {
        DIR_X_Y = 0,
        DIR_NX_Y = 1,
        DIR_NX_NY = 2,
        DIR_X_NY = 3
    }
    export class AssFloorArea {
        areaId: string;
        areaType: AreaType;
        position: Vector3;
        size: Vector3;
        araePolygon: Array<LineCurve2d>;
        deepth: number;
        layoutPosition: Vector3;
        layoutDirect: LayoutDirect;
        subArea: Array<AssFloorArea>;
        doorHole: DoorHole;
    }
    export class DoorHole {
        doorHoleId: string;
        doorHoleCenter: Vector3;
        doorHoleWidth: number;
        relatedAreaId: Array<string>;
    }
    export class AssFloorPlank {
        position: Vector3;
        size: Vector3;
        plankEdges: Array<AssEdge>;
        holesPoint: Array<Vector3>;
        boltPoint: Array<Vector3>;
        holeRadius: number;
        holeRule: string;
        isNormal: boolean;
    }
    export class AssEdge {
        isClosedWall: boolean;
        edgeCurve: Curve2d;
    }
    export class AssemblyFloorRuleUtil {
        static compute(input: AssemblyFloorRuleInput): Array<AssFloorPlank>;
        private static caculatePlankFromArea;
        private static createPlank;
        private static createPlankAssEdge;
        static createHoles(plank: AssFloorPlank, rulePara: AssemblyFloorRuleInput): void;
        static adjustHolePosition(holePointArr: Array<Vector3>, plank: AssFloorPlank, edgeDis: number): void;
        private static caculateHolePoint;
        private static caculateHoleDis;
        private static isPointOnSegment;
        private static calculateLength;
    }
}
declare module "sk/rule/data/familyrule/bathroom/BathroomCeilingRuleUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class CeilingRuleInput {
        ceilingFace: CeilingFace;
        edgeArr: EdgeStruct[];
        plankInfo: PlankInfo;
        menholeInfo: MenHoleInfo;
    }
    export class CeilingRuleInput530 {
        ceilingContiner: CeilingContiner;
        plankInfo: PlankInfo;
        menholeInfo: MenHoleInfo;
    }
    export class PlankInfo {
        maxLength: number;
        maxWidth: number;
        minWidth: number;
        standardWidth: number;
        standardThickness: number;
        plankGap: number;
    }
    export class EdgeStruct {
        has: boolean;
        disToO: number;
        length: number;
    }
    export class CeilingFace {
        offset: Vector2;
        size: Vector3;
        edgeGap: number;
        direct: string;
        flagDW: number;
    }
    export class CeilingContiner {
        size: Vector3;
        edgeGap: number;
        direct: string;
        flagDW: number;
    }
    export class MenHoleInfo {
        holePosition: Vector3;
        holeLength: number;
        holeToEdgeDis: number;
        minWidthHasHole: number;
    }
    export class CeilingRuleOutput {
        edgeArr: EdgeStruct[];
        position: Vector3;
        size: Vector3;
        boxSize: Vector3;
        rotationZ: number;
    }
    export class CeilingRuleOutput530 {
        position: Vector3;
        size: Vector3;
        rotationZ: number;
    }
    export class BathroomCeilingRuleUtil {
        private static edgeWidth;
        static compute(input: any): Array<any>;
        private static compute630;
        private static compute530;
        private static calculatePlankEdge;
        static calculateOneEdge(plank: CeilingRuleOutput, containerOneEdge: EdgeStruct): EdgeStruct;
        private static calculateCeilingHasHole;
        private static calculateLength;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation/BathroomCreationRuleError" {
    export class BathroomCreationRuleErrorEnum {
        static warning: {
            warning1: number;
            warning2: number;
            warning3: number;
            warning4: number;
            warning5: number;
            warning6: number;
            warning7: number;
            warning8: number;
            warning9: string;
            warning10: string;
        };
        static error: {
            error1: number;
            error2: number;
            error3: number;
            error4: number;
            error5: number;
            error6: number;
            error7: number;
            error8: number;
            error9: number;
            error10: number;
            error11: number;
            error12: number;
            error13: number;
            error14: number;
            error15: number;
            error16: string;
            error17: string;
        };
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export type BathroomCreationRuleInput830 = {
        type: number;
        isSameFloor: boolean;
        walls: Array<{
            beg: Vector2;
            end: Vector2;
            contraction: number;
            wallThickness: number;
        }>;
        door: {
            wallIndex: number;
            position: Vector2;
            baseZ: number;
            size: Vector2;
            wallWidth: number;
        };
        window: {
            wallIndex: number;
            position: Vector2;
            baseZ: number;
            size: Vector2;
            innerDepth: number;
            wallWidth: number;
        };
        pipe: {
            position: Vector2;
            size: Vector2;
            contraction: number;
        };
        pit: {
            center: Vector2;
            range: number;
            backWallContraction: number;
            toBackWallDistanceMin: number;
            toHardCompleteMin: number;
            toSoftCompleteMin: number;
        };
        wetFloorSizes: {
            x: Array<number>;
            yMax: number;
            yMin: number;
        };
        dryFloorSizeRange: {
            minx: number;
            maxx: number;
            miny: number;
            maxy: number;
        };
        wallThickness: number;
        tileThickness: number;
        floorEdgeThickness: number;
        ceilingEdgeThickness: number;
        wallMinWidth: number;
        completeMod: number;
        doorWallContractionMax: number;
        bottomZ: number;
        topZ: number;
        doorToFloor: number;
        minFloorToBottom: number;
        floorHeight: number;
        floorEdgeHeight: number;
        ceilingHeight: number;
        ceilingBaseHeight: number;
        wallHeight: Array<number>;
        cabinet: {
            backWallContraction: number;
        };
    };
}
declare module "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export type BathroomCreationRuleOutput830 = {
        error: any;
        room: BathroomCreationRuleRoomOutput;
        range: BathroomCreationRuleRangeOutput;
        component: BathroomCreationRuleComponentOutput;
        height: BathroomCreationRuleHeightOutput;
    };
    export type BathroomCreationRuleComponentOutput = {
        walls: Array<BathroomCreationRuleComponentWall>;
        floor: {
            wet1: BathroomCreationRuleRange;
            dry2: BathroomCreationRuleRange;
            dry3: BathroomCreationRuleRange;
        };
        ceiling: {
            wet1: BathroomCreationRuleComponentCeiling;
            dry2: BathroomCreationRuleComponentCeiling;
            dry3: BathroomCreationRuleComponentCeiling;
        };
    };
    export type BathroomCreationRuleRoomOutput = {
        translate: Vector2;
        rotationZ: number;
        isMirrorY: boolean;
        origin: BathroomCreationRuleRange;
        complete: BathroomCreationRuleRange;
        door: {
            position: Vector2;
            wallIndex: number;
        };
        pit: {
            originPosition: Vector2;
            currentPosition: Vector2;
        };
        pipe: BathroomCreationRuleRange;
    };
    export type BathroomCreationRuleRangeOutput = {
        wet1: BathroomCreationRuleRange;
        dry2: BathroomCreationRuleRange;
        dry3: BathroomCreationRuleRange;
    };
    export type BathroomCreationRuleHeightOutput = {
        floorComplete: number;
        ceilingComplete: number;
    };
    export type BathroomCreationRuleComponentCeiling = {
        position: Vector2;
        size: Vector2;
        plank: {
            offset: Vector2;
            size: Vector2;
        };
        edges: {
            up: {
                hasEdge: boolean;
                offset: {
                    start: number;
                    end: number;
                };
            };
            down: {
                hasEdge: boolean;
                offset: {
                    start: number;
                    end: number;
                };
            };
            left: {
                hasEdge: boolean;
                offset: {
                    start: number;
                    end: number;
                };
            };
            right: {
                hasEdge: boolean;
                offset: {
                    start: number;
                    end: number;
                };
            };
        };
    };
    export type BathroomCreationRuleComponentWall = {
        position: Vector2;
        size: Vector2;
        rotationZ: number;
        code: string;
        contraction: number;
        isWallWet: {
            beg: boolean;
            end: boolean;
        };
        isOuterCorner: {
            beg: boolean;
            end: boolean;
        };
        hasCabinet: {
            beg: boolean;
            end: boolean;
        };
    };
    export type BathroomCreationRuleRange = {
        position: Vector2;
        size: Vector2;
    };
}
declare module "sk/rule/data/familyrule/bathroom/creation830/component/BathroomCreationRuleComponentAssistUtil" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleComponentCeiling, BathroomCreationRuleComponentWall, BathroomCreationRuleOutput830, BathroomCreationRuleRange } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleComponentAssistUtil {
        static getWall(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830, region: number, code: string): BathroomCreationRuleComponentWall;
        static getFloor(input: BathroomCreationRuleInput830, range: BathroomCreationRuleRange): BathroomCreationRuleRange;
        static getCeiling(input: BathroomCreationRuleInput830, range: BathroomCreationRuleRange): BathroomCreationRuleComponentCeiling;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/component/BathroomCreationRuleComponent1Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleComponent1Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/component/BathroomCreationRuleComponent3Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleComponent3Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
        private static setWalls;
        private static setCeiling;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/component/BathroomCreationRuleComponent2Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleComponent2Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/component/BathroomCreationRuleComponent4Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleComponent4Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/range/BathroomCreationRuleRange1Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleRange1Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
        private static computexy;
        private static computePipe;
        private static computeCabinet;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/range/BathroomCreationRuleRange3Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleRange3Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
        private static computey;
        private static computex;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/range/BathroomCreationRuleRange2Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleRange2Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/range/BathroomCreationRuleRange4Util" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleRange4Util {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
        private static computex12;
        private static computex3;
        private static computey;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/room/BathroomCreationRuleHeightUtil" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleHeightUtil {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
        private static computeComplete;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/room/BathroomCreationRuleRoomUtil" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleRoomUtil {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): boolean;
        private static computeOutput;
        private static computeDoor;
        private static computeBath;
        private static initOutput;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/room/BathroomCreationRuleYMirrorUtil" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleYMirrorUtil {
        static compute(input: BathroomCreationRuleInput830, output: BathroomCreationRuleOutput830): void;
        private static computeMirrorY;
        private static computeTranslation;
    }
}
declare module "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleUtil830" {
    import { BathroomCreationRuleInput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleInput830";
    import { BathroomCreationRuleOutput830 } from "sk/rule/data/familyrule/bathroom/creation830/BathroomCreationRuleOutput830";
    export class BathroomCreationRuleUtil830 {
        static compute(input: BathroomCreationRuleInput830): BathroomCreationRuleOutput830;
    }
}
declare module "sk/rule/data/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/rule/data/molding/AreaGraphic3dConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { AreaGraphic3dStructure } from 'sk/data/family/molding/instance/AreaGraphic3dStructure';
    export class AreaGraphic3dConverter extends MoldingGraphics3dConverter {
        constructor();
        createStructure(): AreaGraphic3dStructure;
        computeStructure(context: MoldingDataContext, node: AreaPolygonNode, target?: AreaGraphic3dStructure, options?: MoldingGeometricOptions): AreaGraphic3dStructure;
    }
}
declare module "sk/rule/data/molding/AreaOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    export class AreaOutline3dConverter extends MoldingOutline3dConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: AreaPolygonNode, target?: MoldingOutline3dStructure, options?: MoldingOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/AssembleLevelingCeilingGraphic3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { AssembleLevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/AssembleLevelingCeilingNode';
    export class AssembleLevelingCeilingGraphic3dConverter extends MoldingGraphics3dConverter {
        protected structure: MoldingGeometryStructure;
        constructor();
        process(context: MoldingContext, node: AssembleLevelingCeilingNode, target?: MoldingGeometryStructure, options?: MoldingGeometricOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/AssembleLevelingFloorGraphic3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { AssembleLevelingFloorNode } from 'sk/data/scheme/database/pattern/node/AssembleLevelingFloorNode';
    export class AssembleLevelingFloorGraphic3dConverter extends MoldingGraphics3dConverter {
        protected structure: MoldingGeometryStructure;
        constructor();
        process(context: MoldingContext, node: AssembleLevelingFloorNode, target?: MoldingGeometryStructure, options?: MoldingGeometricOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/BathroomGraphic3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { BathroomNode } from 'sk/data/scheme/database/pattern/node/BathroomNode';
    export class BathroomGraphic3dConverter extends MoldingGraphics3dConverter {
        protected structure: MoldingGeometryStructure;
        constructor();
        process(context: MoldingContext, node: BathroomNode, target?: MoldingGeometryStructure, options?: MoldingGeometricOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/ContainerCollision3dConverter" {
    import { MoldingCollision3dConverter } from 'foundation/data/common/model/molding/MoldingCollision3dConverter';
    import { MoldingCollision3dOptions } from 'foundation/data/common/model/molding/MoldingCollision3dOptions';
    import { MoldingCollision3dStructure } from 'foundation/data/common/model/molding/MoldingCollision3dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    export class ContainerCollision3dConverter extends MoldingCollision3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: ContainerNode, target?: MoldingCollision3dStructure, options?: MoldingCollision3dOptions): MoldingCollision3dStructure;
    }
}
declare module "sk/rule/data/molding/ContainerOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline2dConverter } from 'foundation/data/common/model/molding/MoldingOutline2dConverter';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    export class ContainerOutline2dConverter extends MoldingOutline2dConverter {
        constructor();
        process(context: MoldingContext, node: ContainerNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/ContainerOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    export class ContainerOutline3dConverter extends MoldingOutline3dConverter {
        constructor();
        process(context: MoldingContext, node: ContainerNode, target?: MoldingOutline3dStructure, options?: MoldingOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/ContentGraphics3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    export class ContentGraphics3dConverter extends MoldingGraphics3dConverter {
        constructor();
        process(context: MoldingDataContext, content: any): ResultEnum;
    }
}
declare module "sk/rule/data/molding/CubeSurfaceGraphic3dStructure" {
    import { PolygonGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonGeometry';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    export class CubeSurfaceGraphic3dStructure extends MoldingGeometryStructure {
        node: any;
        directionCd: RelativeDirectionEnum;
        material: any;
        geometry: PolygonGeometry;
        color: string;
        constructor();
    }
}
declare module "sk/rule/data/molding/CubeGraphic3dStructure" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { CubeSurfaceGraphic3dStructure } from "sk/rule/data/molding/CubeSurfaceGraphic3dStructure";
    export class CubeGraphic3dStructure extends MoldingGeometryStructure {
        node: any;
        surfaces: Dictionary<CubeSurfaceGraphic3dStructure>;
        getSurfaceMaterial(directionCd: RelativeDirectionEnum): any;
        getSurfaceColor(directionCd: RelativeDirectionEnum): string;
        getSurfaceModeling(directionCd: RelativeDirectionEnum): CubeSurfaceGraphic3dStructure;
    }
}
declare module "sk/rule/data/molding/CubeGraphic3dConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { CubeGraphic3dStructure } from "sk/rule/data/molding/CubeGraphic3dStructure";
    import { CubeSurfaceGraphic3dStructure } from "sk/rule/data/molding/CubeSurfaceGraphic3dStructure";
    export class CubeGraphic3dConverter extends MoldingGraphics3dConverter {
        getSurfaceCds(node: any): Array<RelativeDirectionEnum>;
        computeStrcuture(context: MoldingDataContext, node: any, target?: CubeGraphic3dStructure): CubeGraphic3dStructure;
        computeSurfaceModeling(node: any, structure: CubeGraphic3dStructure): void;
        computeSurfaceCd(directionCd: RelativeDirectionEnum, surface: CubeSurfaceGraphic3dStructure): void;
    }
}
declare module "sk/rule/data/molding/EdgeSurfaceGraphic3dConverter" {
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { PointStructure } from 'foundation/data/common/structure/geometric/PointStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class EdgeSurfaceGraphic3dConverter extends MoldingGraphics3dConverter {
        static BORDER: number;
        constructor();
        computeStrcuture(context: MoldingDataContext, node: PlaneNode, target?: any): any;
        computeSurfaceModeling(node: PlaneNode, structure: any): void;
        testHole(polygon: Polygon): void;
        testTwoPoints(points: Array<PointStructure>): Array<PointStructure>;
    }
}
declare module "sk/rule/data/molding/FamilyInstanceCollision2dConverter" {
    import { MoldingCollision2dConverter } from 'foundation/data/common/model/molding/MoldingCollision2dConverter';
    import { MoldingCollision2dOptions } from 'foundation/data/common/model/molding/MoldingCollision2dOptions';
    import { MoldingCollision2dStructure } from 'foundation/data/common/model/molding/MoldingCollision2dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class FamilyInstanceCollision2dConverter extends MoldingCollision2dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: FamilyInstanceNode, target?: MoldingCollision2dStructure, options?: MoldingCollision2dOptions): MoldingCollision2dStructure;
    }
}
declare module "sk/rule/data/molding/FamilyInstanceCollision3dConverter" {
    import { MoldingCollision3dConverter } from 'foundation/data/common/model/molding/MoldingCollision3dConverter';
    import { MoldingCollision3dOptions } from 'foundation/data/common/model/molding/MoldingCollision3dOptions';
    import { MoldingCollision3dStructure } from 'foundation/data/common/model/molding/MoldingCollision3dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class FamilyInstanceCollision3dConverter extends MoldingCollision3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: FamilyInstanceNode, target?: MoldingCollision3dStructure, options?: MoldingCollision3dOptions): MoldingCollision3dStructure;
    }
}
declare module "sk/rule/data/molding/FamilyInstanceOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline2dConverter } from 'foundation/data/common/model/molding/MoldingOutline2dConverter';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class FamilyInstanceOutline2dConverter extends MoldingOutline2dConverter {
        constructor();
        process(context: MoldingContext, node: FamilyInstanceNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/FamilyInstanceOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export class FamilyInstanceOutline3dConverter extends MoldingOutline3dConverter {
        constructor();
        process(context: MoldingContext, node: FamilyInstanceNode, target?: MoldingOutline3dStructure, options?: MoldingOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/BeamCollision3dConverter" {
    import { FamilyInstanceCollision3dConverter } from "sk/rule/data/molding/FamilyInstanceCollision3dConverter";
    export class BeamNodeCollision3dConverter extends FamilyInstanceCollision3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/BeamGraphics3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    export class BeamGraphics3dConverter extends MoldingGraphics3dConverter {
        constructor();
        process(context: MoldingDataContext, content: any): ResultEnum;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/BeamOutline2dConverter" {
    import { FamilyInstanceOutline2dConverter } from "sk/rule/data/molding/FamilyInstanceOutline2dConverter";
    export class BeamOutline2dConverter extends FamilyInstanceOutline2dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/BeamOutline3dConverter" {
    import { FamilyInstanceOutline3dConverter } from "sk/rule/data/molding/FamilyInstanceOutline3dConverter";
    export class BeamOutline3dConverter extends FamilyInstanceOutline3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/CeilingSurfaceGraphic3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { CeilingGraphic3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/CeilingGraphic3dStructure';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    export class CeilingSurfaceGraphic3dConverter extends MoldingGraphics3dConverter {
        createStructure(): CeilingGraphic3dStructure;
        process(context: MoldingDataContext, node: CeilingSurfaceNode, target?: CeilingGraphic3dStructure): ResultEnum;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/ColumnCollision3dConverter" {
    import { FamilyInstanceCollision3dConverter } from "sk/rule/data/molding/FamilyInstanceCollision3dConverter";
    export class ColumnCollision3dConverter extends FamilyInstanceCollision3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/ColumnGraphics3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { ColumnNode } from 'sk/data/scheme/database/floorplan/model/ColumnNode';
    export class ColumnGraphics3dConverter extends MoldingGraphics3dConverter {
        constructor();
        process(context: MoldingDataContext, content: ColumnNode): ResultEnum;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/ColumnOutline2dConverter" {
    import { FamilyInstanceOutline2dConverter } from "sk/rule/data/molding/FamilyInstanceOutline2dConverter";
    export class ColumnOutline2dConverter extends FamilyInstanceOutline2dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/ColumnOutline3dConverter" {
    import { FamilyInstanceOutline3dConverter } from "sk/rule/data/molding/FamilyInstanceOutline3dConverter";
    export class ColumnOutline3dConverter extends FamilyInstanceOutline3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/CowallGraphics3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PolygonEdgeGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonEdgeGeometry';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { WallSurfaceTypeEnum } from 'sk/data/family/database/architecture/enumeration/WallSurfaceTypeEnum';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { CowallGeometry } from 'sk/data/scheme/database/floorplan/model/geometry/CowallGeometry';
    import { CowallGraphic3dOptions } from 'sk/data/scheme/database/floorplan/model/molding/CowallGraphic3dOptions';
    import { CowallGraphic3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/CowallGraphic3dStructure';
    import { WallSurfaceGeometryInfo } from 'sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil';
    import { CowallNode } from 'sk/data/scheme/database/floorplan/model/CowallNode';
    import { WallJoinnerNode } from 'sk/data/scheme/database/floorplan/model/WallJoinnerNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    export class CowallGraphics3dConverter extends MoldingGraphics3dConverter {
        protected _node: CowallNode;
        protected _geometry: CowallGeometry;
        protected _isShowSide: boolean;
        protected _displayHeight: number;
        protected _displayHeightMax: number;
        protected _innerOpeningDatas: any;
        protected _outerOpeningDatas: any;
        protected _rangeBox: Box3;
        protected _structure: CowallGraphic3dStructure;
        constructor();
        createStructure(): CowallGraphic3dStructure;
        protected getHeight3d(halfMode: boolean, height?: number): any;
        private get ceilingThickness();
        private get floorThickness();
        protected checkSideSlope(joinner: WallJoinnerNode, points: Vector2[], rotation: number, cowall: CowallNode): any;
        protected getSidePathsSlice(points: Array<Vector2>, start: number, end: number): Array<Vector2>;
        protected getSidePathsCheck(surfaceCd: WallSurfaceTypeEnum, cowall: CowallNode): boolean;
        protected setGeometrySideGeometry(point1: Vector3, point2: Vector3, bottom: number, top: number, surfaceCd?: WallSurfaceTypeEnum): PolygonEdgeGeometry;
        protected constructSideGeometry(surfaceCd: WallSurfaceTypeEnum, sidePaths: any): void;
        protected splitPathByLine(point1: Value2, point2: Value2, points: Array<Value2>): any;
        protected joinnerFaceCheck(joinner: WallJoinnerNode, entity: CowallNode): number;
        protected getSidePaths(): any;
        protected setGeometrySurfaceSide(): void;
        protected setGeometrySurfaceLoop(box: Box3, points: Array<Vector2>, options?: any): Array<any>;
        protected constructLoopGeometry(box: Box3): void;
        protected getSurfaceGeometry(surfaceCd: WallSurfaceTypeEnum): PolygonEdgeGeometry;
        protected getMeshSpaceOutline(opening: OpeningNode): Vector2[];
        protected setGeometrySurfaceTop(points: Array<Vector3>, height3d: number): PolygonEdgeGeometry;
        computeMeshGeometry(): void;
        protected getSameSurfaceOpeningDatas(surface: WallSurfaceNode): any;
        protected setMergedGeometrySurfaceMaster(surfaceCd: WallSurfaceTypeEnum, openingDatas: any, polygonInfos: WallSurfaceGeometryInfo[], edgeSize: number): any;
        protected setGeometrySurfaceMaster(surfaceCd: WallSurfaceTypeEnum, openingDatas: any, startPoint: Vector3, endPoint: Vector3, height: number, edgeSize: number, floorHeight?: number): PolygonEdgeGeometry;
        computeSurfaceMeshGeometry(): void;
        process(context: MoldingDataContext, node: CowallNode, target?: CowallGraphic3dStructure, options?: CowallGraphic3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/FloorSurfaceGraphic3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { FloorGraphic3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/FloorGraphic3dStructure';
    import { FloorSurfaceNode } from 'sk/data/scheme/database/floorplan/model/FloorSurfaceNode';
    export class FloorSurfaceGraphic3dConverter extends MoldingGraphics3dConverter {
        createStructure(): FloorGraphic3dStructure;
        process(context: MoldingDataContext, node: FloorSurfaceNode, target?: FloorGraphic3dStructure): ResultEnum;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/WallGraphics3dConverter" {
    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 { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WallGraphic3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/WallGraphic3dStructure';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    export type SurfaceInfo = {
        buff: BufferGeometry;
        surface: Surface;
        face: BrepFace;
    };
    export class WallGraphics3dConverter extends MoldingGraphics3dConverter {
        node: WallNode;
        brep: BrepBody;
        buffers: Array<SurfaceInfo>;
        constructor();
        createStructure(): WallGraphic3dStructure;
        getOpenings(node: WallNode, result?: Array<OpeningNode>): Array<OpeningNode>;
        computeStructure(context: MoldingDataContext, node: WallNode, target?: WallGraphic3dStructure, options?: MoldingGeometricOptions): WallGraphic3dStructure;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/WallSurfaceSpatialGraphics3dConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { WallSurfaceSpatialGraphic3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/WallSurfaceSpatialGraphic3dStructure';
    import { WallSurfaceSpatialNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode';
    export class WallSurfaceSpatialGraphics3dConverter extends MoldingGraphics3dConverter {
        node: WallSurfaceSpatialNode;
        createStructure(): WallSurfaceSpatialGraphic3dStructure;
        computeStructure(context: MoldingDataContext, node: WallSurfaceSpatialNode, target?: WallSurfaceSpatialGraphic3dStructure, options?: MoldingGeometricOptions): WallSurfaceSpatialGraphic3dStructure;
    }
}
declare module "sk/rule/data/molding/floorplan/graphics/WallSurfaceSpatialOutline3dConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { WallSurfaceSpatialOutline3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/WallSurfaceSpatialOutline3dStructure';
    import { WallSurfaceSpatialNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode';
    export class WallSurfaceSpatialOutline3dConverter extends MoldingOutline3dConverter {
        node: WallSurfaceSpatialNode;
        createStructure(): WallSurfaceSpatialOutline3dStructure;
        computeStructure(context: MoldingDataContext, node: WallSurfaceSpatialNode, target?: WallSurfaceSpatialOutline3dStructure, options?: MoldingOutline3dOptions): WallSurfaceSpatialOutline3dStructure;
    }
}
declare module "sk/rule/data/molding/floorplan/render/CeilingSurfaceRenderConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingRenderConverter } from 'foundation/data/common/model/molding/MoldingRenderConverter';
    import { CeilingGraphic3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/CeilingGraphic3dStructure';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    export class CeilingSurfaceRenderConverter extends MoldingRenderConverter {
        createStructure(): CeilingGraphic3dStructure;
        process(context: MoldingDataContext, node: CeilingSurfaceNode, target?: CeilingGraphic3dStructure): ResultEnum;
    }
}
declare module "sk/rule/data/molding/floorplan/render/CowallRenderConverter" {
    import { CowallGraphics3dConverter } from "sk/rule/data/molding/floorplan/graphics/CowallGraphics3dConverter";
    export class CowallRenderConverter extends CowallGraphics3dConverter {
    }
}
declare module "sk/rule/data/molding/floorplan/render/FloorSurfaceRenderConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingRenderConverter } from 'foundation/data/common/model/molding/MoldingRenderConverter';
    import { FloorGraphic3dStructure } from 'sk/data/scheme/database/floorplan/model/molding/FloorGraphic3dStructure';
    import { FloorSurfaceNode } from 'sk/data/scheme/database/floorplan/model/FloorSurfaceNode';
    export class FloorSurfaceRenderConverter extends MoldingRenderConverter {
        createStructure(): FloorGraphic3dStructure;
        process(context: MoldingDataContext, node: FloorSurfaceNode, target?: FloorGraphic3dStructure): ResultEnum;
    }
}
declare module "sk/rule/data/molding/furniture/PlaneGraphic3dConverter" {
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { PointStructure } from 'foundation/data/common/structure/geometric/PointStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneGraphic3dConverter extends MoldingGraphics3dConverter {
        static BORDER: number;
        constructor();
        computeStrcuture(context: MoldingDataContext, node: PlaneNode, target?: any): any;
        computeSurfaceModeling(node: PlaneNode, structure: any): void;
        testHole(polygon: Polygon): void;
        testTwoPoints(points: Array<PointStructure>): Array<PointStructure>;
        computeFrontSurface(node: PlaneNode, structure: any): void;
        computeBackSurface(node: PlaneNode, structure: any): void;
        computeSurface(node: PlaneNode, surfaceStructure: any, isFront: boolean): void;
        computeEdgesSurface(node: PlaneNode, structure: any): void;
    }
}
declare module "sk/rule/data/molding/furniture/PlaneSurfaceGraphic3dConverter" {
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { PointStructure } from 'foundation/data/common/structure/geometric/PointStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneSurfaceGraphic3dConverter extends MoldingGraphics3dConverter {
        static BORDER: number;
        constructor();
        computeStrcuture(context: MoldingDataContext, node: PlaneNode, structure: any): any;
        computeSurfaceModeling(node: PlaneNode, structure: any): void;
        testHole(polygon: Polygon): void;
        testTwoPoints(points: Array<PointStructure>): Array<PointStructure>;
        computeFrontSurface(node: PlaneNode, structure: any): void;
        computeSurface(node: PlaneNode, surfaceStructure: any, isFront: boolean): void;
    }
}
declare module "sk/rule/data/molding/GroupOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline2dConverter } from 'foundation/data/common/model/molding/MoldingOutline2dConverter';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    export class GroupOutline2dConverter extends MoldingOutline2dConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: GroupNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/HardwareBrepConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingBrepConverter } from 'foundation/data/common/model/molding/MoldingBrepConverter';
    import { MoldingBrepOptions } from 'foundation/data/common/model/molding/MoldingBrepOptions';
    import { MoldingBrepStructure } from 'foundation/data/common/model/molding/MoldingBrepStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    export class HardwareBrepConverter extends MoldingBrepConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: HardwareNode, target?: MoldingBrepStructure, options?: MoldingBrepOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/HardwareGraphic3dConverter" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    export class HardwareGraphic3dConverter extends MoldingGraphics3dConverter {
        centerMatrix: Matrix4;
        parentMatrix: Matrix4;
        constructor();
        computeStructure(context: MoldingDataContext, hardware: HardwareNode, target?: MoldingGeometryStructure): MoldingGeometryStructure;
    }
}
declare module "sk/rule/data/molding/HardwareOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline2dConverter } from 'foundation/data/common/model/molding/MoldingOutline2dConverter';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    export class HardwareOutline2dConverter extends MoldingOutline2dConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: HardwareNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/LayoutGraphic3dConverter" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Single2dSurface } from 'foundation/runtime/geometry/Surface';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { SurfaceOption } from 'foundation/runtime/graphics/molding/SurfaceMoldingUtil';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { LayoutNode } from 'sk/data/family/model/instance/LayoutNode';
    import { LayoutTileNode } from 'sk/data/family/model/instance/LayoutTileNode';
    import { LayoutGraphic3dStructure } from 'sk/data/family/molding/instance/LayoutGraphic3dStructure';
    export class LayoutGraphic3dConverter extends MoldingGraphics3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: LayoutNode, target?: LayoutGraphic3dStructure, options?: MoldingGeometricOptions): LayoutGraphic3dStructure;
        protected createTileGeometry(node: LayoutNode, tiles: LayoutTileNode[], structure: LayoutGraphic3dStructure): void;
        protected createLayoutGeometry(node: LayoutNode, structure: LayoutGraphic3dStructure): void;
        protected getHoles(node: LayoutNode): Array<Single2dSurface>;
        createSectionSurfaceByPoints(points: Vector2[]): SectionSurface;
        protected getPolygonSurface(node: LayoutNode, points: Vector2[], holes?: any, surfaceOption?: SurfaceOption): BufferGeometry;
        protected testIsFloorNode(node: LayoutNode): boolean;
    }
}
declare module "sk/rule/data/molding/LevelingCeilingGraphic3dConverter" {
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { LevelingCeilingGraphic3dStructure } from 'sk/data/family/molding/instance/LevelingCeilingGraphic3dStructure';
    export class LevelingCeilingGraphic3dConverter extends MoldingGraphics3dConverter {
        constructor();
        createStructure(): LevelingCeilingGraphic3dStructure;
    }
}
declare module "sk/rule/data/rule/levelinglayout/ArrangeNumberTool" {
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    export type RefLine = {
        type: string;
        hole?: FamilyInstanceNode;
        min: number;
        max: number;
        isPositive?: boolean;
    };
    export class ArrangeNumberTool {
        private params;
        private reflines;
        private remain;
        private current;
        private vertical;
        private offset;
        private deadTries;
        private isDeadTry;
        private isHardTry;
        numbers: Array<number>;
        standard: number;
        tryNumbers: number[];
        tryIndex: number;
        gap: number;
        tryGap: number;
        tryGapMode: boolean;
        tryList: Array<number>;
        firstTryList: Array<number>;
        checkOffset: number;
        checkDirectionLineOffset: number;
        checkHoleInner: number;
        checkHoleOutter: number;
        checkSingleHole: boolean;
        tryFunction: Function;
        private isReverse;
        start: number;
        constructor(totalWidth: number, reflines: Array<RefLine>, offset: number, vertical: boolean, params: any, tryGap?: number, reverse?: boolean);
        arrangeNumbers(): number[];
        private splitIteratorStepString;
        private getTryConfig;
        private removeSameTry;
        private isInRange;
        private isInDirectionRange;
        private isInHoleSide;
        private isHoleIn;
        private checkReflines;
        private getTryList;
        private getNextTry;
        private getFirstTry;
        private changeCurrent;
        private popTry;
        private tryOne;
        private process;
    }
}
declare module "sk/rule/data/rule/levelinglayout/ReferenceLineCalculator" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { DrawingCodeEnum } from 'sk/data/family/enumeration/drawing/DrawingCodeEnum';
    export type ReferenceLineData = {
        drawingCodes: DrawingCodeEnum[];
        type: string;
        value: number;
        from: number;
        to: number;
    };
    export class ReferenceLineCalculator {
        points: Array<Value2>;
        private hLines;
        private vLines;
        private drawingCodes;
        private endToSide;
        private option;
        private range;
        constructor(points: Array<Value2>, drawingCodes: DrawingCodeEnum[], endToSide: boolean, range: {
            startX: number;
            startY: number;
            endX: number;
            endY: number;
        }, option?: {
            lineLength: number;
            hMaxGap: number;
            vMaxGap: number;
        });
        calculate(): Array<ReferenceLineData>;
        private getHLine;
        private getVLine;
        private addLength;
        private isNearly;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutData" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { ReferenceLineData } from "sk/rule/data/rule/levelinglayout/ReferenceLineCalculator";
    export class LayoutLayerTypeEnum {
        static Base: string;
        static Surface: string;
        static Decorate: string;
        static Leveler: string;
        static Survey: string;
    }
    export class ParameterInfoData {
    }
    export class LayoutLayerData {
        type: LayoutLayerTypeEnum;
        leftOffset: number;
        rightOffset: number;
        topOffset: number;
        bottomOffset: number;
        depth: number;
    }
    export class LayoutHoleData {
    }
    export class LayoutDoorData extends LayoutHoleData {
    }
    export class LayoutWindowData extends LayoutHoleData {
        workSpaceLeft: number;
        workSpaceRight: number;
        workSpaceBottom: number;
        workSpaceTop: number;
    }
    export class LevelingLayoutDataOutput {
    }
    export class LevelingLayoutData {
        type: LevelingLayoutTypeEnum;
        position: Vector3;
        rotation: Vector3;
        area: AreaData;
        wallStartOffsetX: number;
        wallEndOffsetX: number;
        baseStartOffsetX: number;
        baseEndOffsetX: number;
        baseEndOffsetY: number;
        baseStartOffsetY: number;
        surfaceStartOffsetX: number;
        surfaceEndOffsetX: number;
        surfaceEndOffsetY: number;
        surfaceStartOffsetY: number;
        decorateStartOffsetX: number;
        decorateEndOffsetX: number;
        decorateEndOffsetY: number;
        decorateStartOffsetY: number;
        frontWallWorkspace: number;
        backWallWorkspace: number;
        baseScrews: Array<ScrewData>;
        surfaceScrews: Array<ScrewData>;
        quadratePipes: Array<QuadratePipeData>;
        windowStone: WindowStoneData;
        lines?: Array<ReferenceLineData>;
        leftQuadratePipeType?: QuadratePipeLayoutTypeEnum;
        rightQuadratePipeType?: QuadratePipeLayoutTypeEnum;
        lengthZ: number;
        layoutDirection: Vector3;
        layoutOption: LayoutOption;
        baseFlatLineInfos?: Array<{
            line: Array<number>;
            reverse: boolean;
            offset: number;
            height?: number;
        }>;
    }
    export class QuadratePipeLayoutTypeEnum {
        static NULL: string;
        static LEFT: string;
        static HASLEFT: string;
        static RIGHT: string;
        static HASRIGHT: string;
        static BOTH: string;
    }
    export class LayoutOption {
        survey: boolean;
        leverler: boolean;
        basePlank: boolean;
        surfacePlank: boolean;
        decorate: boolean;
        windowStone: boolean;
        quadratePipe: boolean;
        optionManual: boolean;
        layers: Layers;
        constructor();
    }
    export enum LevelingLayoutTypeEnum {
        WALL = 1,
        FLOOR = 2,
        HOLE_INNER_TOP = 3,
        HOLE_INNER_LEFT = 4,
        HOLE_INNER_RIGHT = 5,
        HOLE_INNER_BOTTOM = 6,
        COLUMN_LEFT = 7,
        COLUMN_RIGHT = 8,
        COLUMN_CENTER = 9,
        WINDOW_INNER_BOTTOM = 10,
        DOOR_INNER_BOTTOM = 11,
        NULL = 12
    }
    export type LevelingLayoutParamers = {
        plankId: string;
        surfacePlankId?: string;
        decorateId: string;
        levellerId: string;
        strengthLevellerId?: string;
        boltId?: string;
        screwId?: string;
        nailId?: string;
        windowStoneId?: string;
        quadratePipeFamilyId?: string;
        quadratePipeLength?: number;
        emptySpaceDepth: number;
        plankWidth: number;
        plankHeight: number;
        horizontalGap: number;
        verticalGap: number;
        horizontalPlankGap: number;
        verticalPlankGap: number;
        levellerDiameter: number;
        plankInner: number;
        holeOutter: number;
        element: AssembleLevelingWallElement;
        levellerScrewDistance?: number;
        windowOptimize?: boolean;
        doorOptimize?: boolean;
        buildType: BuildStructureTypeEnum;
        layers: Layers;
        verticalSeam: number;
        horizontalSeam: number;
        verticalIteratorStep: string;
        horizontalIteratorStep: string;
        computeAll?: boolean;
        ability?: number;
    };
    export type Layers = {
        [key: string]: Layer;
    };
    export type Layer = {
        name: string;
        thickness: number;
    };
    export type AreaData = {
        idx: number;
        width: number;
        height: number;
        holes: HoleData[];
        subHoles: HoleData[];
        decorate?: DecorateData;
        reflines?: Array<RefLine>;
        columns?: Array<ColumnData>;
        surfaceColumns?: Array<ColumnData>;
    };
    export type ColumnData = {
        idx: number;
        x: number;
        width: number;
        height: number;
        holes: Array<HoleData>;
        planks?: Array<PlankData>;
        reflines?: Array<RefLine>;
        area: AreaData;
        isLeft: boolean;
        isRight: boolean;
        hasLeveller: boolean;
        innerLeft: number;
        innerRight: number;
        isSurface: boolean;
    };
    export type DecorateData = {
        width: number;
        height: number;
        polygon?: Array<Vector2>;
        x: number;
        y: number;
    };
    export type PlankData = {
        idx: number;
        y: number;
        wx: number;
        wy: number;
        width: number;
        height: number;
        column: ColumnData;
        isTop?: boolean;
        isRight?: boolean;
        innerLeft?: number;
        innerRight?: number;
        innerTop?: number;
        innerBottom?: number;
        holes?: Array<HoleData>;
        cutLines?: Array<Curve2>;
        levellers?: Array<LevellerData>;
        params?: any;
        polygons?: Vector2[][];
    };
    export enum PlankCutEnum {
        DOOR_LEFT = 0,
        DOOR_RIGHT = 1,
        WINDOW_LEFT = 2,
        WINDOW_RIGHT = 3,
        WINDOW_LEFT_TOP = 4,
        WINDOW_RIGHT_TOP = 5,
        WINDOW_LEFT_BOTTOM = 6,
        WINDOW_RIGHT_BOTTOM = 7
    }
    export type HoleData = {
        node: FamilyInstanceNode;
        x: number;
        y: number;
        type: HoleTypeEnum;
        width: number;
        height: number;
        startSpaceX: number;
        endSpaceX: number;
        startSpaceY: number;
        endSpaceY: number;
        startSpaceXFace?: number;
        endSpaceXFace?: number;
        startSpaceYFace?: number;
        endSpaceYFace?: number;
        marginStartX?: number;
        marginEndX?: number;
        marginStartY?: number;
        marginEndY?: number;
        position?: HolePositionTypeEnum;
    };
    export enum HoleTypeEnum {
        HOLE_DOOR = 1,
        HOLE_WINDOW = 2,
        HOLE_BEAM = 3,
        HOLE_CEILING = 4,
        HOLE_NORMAL = 5,
        HOLE_CUT = 6,
        HOLE_SUBDOOR = 7,
        HOLE_MAINDOOR = 8
    }
    export enum HolePositionTypeEnum {
        LEFT = 1,
        LEFT_TOP = 2,
        LEFT_CENTER = 3,
        LEFT_BOTTOM = 4,
        RIGHT = 5,
        RIGHT_TOP = 6,
        RIGHT_CENTER = 7,
        RIGHT_BOTTOM = 8,
        TOP_CENTER = 9,
        BOTTOM_CENTER = 10
    }
    export type LevellerData = {
        x: number;
        y: number;
        wx: number;
        wy: number;
        prior: number;
        plank: PlankData;
        type?: LevellerTypeEnum;
        params?: any;
    };
    export enum LevellerTypeEnum {
        Normal = 0,
        Fix = 1,
        Strength = 2,
        HOLE_SIDE = 3
    }
    export type ScrewData = {
        x: number;
        y: number;
        wx: number;
        wy: number;
    };
    export type WindowStoneData = {
        depth: number;
        length: number;
    };
    export type QuadratePipeData = {
        length: number;
        wx: number;
        wy: number;
    };
}
declare module "sk/rule/data/rule/levelinglayout/PolygonLayoutData" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { LevelingLayoutTypeEnum } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class PolygonLayoutData {
        position: Vector3;
        rotation: Vector3;
        width: number;
        height: number;
        thickness: number;
        area: PolygonAreaData;
        params: LevelingLayoutParamers | any;
        type: LevelingLayoutTypeEnum;
    }
    export type LevelingLayoutParamers = {
        plankId: string;
        surfacePlankId?: string;
        decorateId: string;
        levellerId: string;
        screwId?: string;
        nailId?: string;
        doorStoneId?: string;
        emptySpaceDepth: number;
        plankWidth: number;
        plankHeight: number;
        horizontalGap: number;
        verticalGap: number;
        levellerDiameter: number;
        levellerLength: number;
        plankInner: number;
        holeOutter: number;
        element: PatternInstanceElement;
        levellerScrewDistance?: number;
        windowOptimize?: boolean;
        doorOptimize?: boolean;
        computeAll?: boolean;
        computeSuface?: boolean;
        surfaceOffset?: number;
        isXmirror: boolean;
        isYmirror: boolean;
        horizontalIteratorSteps: [];
        verticalIteratorSteps: [];
        buildType?: BuildStructureTypeEnum;
        ability?: number;
    };
    export type PolygonAreaData = {
        idx: number;
        x: number;
        y: number;
        width: number;
        height: number;
        rotationZ: number;
        originPolygon: Array<Vector2>;
        polygon: Array<Vector2>;
        polygons: Array<Array<Vector2>>;
        holes?: Array<PolygonHoleData>;
        doorStone?: DoorStoneData;
        decorate?: PolygonDecorateData;
        reflines?: Array<RefLine>;
        columns?: Array<PolygonColumnData>;
        surfaceColumns?: Array<PolygonColumnData>;
    };
    export type PolygonDecorateData = {
        width: number;
        height: number;
        polygon?: Array<Vector2>;
        x: number;
        y: number;
    };
    export type PolygonColumnData = {
        idx: number;
        x: number;
        width: number;
        height: number;
        holes: Array<PolygonHoleData>;
        planks?: Array<PolygonPlankData>;
        reflines?: Array<RefLine>;
        area: PolygonAreaData;
    };
    export type PolygonPlankData = {
        idx: number;
        y: number;
        wx: number;
        wy: number;
        width: number;
        height: number;
        polygons: Array<Array<Vector2>>;
        column: PolygonColumnData;
        holes?: Array<PolygonHoleData>;
        cutLines?: Array<Curve2>;
        levellers?: Array<PolygonLevellerData>;
        params?: any;
    };
    export type DoorStoneData = {
        height: number;
        width: number;
    };
    export type PolygonHoleData = {
        node: FamilyInstanceNode;
        polygon: Array<Vector2>;
        left: number;
        right: number;
        bottom: number;
        top: number;
    };
    export type PolygonLevellerData = {
        x: number;
        y: number;
        prior: number;
        plank: PolygonPlankData;
        type?: PolygonLevellerTypeEnum;
        params?: any;
    };
    export enum PolygonLevellerTypeEnum {
        Normal = 0,
        Fix = 1,
        Strength = 2,
        HOLE_SIDE = 3
    }
}
declare module "sk/rule/data/rule/assemble/AssembleRoomContext" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssembleBeamPatternElement } from 'sk/data/family/database/pattern/element/AssembleBeamPatternElement';
    import { AssembleCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingPatternElement';
    import { AssembleCeilingPelmetPatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingPelmetPatternElement';
    import { AssembleCompositeCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleCompositeCeilingPatternElement';
    import { AssembleCompositeWallBasePatternElement } from 'sk/data/family/database/pattern/element/AssembleCompositeWallBasePatternElement';
    import { AssembleCompositeWallSurfacePatternElement } from 'sk/data/family/database/pattern/element/AssembleCompositeWallSurfacePatternElement';
    import { AssembleDoorPatternElement } from 'sk/data/family/database/pattern/element/AssembleDoorPatternElement';
    import { AssembleIntegrationCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleIntegrationCeilingPatternElement';
    import { AssembleLevelingCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingCeilingPatternElement';
    import { AssembleLevelingFloorPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingFloorPatternElement';
    import { AssembleLevelingWallPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingWallPatternElement';
    import { AssembleWindowGroundPatternElement } from 'sk/data/family/database/pattern/element/AssembleWindowGroundPatternElement';
    import { AssembleWindowPatternElement } from 'sk/data/family/database/pattern/element/AssembleWindowPatternElement';
    import { CompositeCeilingPatternElement } from 'sk/data/family/database/pattern/element/CompositeCeilingPatternElement';
    import { CompositeWallPatternElement } from 'sk/data/family/database/pattern/element/CompositeWallPatternElement';
    import { LevelingCeilingPatternElement } from 'sk/data/family/database/pattern/element/LevelingCeilingPatternElement';
    import { LevelingFloorPatternElement } from 'sk/data/family/database/pattern/element/LevelingFloorPatternElement';
    import { LevelingWallPatternElement } from 'sk/data/family/database/pattern/element/LevelingWallPatternElement';
    import { PelmetPatternElement } from 'sk/data/family/database/pattern/element/PelmetPatternElement';
    import { ProxyCeilingPatternElement } from 'sk/data/family/database/pattern/element/ProxyCeilingPatternElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { DecorateLayerMaterialTypeEnum } from 'sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class AssembleRoomContext {
        document: SchemeDocument;
        assembleRoom: AssembleRoomElement;
        wallInfoId: string;
        wallPattern: LevelingWallPatternElement;
        assembleWallInfoId: string;
        assembleWallPattern: AssembleLevelingWallPatternElement;
        wallDecorateLinkPattern: LinkerPatternElement;
        compositeWallInfoId: string;
        compositeWallPattern: CompositeWallPatternElement;
        assembleCompositeWallInfoId: string;
        assembleWallBasePattern: AssembleCompositeWallBasePatternElement;
        assembleWallSurfacePattern: AssembleCompositeWallSurfacePatternElement;
        compositeWallDecorateLinkPattern: LinkerPatternElement;
        windowEdgeDecrotateLinkPattern: LinkerPatternElement;
        windowGroundDecrotateLinkPattern: LinkerPatternElement;
        assembleWindowInfoId: string;
        assembleWindowPattern: AssembleWindowPatternElement;
        assembleWindowEdgeInfoId: string;
        assembleWindowEdgePattern: AssembleLevelingWallPatternElement;
        assembleWindowGroundInfoId: string;
        assembleWindowGroundPattern: AssembleWindowGroundPatternElement;
        doorGroundDecrotateLinkPattern: LinkerPatternElement;
        assembleDoorInfoId: string;
        assembleDoorPattern: AssembleDoorPatternElement;
        assembleDoorGroundInfoId: string;
        assembleDoorGroundPattern: AssembleLevelingFloorPatternElement;
        floorInfoId: string;
        floorPattern: LevelingFloorPatternElement;
        assembleFloorInfoId: string;
        assembleFloorPattern: AssembleLevelingFloorPatternElement;
        floorDecorateLinkPattern: LinkerPatternElement;
        ceilingInfoId: string;
        ceilingPattern: LevelingCeilingPatternElement;
        ceilingDecorateLinkPattern: LinkerPatternElement;
        assembleCeilingInfoId: string;
        assembleCeilingPattern: AssembleLevelingCeilingPatternElement | AssembleIntegrationCeilingPatternElement;
        compositeCeilingInfoId: string;
        compositeCeilingPattern: CompositeCeilingPatternElement;
        compositeCeilingDecorateLinkPattern: LinkerPatternElement;
        assembleCompositeCeilingInfoId: string;
        assembleCompositeCeilingPattern: AssembleCompositeCeilingPatternElement;
        proxyCeilingInfoId: string;
        proxyceilingPattern: ProxyCeilingPatternElement;
        proxyCeilingDecorateLinkPattern: LinkerPatternElement;
        assembleLapCeilingInfoId: string;
        assembleLapCeilingPattern: AssembleCeilingPatternElement;
        pelmetInfoId: string;
        pelmetDecorateLinkPattern: LinkerPatternElement;
        pelPattern: PelmetPatternElement;
        assemblePelmetInfoId: string;
        assemblePelmetPattern: AssembleCeilingPelmetPatternElement;
        beamDecrotateLinkPattern: LinkerPatternElement;
        assembleBeamCTypeInfoId: string;
        assembleBeamLTypeInfoId: string;
        assembleBeamPattern: AssembleBeamPatternElement;
        assembleBeamPlankInfoId: string;
        assembleBeamPlankPattern: AssembleLevelingWallPatternElement;
        decorateLayerMaterialInfoId: string;
        decorateLayerMaterialType: DecorateLayerMaterialTypeEnum;
        context: ContextObject;
        loadAssembleRoomParamsAsync(assembleRoom: AssembleRoomElement): Promise<ResultObject>;
        loadLeveingWallPatternParamsAsync(assembleRoom: AssembleRoomElement, wallInfoId: string): Promise<ResultObject>;
        loadCompositeWallPatternParamsAsync(assembleRoom: AssembleRoomElement, wallInfoId: string): Promise<ResultObject>;
        loadPelmetPatternParamsAsync(assembleRoom: AssembleRoomElement, pelmetInfoId: string): Promise<ResultObject>;
        loadWindowPatternParamsAsync(linkPattern: LinkerPatternElement): Promise<ResultObject>;
        loadDoorPatternParamsAsync(linkPattern: LinkerPatternElement): Promise<ResultObject>;
        loadLeveingFloorPatternParamsAsync(assembleRoom: AssembleRoomElement, floorInfoId: string): Promise<ResultObject>;
        loadLeveingCeilingPatternParamsAsync(assembleRoom: AssembleRoomElement, ceilingInfoId: string): Promise<ResultObject>;
        loadComposteCeilingPatternParamsAsync(assembleRoom: AssembleRoomElement, compositeCeilingInfoId: string): Promise<ResultObject>;
        loadProxyCeilingPatternParamsAsync(assembleRoom: AssembleRoomElement, proxyCeilingInfoId: string): Promise<ResultObject>;
        loadBeamPatternParamsAsync(linkPattern: LinkerPatternElement, LtypeLinkPattern?: LinkerPatternElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/base/ContentBase" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    export class ContentBase {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        placeCd: ContentPlaceTypeEnum;
        offset: Vector3;
        asixX: Vector3;
        asixY: Vector3;
        asixZ: Vector3;
        isLayout: boolean;
        layoutVector: Vector3;
        belongId: string;
        roomId: string;
        constructor();
        clone(): ContentBase;
        set size(s: Vector3);
        get size(): Vector3;
        set position(s: Vector3);
        get position(): Vector3;
        set origin(s: Vector3);
        get origin(): Vector3;
        set rotation(s: Vector3);
        get rotation(): Vector3;
    }
}
declare module "sk/rule/data/rule/assemble/beam/base/FamilyContentBase" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class FamilyContentBase extends ContentBase {
        familyId: string;
        familyIds: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamLayerTypeEnum" {
    export class AssemblyBeamLayerTypeEnum {
        static base: string;
        static face: string;
        static decorate: string;
        static contract: string;
        static nail: string;
        static faceNail: string;
        static survey: string;
        static keel: string;
        static keelNail: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    import { AssemblyBeamLayerTypeEnum } from "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamLayerTypeEnum";
    export class LayerLayoutResult extends ContentBase {
        type: AssemblyBeamLayerTypeEnum;
        elements: Array<FamilyContentBase>;
        constructor();
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingElementUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { PointElement } from 'sk/data/family/element/brep/geometric/PointElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
    import { TechnologyHoleElement } from 'sk/data/scheme/database/technology/element/TechnologyHoleElement';
    import { TechnologyMillingTrackElement } from 'sk/data/scheme/database/technology/element/TechnologyMillingTrackElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { LayerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult";
    import { DecorateData, HoleData, PlankData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { PolygonAreaData, PolygonDecorateData, PolygonPlankData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class LevelingElementUtil {
        protected static _calculatorService: CalculatorService;
        protected static _schemeConfigService: SchemeConfigService;
        static getElementInfoAsync(context: ContextObject, familyId: string): Promise<RuleProcesResult>;
        static createElementAsync(context: ElementPerformerContext, parent: ContentElement, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<FamilyInstanceElement>>;
        static createMillingLine(familyStructure: FamilyStructure, beginX: number, beginY: number, endX: number, endY: number, depth: number): TechnologyMillingTrackElement;
        static createTechnologyHoleByPolygon(familyStructure: FamilyStructure, polygon: Vector2[], lengthX: number, lengthY: number, lengthZ: number): TechnologyHoleElement;
        static createTechnologyHoleByHoleData(familyStructure: FamilyStructure, holeData: HoleData, lengthZ: number, decroateLengthZ?: number): TechnologyHoleElement;
        static addPlankHoleMilling(plankElement: FamilyInstanceElement, plank: PlankData | PolygonPlankData): void;
        static getMillingLinePoints(plankElement: FamilyInstanceElement): Array<Array<PointElement>>;
        static addPlankTechnologyHole(plankElement: FamilyInstanceElement, orginX: number, orginY: number, holes: HoleData[], reverse?: boolean): void;
        static addPlankCutLinesMilling(plankElement: FamilyInstanceElement, cutLines: Curve2[]): void;
        static addPlankTechnologyHoleByDecorateData(plankElement: FamilyInstanceElement, decorateData: DecorateData, holes: HoleData[], reverse?: boolean): void;
        static addPlankTechnologyHoleByDecorateHoles(plankElement: FamilyInstanceElement, holes: HoleData[], reverse?: boolean): void;
        static addBeamPlankTechnologyHoleByDecorateData(plankElement: FamilyInstanceElement, decorateData: LayerLayoutResult, holes: HoleData[], reverse?: boolean): void;
        static addBeamPlankMillingHoleByDecorateData(plankElement: FamilyInstanceElement, holes: HoleData[], faceLayer?: boolean): void;
        static addPlankTechnologyHoleByPolygons(plankElement: FamilyInstanceElement, decorateData: PolygonDecorateData, polygons: Vector2[][], areaData: PolygonAreaData): void;
        static setPlankByPolygon(plankElement: FamilyInstanceElement, polygon: Vector2[]): void;
        static clearEdgesByPlank(plankElement: FamilyInstanceElement): void;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter" {
    import { AssemblyBeamLayerTypeEnum } from "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamLayerTypeEnum";
    export class LayerArrangeParamter {
        leftGap: number;
        rightGap: number;
        bottomGap: number;
        topGap: number;
        depth: number;
        type: AssemblyBeamLayerTypeEnum;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutGeometryArea" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { HoleData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LayoutGeometryArea {
        location: Vector2;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        polygon: Array<Vector2>;
        holes: HoleData[];
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { AssemblyBeamLayerTypeEnum } from "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamLayerTypeEnum";
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    import { LayoutGeometryArea } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutGeometryArea";
    export class LayoutSurfaceData extends LayoutGeometryArea {
        layerArrangeInput: TypeMap<AssemblyBeamLayerTypeEnum, LayerArrangeParamter>;
        startContraction: number;
        endContraction: number;
        calculateList: TypeMap<AssemblyBeamLayerTypeEnum, boolean>;
        constructor();
        layerListSet(element: LevelingWallElement, buildType: BuildStructureTypeEnum, isLBeam: boolean): void;
        layerListSetByLevelingWallType(element: LevelingWallElement): void;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleElementUtil" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export class AssembleElementUtil {
        static removeAssembleInstance(instance: PatternInstanceElement, remove?: boolean): void;
        static getBuildStructureType(context: ElementPerformerContext, element: PatternInstanceElement): BuildStructureTypeEnum;
        static removeContainerChildren(element: ContentInstanceElement, pool?: boolean): void;
        static isTechniquleContainer(element: BrepElement): boolean;
        static getContainerChildByName(element: BrepElement, name: string): ContainerElement;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase" {
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class AssemblyCeilingContentBase extends ContentBase {
        outline: SectionSurface;
        columnIndex: number;
        rowIndex: number;
        name: string;
        identifier: number;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingBasedPlank" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    export class AssemblyCeilingBasedPlank extends AssemblyCeilingContentBase {
        millingPath: Array<Curve2>;
        constructor();
    }
}
declare module "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class PolygonKeelLayoutData extends PolygonLayoutData {
        params: KeelLayoutParamers;
        type: any;
    }
    export type KeelLayoutParamers = {
        plankWidth: number;
        plankHeight: number;
        horizontalGap: number;
        verticalGap: number;
        checkInnerDis: number;
        checkOuterDis: number;
        plankInner: number;
        holeOutter: number;
        computeSurface: boolean;
        computeBase: boolean;
        surfaceOffset: number;
        checkOffset: number;
    };
    export type PolygonAreaData = {
        idx: number;
        x: number;
        y: number;
        width: number;
        height: number;
        rotationZ: number;
        originPolygon: Array<Vector2>;
        polygon: Array<Vector2>;
        polygons: Array<Array<Vector2>>;
        holes?: Array<PolygonHoleData>;
        decorate?: PolygonDecorateData;
        reflines?: Array<RefLine>;
        columns?: Array<PolygonColumnData>;
        surfaceColumns?: Array<PolygonColumnData>;
    };
    export type PolygonDecorateData = {
        width: number;
        height: number;
        polygon?: Array<Vector2>;
        x: number;
        y: number;
    };
    export type PolygonColumnData = {
        idx: number;
        x: number;
        width: number;
        height: number;
        holes: Array<PolygonHoleData>;
        planks?: Array<PolygonPlankData>;
        reflines?: Array<RefLine>;
        area: PolygonAreaData;
    };
    export type PolygonPlankData = {
        idx: number;
        y: number;
        wx: number;
        wy: number;
        width: number;
        height: number;
        polygons: Array<Array<Vector2>>;
        column: PolygonColumnData;
        holes?: Array<PolygonHoleData>;
        cutLines?: Array<Curve2>;
        params?: any;
    };
    export type PolygonHoleData = {
        node: FamilyInstanceNode;
        polygon: Array<Vector2>;
        left: number;
        right: number;
        bottom: number;
        top: number;
    };
}
declare module "sk/rule/data/rule/layout/entitys/LoDbEntity" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class LoDbEntity extends ContentBase {
        id: string;
        symbolId: string;
        columnIndex: number;
        rowIndex: number;
        name: string;
        identifier: number;
        subEntitys: Array<LoDbEntity>;
        outline: SectionSurface;
        protected _schemeConfigService: SchemeConfigService;
        constructor(id?: string);
        copyFrom(other: LoDbEntity): void;
        setPropertiesFromElement(element: FamilyInstanceElement): void;
        transformBy(mat: Matrix4): void;
        transform(): Matrix4;
    }
}
declare module "sk/rule/data/rule/base/LevelingWallPlankGapPosEnum" {
    export class LevelingWallPlankGapPosEnum {
        static LeftUp: string;
        static LeftBottom: string;
        static RightUp: string;
        static RightBottom: string;
    }
}
declare module "sk/rule/data/rule/layout/LayoutableObject" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class LayoutableObject {
        normal: Vector3;
        constructor();
    }
}
declare module "sk/rule/data/rule/layout/LayoutableLine" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    export class LayoutableLine extends LayoutableObject {
        begin: Point3;
        end: Point3;
        constructor(begin?: Point3, end?: Point3, normal?: Vector3);
        clone(): LayoutableLine;
        move(x?: number, y?: number, z?: number): LayoutableLine;
        clipBegin(len: number): void;
        clipEnd(len: number): void;
        dir(): Vector3;
        length(): number;
        intersectWithLine(other: LayoutableLine): {
            isOk: boolean;
            point: Point3;
        };
        invert(): void;
        convertToIntPtList(scale?: number): Array<any>;
        convertToClosedIntPtList(scale?: number): Array<any>;
    }
}
declare module "sk/rule/data/rule/layout/LayoutablePolyline" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    export class LayoutablePolyline extends LayoutableObject {
        _layoutLines: Array<LayoutableLine>;
        _isClose: boolean;
        constructor();
        convertToIntPtList(scale?: number, isClockwise?: boolean): {
            ptList: Array<any>;
            isClose: boolean;
        };
        static isClockwise(ptList: Array<Vector2>): boolean;
    }
}
declare module "sk/rule/data/rule/layout/ReferencelineInfo" {
    import { Line3 } from 'foundation/runtime/math/Line3';
    export class ReferencelineInfo {
        line: Line3;
        type: string;
        name: string;
        constructor(line?: Line3, type?: string, name?: string);
    }
}
declare module "sk/rule/data/rule/layout/LayoutableSurface" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    import { LayoutablePolyline } from "sk/rule/data/rule/layout/LayoutablePolyline";
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    export class LayoutableSurface extends LayoutableObject {
        static surfaceNormal: number;
        static insideElevationNormal: number;
        static outsideElevationNormal: number;
        origin: Point3;
        axisX: Vector3;
        axisY: Vector3;
        lengthX: number;
        lengthY: number;
        column: number;
        row: number;
        trimPolylines: Array<Curve2>;
        constructor(origin?: Point3, axisX?: Vector3, axisY?: Vector3, lengthX?: number, lengthY?: number, normal?: Vector3);
        clone(): LayoutableSurface;
        static fromExtents(ext: SkDbExtents): LayoutableSurface;
        static fromLineXY(lineX: LayoutableLine, lineY: LayoutableLine): LayoutableSurface;
        getOutline(normalMode: number): LayoutablePolyline;
        isPointIn(pt: Point3): boolean;
        isCornerPt(pt: Point3): boolean;
        offset(offsetDist: number): void;
        pointA(): Point3;
        pointB(): Point3;
        pointC(): Point3;
        pointD(): Point3;
        getLineNormal(index: number, normalMode: number): Vector3;
        getLineNormalByIndex(normalIndex: number): Vector3;
        getAB(normalMode?: number): LayoutableLine;
        getBA(normalMode?: number): LayoutableLine;
        getBC(normalMode?: number): LayoutableLine;
        getCB(normalMode?: number): LayoutableLine;
        getCD(normalMode?: number): LayoutableLine;
        getDC(normalMode?: number): LayoutableLine;
        getAD(normalMode?: number): LayoutableLine;
        getDA(normalMode?: number): LayoutableLine;
        calculateRefrencelines(type: string, name: string, output: Array<ReferencelineInfo>): void;
        toSectionSurface(): SectionSurface;
        toSurface(): Surface;
    }
}
declare module "sk/rule/data/rule/layout/entitys/LoDbReferenceLine" {
    import { Line3 } from 'foundation/runtime/math/Line3';
    export class LoDbReferenceLine {
        line: Line3;
        type: string;
        name: string;
        constructor(line?: Line3, type?: string, name?: string);
    }
}
declare module "sk/rule/data/rule/layout/LoUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { BooleanOperationEnum } from 'foundation/runtime/math/Operator';
    import { Point2 } from 'foundation/runtime/math/Point2';
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ComplexHoleSurface } from 'foundation/runtime/geometry/surface/ComplexHoleSurface';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { WallSurfaceElement } from 'sk/data/scheme/database/floorplan/element/WallSurfaceElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { LogicPoint } from "sk/rule/data/calculate/data/LogicPoint";
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { LoDbReferenceLine } from "sk/rule/data/rule/layout/entitys/LoDbReferenceLine";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    export class LoUtil {
        protected static _calculatorService: CalculatorService;
        protected static _schemeConfigService: SchemeConfigService;
        private static familyInfoIdMap;
        private static familyInfoMap;
        static getFamilyInfoIdFromMap(id: string): string;
        static getFamilyInfoFromMap(id: string, symbolIndex?: number): ISpecificationFamilyInfo;
        static getFamilyInfoAsync(schemeConfigService: SchemeConfigService, context: ElementPerformerContext, id: string, symbolIndex?: number): Promise<ISpecificationFamilyInfo>;
        static calculateLineRotate(begin: Point3, end: Point3, viewDir: Vector3): {
            left: Point3;
            rotate: number;
        };
        static getCeilingSurfaceFromInput(input: RuleProcessInput): CeilingSurfaceElement;
        static getWallSurfaceFromInput(input: RuleProcessInput): WallSurfaceElement;
        static createConatinerFromParent(parent: ContentElement, name: string, identifier: number, drawingCodes: string): ContainerElement;
        static createElementByContentBaseAsync(context: ElementPerformerContext, loEntitys: Array<LoDbEntity>, parent: NestElement, axisDirection?: boolean): Promise<RuleProcesResult>;
        static createElementByContentBase1Async(context: ElementPerformerContext, schemeConfigService: SchemeConfigService, calculatorService: CalculatorService, loEntitys: Array<LoDbEntity>, parent: NestElement): Promise<RuleProcesResult>;
        static createElementByFamilyIdAsync(context: ElementPerformerContext, parent: NestElement, loEntity: LoDbEntity): Promise<ResultObject<FamilyInstanceElement>>;
        static createElementAsync(context: ElementPerformerContext, schemeConfigService: SchemeConfigService, calculatorService: CalculatorService, parent: NestElement, loEntity: LoDbEntity): Promise<FamilyInstanceElement>;
        static createElement2Async(context: ElementPerformerContext, schemeConfigService: SchemeConfigService, calculatorService: CalculatorService, parent: NestElement, loEntity: LoDbEntity): Promise<FamilyInstanceElement>;
        static plankMillingProcess(plankElement: FamilyInstanceElement, parent: ContentElement, paths: Array<Curve2>): void;
        static createReferenceLines(lines: Array<LoDbReferenceLine>, parent: NestElement): void;
        static createSectionSurfaceEdge(plane: FamilyInstanceElement, section: SectionSurface): void;
        static sortD(a: any, b: any): any;
        static sortR(a: any, b: any): any;
        static sortHLine(a: LayoutableLine, b: LayoutableLine): any;
        static sortVLine(a: LayoutableLine, b: LayoutableLine): any;
        static sortHPoint(a: Vector3, b: Vector3): any;
        static sortVPoint(a: Vector3, b: Vector3): any;
        static intersectWithSurface2(surfaceF: LayoutableSurface, surfaceT: LayoutableSurface, opration: BooleanOperationEnum): Array<LayoutablePolySurface>;
        static pointIsOnboundary(p1: Vector2, p2: Vector2, region: any): boolean;
        static isPointInPlank(point: Vector2, region: any): boolean;
        static intersectWithSurface(surfaceF: LayoutableSurface, surfaceT: LayoutableSurface, opration: BooleanOperationEnum): Array<LayoutablePolySurface>;
        static points2ToPoints3(pts2: Array<Point2>): Array<Point3>;
        static logicPointsToPoints3Ex(pts2: Types<LogicPoint>): Array<Point3>;
        static point2sToLogicPoints(pts: Array<Point2>): Types<LogicPoint>;
        static intersectWithSurfaces(surfaceF: LayoutableSurface, surfaceTs: Array<LayoutableSurface>, opration: BooleanOperationEnum): Array<LayoutablePolySurface>;
        static createComplexHoleSurface(outline: Vector2[], holes: Vector2[][]): ComplexHoleSurface;
    }
}
declare module "sk/rule/data/rule/layout/LayoutablePolySurface" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Surface } from 'foundation/runtime/geometry/Surface';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    export class LayoutableLineWithCorner extends LayoutableLine {
        startCorner: boolean;
        endCorner: boolean;
        constructor();
    }
    export class PolyVertex extends Point3 {
        preVertex: PolyVertex;
        nextVertex: PolyVertex;
        headFlag: boolean;
    }
    export class LayoutablePolySurface extends LayoutableSurface {
        points: Array<Point3>;
        holes: Array<Array<Vector2>>;
        horizontalLines: Array<LayoutableLine>;
        verticalLines: Array<LayoutableLine>;
        vertexHead: PolyVertex;
        constructor();
        static fromPoints(points: Array<Point3>, holes?: Array<Array<Vector2>>): LayoutablePolySurface;
        static fromLogicArea(area: LogicArea): LayoutablePolySurface;
        static fromPlankNode(plankNode: PlankNode): LayoutablePolySurface;
        static preIndex(polySurface: LayoutablePolySurface, curIndex: number): number;
        static nextIndex(polySurface: LayoutablePolySurface, curIndex: number): number;
        static getLineSegmentXCoord(lineSegment: LayoutableLine): {
            coord: number;
            smallValue: number;
            bigValue: number;
        };
        static getLineSegmentYCoord(lineSegment: LayoutableLine): {
            coord: number;
            smallValue: number;
            bigValue: number;
        };
        static createHCrossLineByParams(coord: number, smallValue: number, bigValue: number, zValue: number): LayoutableLine;
        static createVCrossLineByParams(coord: number, smallValue: number, bigValue: number, zValue: number): LayoutableLine;
        clipLineByHoles(line: LayoutableLine, holes: Array<Array<Vector2>>): Array<LayoutableLine>;
        getCrossSectionLines(coord: number, hvFlag: number): Array<LayoutableLine>;
        sortPoints(): Array<Point3>;
        pushOrthLine(layoutLine: LayoutableLine): boolean;
        setZ(zValue: number): void;
        createOrthLine(ptF: Point3, ptS: Point3): boolean;
        createOrthLines(): boolean;
        createLayoutLineInfo(isClonePoint: boolean): Array<LayoutableLineWithCorner>;
        calculateRefrencelines(type: string, name: string, output: Array<ReferencelineInfo>): void;
        toSectionSurface(): SectionSurface;
        static fromExtents(ext: SkDbExtents): LayoutablePolySurface;
        offset(offsetDist: number): void;
        toSurface(): Surface;
    }
}
declare module "sk/rule/data/rule/layout/entitys/LoDbPlank" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    export class PlankCut {
        gapWidth: number;
        gapHeight: number;
        gapPos: string;
        static LeftUp: string;
        static LeftBottom: string;
        static RightUp: string;
        static RightBottom: string;
    }
    export class LoDbPlank extends LoDbEntity {
        cuts: Array<PlankCut>;
        millingPath: Array<Curve2>;
        constructor(id?: string);
        getLayoutableSurface(): any;
        static millingByPolySurface(dbPlank: LoDbPlank, polySurface: LayoutablePolySurface): Array<LoDbPlank>;
        static millingByLogicArea(area: LogicArea, id: string): Array<LoDbPlank>;
        static cutPlankEntityBySurface(plank: LoDbPlank, cutSurface: LayoutableSurface): void;
        static cutPlankEntityBySurfaces(plank: LoDbPlank, cutSurfaces: Array<LayoutableSurface>): boolean;
        static cutPlankElement(plankElement: FamilyInstanceElement, parent: ContentElement, plankSurface: LayoutableSurface, cutPara: PlankCut): void;
    }
}
declare module "sk/rule/data/rule/layout/LoMirrorUtil" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { PolygonColumnData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { PolygonAreaData, PolygonPlankData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { LoDbPlank } from "sk/rule/data/rule/layout/entitys/LoDbPlank";
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    export class LoMirrorUtil {
        static mirrorPointByAxisX(point: Value2, yValue: number): void;
        static mirrorPointByAxisY(point: Value2, xValue: number): void;
        static mirrorPointsByAxisX(points: Array<Value2>, yValue: number): void;
        static mirrorPointsByAxisY(points: Array<Value2>, xValue: number): void;
        static mirrorEntityByAxisX(entity: LoDbEntity, yValue: number): void;
        static mirrorEntityByAxisY(entity: LoDbEntity, xValue: number): void;
        static mirrorCurve2ByAxisX(curve: Curve2, yValue: number): void;
        static mirrorCurve2ByAxisY(curve: Curve2, xValue: number): void;
        static mirrorLineCurve2dByAxisX(curve: LineCurve2d, yValue: number): void;
        static mirrorLineCurve2dByAxisY(curve: LineCurve2d, xValue: number): void;
        static mirrorPathByAxisX(path: Array<Curve2>, yValue: number): void;
        static mirrorPathByAxisY(path: Array<Curve2>, xValue: number): void;
        static mirrorSectionSurfaceByAxisX(sectionSurface: SectionSurface, yValue: number): void;
        static mirrorSectionSurfaceByAxisY(sectionSurface: SectionSurface, xValue: number): void;
        static mirrorReferencelineByAxisX(refLines: Array<ReferencelineInfo>, yValue: number): void;
        static mirrorReferencelineByAxisY(refLines: Array<ReferencelineInfo>, xValue: number): void;
        static mirrorPlankByAxisX(plank: LoDbPlank, yValue: number): void;
        static mirrorPlankByAxisY(plank: LoDbPlank, xValue: number): void;
        static mirrorContentBaseByAxisX(contents: Array<ContentBase>, yValue: number): void;
        static mirrorContentBaseByAxisY(contents: Array<ContentBase>, xValue: number): void;
        static mirrorPolygonPlankDataByAxisX(planks: Array<PolygonPlankData>, yValue: number): void;
        static mirrorPolygonPlankDataByAxisY(planks: Array<PolygonPlankData>, xValue: number): void;
        static mirrorColumnDatasByAxisX(columns: Array<PolygonColumnData>, yValue: number): void;
        static mirrorColumnDatasByAxisY(columns: Array<PolygonColumnData>, xValue: number): void;
        static mirrorPolygonAreaDataByAxisX(polygonAreaData: PolygonAreaData, yValue: number): void;
        static mirrorPolygonAreaDataByAxisY(polygonAreaData: PolygonAreaData, xValue: number): void;
    }
}
declare module "sk/rule/data/rule/levelinglayout/PolygonLayoutLevellerCalculator" {
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { PolygonLayoutData, LevelingLayoutParamers, PolygonLevellerData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class PolygonLayoutLevellerCalculator {
        private layoutData;
        private params;
        sideLevellers: Array<PolygonLevellerData>;
        tmpPolygon: Polygon;
        constructor(layoutData: PolygonLayoutData, params: LevelingLayoutParamers);
        calculate(): void;
        private addLevellers;
        private createNarrowPlankLevelers;
        private createPlankInnerLevellers;
        private isLevellerCover;
        private addLevellerToPlank;
        private createPlankSideLevellers;
        private createLineLevellers;
        private isLineOnPolygon;
        private getLineIndexOnPolygon;
        private moveInterLeveller;
        private isLevellerCoverMove;
        private normalize;
        private pushInnerSideLevellers;
        private getPointOnPolygonDir;
        private moveLeveller;
    }
}
declare module "sk/rule/data/rule/levelinglayout/PolygonLayoutDataCalculator" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { LevelingLayoutParamers, PolygonAreaData, PolygonColumnData, PolygonHoleData, PolygonLayoutData, PolygonPlankData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class PolygonLayoutDataCalculator {
        layoutData: PolygonLayoutData;
        protected params: LevelingLayoutParamers;
        constructor(layoutData: PolygonLayoutData, params: LevelingLayoutParamers);
        caclulate(): RuleProcesResult;
        protected computeDoorStone(): void;
        protected computeDecorate(layoutData: PolygonLayoutData): RuleProcesResult;
        protected getRefLines(area: PolygonAreaData, holes: Array<PolygonHoleData>, vertical?: boolean, column?: PolygonColumnData): Array<RefLine>;
        protected getBaseRefLines(area: PolygonAreaData, vertical?: boolean, columnData?: PolygonColumnData): RefLine[];
        protected computePlank(): RuleProcesResult;
        protected computeSurfacePlank(): RuleProcesResult;
        protected tryMergePlank(column: PolygonColumnData): void;
        protected cutColumns(areaData: PolygonAreaData, columns: PolygonColumnData[], offset?: number, baseRefLines?: RefLine[]): boolean;
        protected cutRows(column: PolygonColumnData, isSurface?: boolean, offset?: number, baseRefLines?: RefLine[]): boolean;
        protected createPlanksByNumbers(column: PolygonColumnData, numbers: Array<number>): void;
        protected getPlankLocalHoles(plank: PolygonPlankData, inputHoles: Array<PolygonHoleData>): void;
        protected cutPlank(plank: PolygonPlankData, idx: number): number;
        protected addPlankData(plank: PolygonPlankData, plankPolygon: Array<Vector2>, polygons: Array<Array<Vector2>>): void;
        protected convertPolygonToRegion(polygon: Value2[], region: any[]): any;
        protected isPointInPlank(plank: PolygonPlankData, point: Value2): boolean;
        protected isPointsOnPlankSameSide(plank: PolygonPlankData, p1: Value2, p2: Value2): boolean;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingFloorBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { LevelingLayoutParamers, PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class LevelingFloorBuilder {
        private layoutData;
        private params;
        private context;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: PolygonLayoutData, params: LevelingLayoutParamers);
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        private createConatiner;
        private createElementsErroModeAsync;
        private createElementsAsync;
        createContainers(context: ElementPerformerContext, element: ContentElement): void;
        createPlanksAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<void>;
        createDecoratesAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<ResultObject>;
        createDoorStoneAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, offest: number): Promise<void>;
        private createPlankElementAsync;
        private createSimplePlankElementAsync;
        private createDoorStoneElementAsync;
        private createDecorateElementAsync;
        private createLevellersAsync;
        private createLevellerElementAsync;
    }
}
declare module "sk/rule/data/rule/levelinglayout/PolygonLayoutDataCalculatorEx" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { LogicContext } from "sk/rule/data/calculate/base/LogicContext";
    import { LogicPolygonSplitterCalculator } from "sk/rule/data/calculate/calculate/LogicPolygonSplitterCalculator";
    import { LogicPolygonSplitterInput } from "sk/rule/data/calculate/calculate/LogicPolygonSplitterInput";
    import { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    import { PolygonLayoutDataCalculator } from "sk/rule/data/rule/levelinglayout/PolygonLayoutDataCalculator";
    export class LogicPolygonSplitterCalculatorEx extends LogicPolygonSplitterCalculator {
        process(context: LogicContext, input: LogicPolygonSplitterInput): Types<LogicArea>;
        createTestData(): Types<LogicArea>;
    }
    export class PolygonLayoutDataCalculatorEx extends PolygonLayoutDataCalculator {
        caclulate(): RuleProcesResult;
        convertInput(): LogicPolygonSplitterInput;
        convertOutput(output: Types<LogicArea>): RuleProcesResult;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingFloorBuilderEx" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { LogicArea } from "sk/rule/data/calculate/data/LogicArea";
    import { LevelingLayoutParamers, PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class LevelingFloorBuilderEx {
        area: LogicArea;
        output: Types<LogicArea>;
        params: LevelingLayoutParamers;
        private holes;
        private outputPoints;
        constructor(layoutData: PolygonLayoutData, params: LevelingLayoutParamers);
        layoutDataToLogicArea(layoutData: PolygonLayoutData): LogicArea;
        private createConatiner;
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        private createElementsAsync;
        createPlanksAsync(context: ElementPerformerContext, container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<ResultObject>;
        createDecoratesAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<ResultObject>;
        private createLevellersAsync;
        private createLevellerElementAsync;
    }
}
declare module "sk/rule/data/rule/assemble/LevelingFloorElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AssembleLevelingFloorPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingFloorPatternElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleLevelingFloorElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingFloorElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { PolygonAreaData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class LevelingFloorPartenEnum {
        static floor: string;
        static area_floor: string;
    }
    export class LevelingFloorElementUtil {
        static createLevelingFloorsByDefaultAsync(outline: Array<Vector2>, floorElement: LevelingFloorElement, holes?: Array<Array<Vector2>>): Promise<ResultObject<any>>;
        static createLevelingFloorByOutlineAsync(infoId: string, document: SchemeDocument, outline: Array<Vector2>, element: LevelingFloorElement, holes?: Array<Array<Vector2>>): Promise<ResultObject<LevelingFloorElement>>;
        static loadFloorPatternParameterDefaultsAsync(element: LevelingFloorElement): Promise<ResultObject>;
        static createLevelingFloorsAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode): Promise<ResultObject<any>>;
        static createLevelingFloorAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode, element?: LevelingFloorElement): Promise<ResultObject>;
        static updateLevelingFloorLinkedPatternAsync(assembleRoom: AssembleRoomElement, levelingFloor: LevelingFloorElement, newPatternInfoId: string): Promise<ResultObject>;
        static getAreasFromFloorSurface(roomNode: RoomNode): Array<Array<Vector2>>;
        static createLevelingFloorByAreaAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode, element?: LevelingFloorElement): Promise<ResultObject>;
        static dirtyLevelingFloorByOutline(polygon: Array<Vector2>, element: LevelingFloorElement): void;
        static createLevelingFloorByRegion(assembleContext: AssembleRoomContext, region: Array<Vector2>, relationElemnt: ContentInstanceElement, element?: LevelingFloorElement): LevelingFloorElement;
        static updateLevelingFloorByArea(element: LevelingFloorElement): LevelingFloorElement;
        static updateLevelingFloorAsync(context: ElementPerformerContext, element: LevelingFloorElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static loadFloorPatternParametersAsync(assembleFloorPattern: AssembleLevelingFloorPatternElement, assembleFloorInfoId: string, floorDecorateLinkPattern: LinkerPatternElement, element: LevelingFloorElement): Promise<ResultObject>;
        static setLevelingFloorProperty(element: LevelingFloorElement, area: PolygonAreaData, thickness: number): void;
        static getValidSteps(steps: string): number[];
        static buildFloorElementAsync(context: ElementPerformerContext, levelingFloorElement: LevelingFloorElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateFloorLayerElementAsync(context: ElementPerformerContext, levelingFloorElement: LevelingFloorElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        private updateDecorateLayerInfoAsync;
        static getThicknessWithDecorate(assembleFloorElement: AssembleLevelingFloorElement, thicknessWithDecorate: number): number;
        static getSpaceThickness(assembleFloorElement: AssembleLevelingFloorElement): number;
        static getDecorateThickness(assembleFloorElement: AssembleLevelingFloorElement): number;
        static getBaseThickness(assembleFloorElement: AssembleLevelingFloorElement): number;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleDoorElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { AssembleDoorElement } from 'sk/data/scheme/database/pattern/element/AssembleDoorElement';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class AssembleDoorElementUtil {
        static createAssembleDoorAsync(assembleContext: AssembleRoomContext, doorNode: OpeningNode, wallSurfaceNode: WallSurfaceNode, levelingWall: LevelingWallElement | CompositeWallElement): Promise<ResultObject>;
        static updateAssemleDoorElementAsync(context: ElementPerformerContext, element: AssembleDoorElement): Promise<ResultObject>;
        private static calculateAssembleDoorGeo;
        private static setParameters;
        static setElementLocation(element: AssembleDoorElement, box: ContentBase): void;
        static createDoorFloorAsync(assembleContext: AssembleRoomContext, assembleDoor: AssembleDoorElement, element: OpeningElement, wallSurfaceNode: WallSurfaceNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutDecorateParamter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutDecorateParameter extends LayerArrangeParamter {
        decorateId: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutFaceNailParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutFaceNailParameter extends LayerArrangeParamter {
        nailId: string;
        innerGap: number;
        nailDiamter: number;
        nailArrangeModule: number;
        layoutType: string;
        nailSideGap: number;
        minSpace: number;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutFacePlankParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutFacePlankParameter extends LayerArrangeParamter {
        arrangeModule: number;
        lengthModule: number;
        minLength: number;
        plankId: string;
        plankSymbolLength: number;
        plankGapMisposed: number;
        levelerModule: number;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutKeelNailParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutKeelNailParameter extends LayerArrangeParamter {
        nailId: string;
        innerGap: number;
        nailDiamter: number;
        nailArrangeModule: number;
        nailSideGap: number;
        minSpace: number;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutKeelParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutKeelParameter extends LayerArrangeParamter {
        baseplankThickness: number;
        surfaceplankThickness: number;
        decorateThickness: number;
        edgeKeelWidth: number;
        edgeKeelHeight: number;
        levelerToBeamEdgeDis: number;
        keelStandardLength: number;
        keelMinLength: number;
        layoutType: string;
        viceKeelId: string;
        edgeKeelId: string;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutLevelerParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutLevelerParameter extends LayerArrangeParamter {
        arrangeModule: number;
        diameter: number;
        collisonDistance: number;
        levelerId: string;
        levelerIds: string;
        fixedLevelerId: string;
        fixedLevelerIds: string;
        boltId: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutMetalLevelerParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutMetalLevelerParameter extends LayerArrangeParamter {
        arrangeModule: number;
        diameter: number;
        levelerToBeamEdgeDis: number;
        collisonDistance: number;
        layoutType: string;
        edgeKeelWidth: number;
        viceKeelHeight: number;
        metalLevelerId: string;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutNailParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutNailParameter extends LayerArrangeParamter {
        nailId: string;
        innerGap: number;
        nailDiamter: number;
        nailArrangeModule: number;
        layoutType: string;
        nailSideGap: number;
        minSpace: number;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutPlankParameter" {
    import { LayerArrangeParamter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerArrangeParamter";
    export class LayoutPlankParameter extends LayerArrangeParamter {
        arrangeModule: number;
        lengthModule: number;
        minLength: number;
        plankId: string;
        plankSymbolLength: number;
        levelerModule: number;
    }
}
declare module "sk/rule/data/rule/assemble/beam/frame/AssemblyBeamSuctionTypeEnum" {
    export class AssemblyBeamSuctionTypeEnum {
        static Unknown: string;
        static leftSurface: string;
        static rightSurface: string;
        static bottomSurface: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/frame/LayoutSurfaceResult" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { LayerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult";
    import { AssemblyBeamLayerTypeEnum } from "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamLayerTypeEnum";
    export class LayoutSurfaceResult {
        calculateList: TypeMap<AssemblyBeamLayerTypeEnum, boolean>;
        type: string;
        layers: TypeMap<AssemblyBeamLayerTypeEnum, LayerLayoutResult>;
        constructor();
    }
}
declare module "sk/rule/data/rule/layout/LayoutablePoint" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    export class LayoutablePoint extends LayoutableObject {
        position: Point3;
        constructor(pos?: Point3, normal?: Vector3);
    }
}
declare module "sk/rule/data/rule/layout/LayoutableNailPoint" {
    import { LayoutablePoint } from "sk/rule/data/rule/layout/LayoutablePoint";
    export class LayoutableNailPoint extends LayoutablePoint {
    }
}
declare module "sk/rule/data/rule/layout/LineLayoutProcess" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutableNailPoint } from "sk/rule/data/rule/layout/LayoutableNailPoint";
    import { LayoutablePoint } from "sk/rule/data/rule/layout/LayoutablePoint";
    import { LayoutablePolyline } from "sk/rule/data/rule/layout/LayoutablePolyline";
    export class LineLayoutResult {
    }
    export class LineLayoutProcess {
        _layoutLine: LayoutableLine;
        _unitLength: number;
        _minLength: number;
        _spacing: number;
        beginMargin: number;
        endMargin: number;
        endMode: number;
        protected _resultLayoutLines: Array<LayoutableLine>;
        protected _resultNails: Array<LayoutableNailPoint>;
        process(): void;
        static lineOnPoyline(polyline: LayoutablePolyline, unitLength: number, thickness: number, minLength: number, beginMargin: number, endMargin: number, spacing: number, endMode: number): Array<LayoutableLine>;
        static lineOnLine(line: LayoutableLine, unitLength: number, minLength: number, beginMargin: number, endMargin: number, spacing: number, endMode: number, firstLength?: number, stepValue?: number): Array<LayoutableLine>;
        static pointOnLineBySplits(line: LayoutableLine, splits: Array<number>): Array<LayoutablePoint>;
        static pointOnLineSideAvg(line: LayoutableLine, spacing: number, beginMargin: number, endMargin: number): Array<LayoutablePoint>;
        static calculateSplitValues(totalLength: number, spacing: number, minLength: number, beginMargin: number, endMargin: number, endMode: number, stepValue?: number, needBeginMarin?: boolean): Array<number>;
        static pointOnLine(line: LayoutableLine, spacing: number, minLength: number, beginMargin: number, endMargin: number, endMode: number, stepValue?: number): Array<LayoutablePoint>;
        static lineLayout_NO3(): void;
        static setObjEulerByXYZ(obj: ContentBase, axisX: Vector3, axisY: Vector3, axisZ: Vector3): void;
        static assemblyObjByOCS(obj: ContentBase, fromOrigin: Point3, fromXAxis: Vector3, fromYAxis: Vector3, fromZAxis: Vector3, toOrigin: Point3, toXAxis?: Vector3, toYAxis?: Vector3, toZAxis?: Vector3): void;
        static assemblyElementByOCS(element: ContentElement, fromOrigin: Point3, fromXAxis: Vector3, fromYAxis: Vector3, fromZAxis: Vector3, toOrigin: Point3, toXAxis?: Vector3, toYAxis?: Vector3, toZAxis?: Vector3): void;
        static assemblyObjByPointXNormal(obj: ContentBase, normal: Vector3, position: Point3, offsetY: number, offsetZ: number): void;
        static assemblyObjByPointYNormal(obj: ContentBase, normal: Vector3, position: Point3, offsetX: number, offsetZ: number): void;
        static assemblyObjByPointZNormal(obj: ContentBase, normal: Vector3, position: Point3, offsetX: number, offsetY: number): void;
        static assemblyObjByXLine(obj: ContentBase, zAxis: Vector3, yAxis: Vector3, begin: Point3, end: Point3, fromOrigin?: Point3): void;
        static assemblyObjByYLine(obj: ContentBase, zAxis: Vector3, xAxis: Vector3, begin: Point3, end: Point3): void;
        static assemblyObjByZLine(obj: ContentBase, xAxis: Vector3, yAxis: Vector3, begin: Point3, end: Point3): void;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/SurveyLineTypeEnum" {
    export class SurveyLineTypeEnum {
        static outline: string;
        static surveyline: string;
        static workDistanceLine: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/SurveyLineBase" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    import { SurveyLineTypeEnum } from "sk/rule/data/rule/assemble/beam/calculator/SurveyLineTypeEnum";
    export class SurveyLineBase extends FamilyContentBase {
        type: SurveyLineTypeEnum;
        direction: string;
        end: Vector3;
        begin: Vector3;
        constructor(type?: SurveyLineTypeEnum);
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/NailComponent" {
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    export class NailComponent extends FamilyContentBase {
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/EdgeKeelComponent" {
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    import { NailComponent } from "sk/rule/data/rule/assemble/beam/calculator/NailComponent";
    export class EdgeKeelComponent extends FamilyContentBase {
        thickness: number;
        nails: Array<NailComponent>;
        isCloseWall: boolean;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/HardwareTypeEnum" {
    export class HardwareTypeEnum {
        static Leveller: string;
        static EdgeKeel: string;
        static Nail: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/LevelerComponent" {
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    export class LevelerComponent extends FamilyContentBase {
        type: string;
        boltFamilyId: string;
    }
}
declare module "sk/rule/data/rule/assemble/beam/base/PolygonUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class PolygonUtil {
        static getBound(lengthX: number, lengthY: number, x?: number, y?: number): Array<Vector2>;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/PlankComponent" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { HoleData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    export class PlankComponent extends FamilyContentBase {
        polygon: Polygon;
        cutLines: Array<Curve2>;
        holes: HoleData[];
        box: Box2;
        constructor();
        computePolgyon(): void;
        computeBound(): void;
    }
}
declare module "sk/rule/data/rule/assemble/beam/frame/AssemblyBeamParameter" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class AssemblyBeamParameter {
        plankId: string;
        surfacePlankId: string;
        fixedLevelerId: string;
        fixedLevelerIdList: string;
        boltId: string;
        levelerId: string;
        levelerIdList: string;
        levelerList: Array<string>;
        metalLevelerId: string;
        viceKeelId: string;
        edge_Keel_Id: string;
        nailId: string;
        decorateId: string;
        plankSideGap: number;
        plankTopGap: number;
        viceKeelSideGap: number;
        edgeKeelSideGap: number;
        viceKeelArrangeModule: number;
        metalLevelerArrangeModule: number;
        metalLevelerSideGap: number;
        metalLevelerEdgeGap: number;
        nailSideGap: number;
        nailArrangeModule: number;
        faceNailSideGap: number;
        faceNailArrangeModule: number;
        nailDistanceInnerGap: number;
        nailCollisionDistance: number;
        metalLevelerCollisionDistance: number;
        levelerCollisionDistance: number;
        leftFinishDistance: number;
        rightFinishDistance: number;
        bottomFinishDistance: number;
        plankSymbolLength: number;
        plankSymbolWidth: number;
        plankMinLength: number;
        plankThickness: number;
        basePlankThickness: number;
        surfacePlankThickness: number;
        plankDecorateThickness: number;
        levelerArrangeModule: number;
        levelerSideGap: number;
        levelerTopGap: number;
        levelerToBeamEdgeDis: number;
        levelerDiameter: number;
        nailDiameter: number;
        elementBox: ContentBase;
        startContraction: number;
        endContraction: number;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/frame/AssemblyBeamBuilder" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    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 { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { LayerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult";
    import { LayoutSurfaceData } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData";
    import { PlankComponent } from "sk/rule/data/rule/assemble/beam/calculator/PlankComponent";
    import { AssemblyBeamParameter } from "sk/rule/data/rule/assemble/beam/frame/AssemblyBeamParameter";
    import { LayoutSurfaceResult } from "sk/rule/data/rule/assemble/beam/frame/LayoutSurfaceResult";
    export class AssemblyBeamBuilder {
        protected static _calculatorService: CalculatorService;
        static HardwareType: string;
        static createSurfaceElementsAsync(context: ContextObject, parent: ContentElement, surfaceResult: LayoutSurfaceResult, parameters: AssemblyBeamParameter): Promise<ResultObject>;
        static createCompleteElementsAsync(context: ContextObject, parent: AssembleLevelingWallElement, surfaceResult: LayoutSurfaceResult, parameters: AssemblyBeamParameter): Promise<ResultObject>;
        static createDecorateElementAsync(context: ElementPerformerContext, parent: ContentElement, familyInfo: ISpecificationFamilyInfo, decorate: LayerLayoutResult, offset: number, layoutSurfaceData: LayoutSurfaceData): Promise<ResultObject>;
        static createContationer(parent: ContentElement, name: string, identifier: number, drawingCodes: string): ContainerElement;
        static createLayersContationers(element: ContentElement, paramters: AssemblyBeamParameter): TypeMap<string, ContainerElement>;
        static createSurfaceContationer(element: ContentElement): ContainerElement;
        static setContainerLocation(container: ContentElement, toOgrin: Vector3, toXAxis?: Vector3, toYAxis?: Vector3, toZAxis?: Vector3): void;
        static assemblyObjByOCS(obj: ContentBase, toXAxis?: Vector3, toYAxis?: Vector3, toZAxis?: Vector3): void;
        private static choiceLeveller;
        private static choiceLevellerFromIds;
        private static choiceNail;
        private static createSurveyLine;
        static setElementShape(content: ContentBase, element: ContentElement): void;
        static getElementInfoAsync(context: ContextObject, familyId: string): Promise<RuleProcesResult>;
        static createElementAsync(context: ContextObject, parent: ContentElement, familyInfo: ISpecificationFamilyInfo, plank?: PlankComponent): Promise<ResultObject<FamilyInstanceElement>>;
        static addPlankHoleMilling(plankElement: FamilyInstanceElement, plank: PlankComponent): void;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLevelerLayoutResult" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { LayerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult";
    export class LayerLevelerLayoutResult extends LayerLayoutResult {
        levelers: Array<Array<ContentBase>>;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutConverter" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { LayerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult";
    import { LayerLevelerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLevelerLayoutResult";
    export class LayoutConverter {
        static findContainer(assembleWall: AssembleLevelingWallElement): any;
        static convertAllEdgeKeels(container: ContentElement): LayerLevelerLayoutResult;
        static convertAllLevellers(container: ContentElement): LayerLevelerLayoutResult;
        static convertAllPlanks(container: ContentElement): LayerLayoutResult;
        private static convertPlankDate;
        private static getHoleDatas;
        private static createHoleData;
    }
}
declare module "sk/rule/data/rule/levelinglayout/keellayout/KeelLayoutData" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { ReferenceLineData } from "sk/rule/data/rule/levelinglayout/ReferenceLineCalculator";
    export class LayoutLayerTypeEnum {
        static Base: string;
        static Surface: string;
        static Decorate: string;
    }
    export class KeelLayoutData {
        position: Vector3;
        rotation: Vector3;
        area: AreaData;
        wallStartOffsetX: number;
        wallEndOffsetX: number;
        baseStartOffsetX: number;
        baseEndOffsetX: number;
        baseEndOffsetY: number;
        baseStartOffsetY: number;
        surfaceStartOffsetX: number;
        surfaceEndOffsetX: number;
        surfaceEndOffsetY: number;
        surfaceStartOffsetY: number;
        decorateStartOffsetX: number;
        decorateEndOffsetX: number;
        decorateEndOffsetY: number;
        decorateStartOffsetY: number;
        lines?: Array<ReferenceLineData>;
        lengthZ: number;
        layoutDirection: Vector3;
        layoutOption: LayoutOption;
    }
    export class QuadratePipeLayoutTypeEnum {
        static NULL: number;
        static LEFT: number;
        static RIGHT: number;
        static BOTH: number;
    }
    export class LayoutOption {
        survey: boolean;
        leverler: boolean;
        basePlank: boolean;
        surfacePlank: boolean;
        decorate: boolean;
        constructor();
    }
    export enum KeelLayoutTypeEnum {
        Ceiling = 1,
        NULL = 2
    }
    export type AreaData = {
        idx: number;
        width: number;
        height: number;
        holes: HoleData[];
        decorate?: DecorateData;
        reflines?: Array<RefLine>;
        columns?: Array<ColumnData>;
        surfaceColumns?: Array<ColumnData>;
    };
    export type ColumnData = {
        idx: number;
        x: number;
        width: number;
        height: number;
        holes: Array<HoleData>;
        planks?: Array<PlankData>;
        reflines?: Array<RefLine>;
        area: AreaData;
        isLeft: boolean;
        isRight: boolean;
        hasLeveller: boolean;
        innerLeft: number;
        innerRight: number;
    };
    export type DecorateData = {
        width: number;
        height: number;
        polygon?: Array<Vector2>;
        x: number;
        y: number;
    };
    export type PlankData = {
        idx: number;
        y: number;
        wx: number;
        wy: number;
        width: number;
        height: number;
        column: ColumnData;
        isTop?: boolean;
        isRight?: boolean;
        innerLeft?: number;
        innerRight?: number;
        innerTop?: number;
        innerBottom?: number;
        holes?: Array<HoleData>;
        cutLines?: Array<Curve2>;
        params?: any;
    };
    export enum PlankCutEnum {
        Null = 0
    }
    export type HoleData = {
        node: FamilyInstanceNode;
        x: number;
        y: number;
        type: HoleTypeEnum;
        width: number;
        height: number;
        startSpaceX: number;
        endSpaceX: number;
        startSpaceY: number;
        endSpaceY: number;
        marginStartX?: number;
        marginEndX?: number;
        marginStartY?: number;
        marginEndY?: number;
        position?: HolePositionTypeEnum;
    };
    export enum HoleTypeEnum {
        HOLE_BEAM = 1
    }
    export enum HolePositionTypeEnum {
        LEFT = 1,
        LEFT_TOP = 2,
        LEFT_CENTER = 3,
        LEFT_BOTTOM = 4,
        RIGHT = 5,
        RIGHT_TOP = 6,
        RIGHT_CENTER = 7,
        RIGHT_BOTTOM = 8,
        TOP_CENTER = 9,
        BOTTOM_CENTER = 10
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/DecorateComponent" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    export class DecorateComponent extends FamilyContentBase {
        polygon: Array<Vector2>;
        clipLines: Array<LineCurve2d>;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/ViceKeelComponent" {
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    export class ViceKeelComponent extends FamilyContentBase {
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayerSurveyResult" {
    import { LayerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult";
    export class LayerSurveyResult extends LayerLayoutResult {
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { HoleData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { AssemblyBeamLayerTypeEnum } from "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamLayerTypeEnum";
    import { EdgeKeelComponent } from "sk/rule/data/rule/assemble/beam/calculator/EdgeKeelComponent";
    import { PlankComponent } from "sk/rule/data/rule/assemble/beam/calculator/PlankComponent";
    import { LayerLayoutResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerLayoutResult";
    import { LayerSurveyResult } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayerSurveyResult";
    import { LayoutKeelParameter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutKeelParameter";
    import { LayoutPlankParameter } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutPlankParameter";
    import { LayoutSurfaceData } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData";
    export class LayoutUtil {
        static layoutBasePlank(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        static layoutSimpleBasePlank(layoutSurface: LayoutSurfaceData, layer: AssemblyBeamLayerTypeEnum): ResultObject<LayerLayoutResult>;
        protected static separatelengthByHoles(lengthAll: number, holes: HoleData[], plankSymbolLength: number, minLength: number, levelerModule: number, plankHeigh: number, topGap: number, startStep: number): any;
        protected static separatelengthByHolesFace(lengthAll: number, holes: HoleData[], plankHeigh: number, topGap: number, holeRetract: boolean[], startStep: number): any;
        static separateAvoidHoleFront(point: number, lineParts: Array<number>, holeFrontPoint: number, plankSymbolLength: number, minLength: number, levelerModule: number, startPoint: Array<number>): void;
        static sortNumber(a: any, b: any): any;
        static sortHole(a: any, b: any): any;
        protected static addHoles(layoutSurface: LayoutSurfaceData, plank: PlankComponent, topGap: number, isface?: boolean): void;
        private static setLocalHolePosition;
        static layoutFacePlank(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        static layoutLeveler(layoutSurface: LayoutSurfaceData, planks: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static setLevelerSize(diameter: number, depth: number, elements: Array<ContentBase>): void;
        static setMetalLevelerSize(diameter: number, positionZ: number, depth: number, elements: Array<ContentBase>): void;
        static splitLevelers(startStep: number, remainLength: number, levelerModule: number, collisionDistance: number): Array<number>;
        static splitLevelersConsiderHoles(startStep: number, endStep: number, levelerModule: number, collisionDistance: number, planks: PlankComponent[], holes: Array<number>): Array<number>;
        static layoutSideLevelerByPlank(layoutSurface: LayoutSurfaceData, plankResult: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static layoutSideLeveler(layoutSurface: LayoutSurfaceData, planks: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        private static inHoles;
        private static isBehindHoles;
        static computeLevelerNail(layoutSurface: LayoutSurfaceData, levelerResult: LayerLayoutResult, plankResult: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static computeFaceNail(layoutSurface: LayoutSurfaceData, plankResult: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static computeSurvey(layoutSurface: LayoutSurfaceData, levelerResult: LayerLayoutResult, edgeKeelResult?: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static computeDecorate(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        static calculateLine(layoutSurface: LayoutSurfaceData, levelerResult: LayerLayoutResult, layoutSurvey: LayerSurveyResult): void;
        private static createEdgeKeelLine;
        static calculateOutline(layoutSurface: LayoutSurfaceData, layoutSurvey: LayerSurveyResult): void;
        static layoutMetalLeveler(layoutSurface: LayoutSurfaceData, planks: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static layoutMetalKeels(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        static layoutBeamKeels(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        static layoutViceKeel(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        static layoutEdgeKeels(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        static layoutBeamEdgeKeels(layoutSurface: LayoutSurfaceData): ResultObject<LayerLayoutResult>;
        private static computeCrossEdgeKeelNail;
        static computeEdgeKeelNail(layoutSurface: LayoutSurfaceData, edgeKeelResult: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static judgeKeelRelativePos(keel: EdgeKeelComponent, parameters_base: LayoutPlankParameter, parameters_keel: LayoutKeelParameter): void;
        static computeCrossBeamKeelNail(layoutSurface: LayoutSurfaceData, keelResult: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        static computeBasePlankNail(layoutSurface: LayoutSurfaceData, keelResult: LayerLayoutResult, plankResult: LayerLayoutResult): ResultObject<LayerLayoutResult>;
        private static splitLengthToSpace;
        private static buildHoleBelowNails;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamCBottomSurfaceCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { LayoutSurfaceData } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData";
    export class AssemblyCBottomSurfaceCalculator {
        constructor();
        calculateComponent(surfaceLayoutData: LayoutSurfaceData, buildType: BuildStructureTypeEnum): ResultObject;
        completionComponent(surfaceLayoutData: LayoutSurfaceData, assembleWall: AssembleLevelingWallElement): ResultObject;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamLBottomSurfaceCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { LayoutSurfaceData } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData";
    export class AssemblyLBottomSurfaceCalculator {
        constructor();
        calculateComponent(surfaceLayoutData: LayoutSurfaceData, buildType: BuildStructureTypeEnum): ResultObject;
        completionComponent(surfaceLayoutData: LayoutSurfaceData, assembleWall: AssembleLevelingWallElement): ResultObject;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/AssemblyBeamSideSurfaceCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { LayoutSurfaceData } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData";
    export class AssemblySideSurfaceCalculator {
        constructor();
        calculateComponent(surfaceLayoutData: LayoutSurfaceData, buildType: BuildStructureTypeEnum): ResultObject;
        completionComponent(surfaceLayoutData: LayoutSurfaceData, assembleWall: AssembleLevelingWallElement): ResultObject;
        private cutHole;
        private cutPlank;
    }
}
declare module "sk/rule/data/rule/assemble/beam/CrossAssembleBeamElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class CrossAssembleBeamElementUtil {
        static findCrossAssembleBeamElementAsync(assembleBeams: AssembleBeamElement[], assembleContext?: AssembleRoomContext, beams?: BeamNode[], room?: RoomNode): Promise<ResultObject>;
        static judgeCross(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): boolean;
        static isParallel(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): boolean;
        static boxToVector3Array(box: BoundaryBox): Vector3[];
        private static coincidePointCount;
        static boxToPolygonCurve2d(box: BoundaryBox): PolygonCurve2d;
        static findLowerBeam(assemblebeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): boolean;
        static getBeamInfoOnLine(beam: AssembleBeamElement, line: Line2, polygon?: Vector2[]): any;
        static computeAssembelBeamHole(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): void;
        static getAssembleBeamInfoOnLineAutoLong(assembleBeam: AssembleBeamElement, line: Line2): any;
        static getBeamHoleData(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement, x: number, subLine: Line2, relativeRotate: number): any;
        static changeHeightBeamButtomCavity(assembelBeamLow: AssembleBeamElement, hole: any, assembelBeamHeigh: AssembleBeamElement, heightGap: number): void;
        static separateAssembleBeamElementByHoles(frontAssembleBeam: AssembleBeamElement, backAssembleBeam: AssembleBeamElement, hole: any): void;
        static crossAssembleBeamElementUpdate(assembleBeam: AssembleBeamElement): void;
        private static getCrossAssembleBeamData;
        private static findAssembleBeamsInSameRoom;
        static heighAssembleBeamElementUpdate(assembleBeam: AssembleBeamElement): void;
        static lowAssembleBeamElementUpdate(assembleBeam: AssembleBeamElement): void;
        static updateAssembleBeamHoles(assembleBeam: AssembleBeamElement): void;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleBeamElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { AssemblyBeamParameter } from "sk/rule/data/rule/assemble/beam/frame/AssemblyBeamParameter";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class AssembleBeamElementUtil {
        static createAssembleBeamsByRoomAsync(assembleContext: AssembleRoomContext, room: RoomNode): Promise<Array<AssembleBeamElement>>;
        static createAssembleBeamAsync(assembleContext: AssembleRoomContext, beam: BeamNode, room: RoomNode): Promise<ResultObject>;
        static creatAssembleBeamElement(assembleContext: AssembleRoomContext, beam: BeamNode): any;
        static creatAssembleBeamElementAllPlankAsync(assembleContext: AssembleRoomContext, beam: BeamNode, polygon: Vector2[], assembleBeam: AssembleBeamElement, room: RoomNode): Promise<ResultObject>;
        private static findCeilingThickness;
        private static lineIsOnPolygon;
        static isSegmentsOverlapped(point1: Value2, point2: Value2, point3: Value2, point4: Value2, tolerance?: number): boolean;
        static setAssembleBeamProperty(assembleBeam: AssembleBeamElement): void;
        static createAssembleBeamPlankAsync(assembleContext: AssembleRoomContext, assembleBeam: AssembleBeamElement, beam: BeamNode, idx: number, ceilingThickness?: number): Promise<ResultObject>;
        private static setLevelingWallElementGeo;
        static updateAssembleBeamPlankAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject>;
        static updateAssembleBeamAsync(context: ElementPerformerContext, assembleBeam: AssembleBeamElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateBeamPlankAsync(context: ElementPerformerContext, element: LevelingWallElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static getFamilyInfoParamsFromLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject<AssemblyBeamParameter>>;
        static getParamsFromLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject<AssemblyBeamParameter>>;
        static buildBeamPlankAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static buildBeamPlankTechnologyAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        private static getBoxCalculateParameter;
        private static arrangeCBottomLayoutParamters;
        private static arrangeLBottomLayoutParamters;
        private static arrangeSideLayoutParamters;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingModelCalculator" {
    export class AssemblyCeilingModelCalculator {
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/ArrangeIteratorTool" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    export class ArrangeIteratorTool {
        static pointOnLine(step: number, minUnit: number, layoutline: LayoutableLine): Array<Point3>;
        static lintOnFixPointStartToEnd(axis: Vector3, minLength: number, maxLength: number, iteratorPoints: Array<Vector3>, iteratorRiskPoints?: Array<Vector3>, isFromStart?: boolean): Array<Vector3>;
        static pointOnFixPoint(axis: Vector3, start: Vector3, end: Vector3, minLength: number, maxLength: number, points: Array<Vector3>, riskPoints?: Array<Vector3>, isFromStart?: boolean): Array<Vector3>;
        static layoutableLineFromVector(points: Array<Vector3>, offset?: Vector3, beginOffset?: boolean, endOffset?: boolean): Array<LayoutableLine>;
        private static isOnRiskPoint;
        static cutNumber(totalLength: number, step: number, endMinLength?: number): Array<number>;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeParamers" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export type CeilingEdgeParamers = {
        thickness: number;
        straightWareId: string;
        straightWareWidth: number;
        straightWareHeight: number;
        straightWareStandardLength: number;
        straightWareMinLength: number;
        cornerWareId: string;
        cornerWareWidth: number;
        cornerWareHeight: number;
        cornerWareThickness: number;
        ceilingClipKeelId: string;
        ceilingClipKeelThick: number;
        ceilingClipKeelWidth: number;
        ceilingClipKeelSTLength: number;
        ceilingClipKeelHeight: number;
        ceilingClipKeelMinLength: number;
        ceilingclipKeelStepRuleValue: number;
        ceilingclipKeelArrangeParralelEndRemain: number;
        ceilingclipKeelArrangeVerticalEndRemain: number;
        ceilingclipKeelClawCenterToEndValue: number;
        ceilingclipKeelSteeveToKeelEndValue: number;
        ceilingclipKeelSteeveModule: number;
        hangingPlankId: string;
        hangingPlankStandardWidth: number;
        hangingPlankStandardHeight: number;
        hangingPlankThickness: number;
        hangingPlankMinLength: number;
        hangingPlaneNail2Side: number;
        hangingPlaneNail2End: number;
        hangingPlaneNailMoudle: number;
        hangingPlaneNailMinGap: number;
        ceilingEdgeKeelId: string;
        ceilingEdgeKeelHeight: number;
        ceilingEdgeKeelUpWidth: number;
        ceilingEdgeKeelDownWidth: number;
        ceilingEdgeKeelStandardLength: number;
        ceilingEdgeKeelThick: number;
        ceilingEdgeKeelMinLength: number;
        ceilingEdgeKeelNail2End: number;
        ceilingEdgeKeelNailModule: number;
        ceilingEdgeKeelNailMinGap: number;
        angleKeelID: string;
        angleKeelWidth: number;
        angleKeelHeight: number;
        angleKeelThickness: number;
        angleKeelStandardLength: number;
        angleKeelMinLength: number;
        angleKeelBolt2Side: number;
        angleKeelBolt2End: number;
        angleKeelBoltMoudle: number;
        angleKeelBoltMinGap: number;
        ceilingViceKeelId: string;
        ceilingViceThick: number;
        ceilingViceHeight: number;
        ceilingViceSTLength: number;
        ceilingViceWidth: number;
        ceilingViceSideLength: number;
        horizontalConnectionId: string;
        horizontalConnectionLength: number;
        horizontalConnectionHeight: number;
        horizontalConnectionWidth: number;
        horizontalConnectionThick: number;
        viceKeelHangingID: string;
        viceKeelHangingLengthX: number;
        viceKeelHangingLengthY: number;
        viceKeelHangingLengthZ: number;
        viceKeelHangingThick: number;
        viceKeelHanging2plankLappedConnection: number;
        viceKeelHanging2plankStraightConnection: number;
        viceKeelHangingModule: number;
        viceKeelHangingMinGap: number;
        viceKeelHangingNail2HangingPlaneSide: number;
        plankStraightConnectionID: string;
        plankStraightConnectionLengthX: number;
        plankStraightConnectionLengthY: number;
        plankStraightConnectionLengthZ: number;
        plankLappedConnectionID: string;
        plankLappedConnectionLengthX: number;
        plankLappedConnectionLengthY: number;
        plankLappedConnectionLengthZ: number;
        ceilingPlasterPlankId: string;
        ceilingPlasterPlankThick: number;
        ceilingPlasterPlankSTWidth: number;
        ceilingPlasterPlankSTLength: number;
        ceilingPlasterPlankMinWidth: number;
        ceilingPlasterPlankMinLength: number;
        screw6BoltId: string;
        screw8BoltId: string;
        clipKeelSteeveId: string;
        dryWallNail25Id: string;
        nail25Id: string;
        decorateFaceId: string;
        lowerWidthD: number;
        mgrgBottomWidthM: number;
        mgrgBottomWidthM1: number;
        lowerToCeilingHeight: number;
        angleKeelBegin2Wall: number;
        angleKeelEnd2Wall: number;
        buildType: BuildStructureTypeEnum;
    };
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeCalculatorInput" {
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { CeilingEdgeParamers } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeParamers";
    export class AssemblyCeilingEdgeCalculatorInput {
        thickness: number;
        polySurface: LayoutablePolySurface;
        params: CeilingEdgeParamers;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeCalculatorOutput" {
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { LoDbPlank } from "sk/rule/data/rule/layout/entitys/LoDbPlank";
    import { LoDbReferenceLine } from "sk/rule/data/rule/layout/entitys/LoDbReferenceLine";
    export class AssemblyCeilingEdgeCalculatorOutput {
        edgeKeels: Array<LoDbEntity>;
        nail25s: Array<LoDbEntity>;
        topAngleKeels: Array<LoDbEntity>;
        bolts: Array<LoDbEntity>;
        ceilingPlanks: Array<LoDbEntity>;
        plankStraightConnections: Array<LoDbEntity>;
        plankLappedConnections: Array<LoDbEntity>;
        viceKeelHangings: Array<LoDbEntity>;
        viceKeels: Array<LoDbEntity>;
        straightConnectionBasePlates: Array<LoDbEntity>;
        horizontalConnections: Array<LoDbEntity>;
        basedPlanks: Array<LoDbPlank>;
        surfacePlanks: Array<LoDbPlank>;
        clipKeels: Array<LoDbEntity>;
        clipKeelSteeves: Array<LoDbEntity>;
        layer: Array<LoDbEntity>;
        referenceLines: Array<LoDbReferenceLine>;
        constructor();
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgePolygonLayoutData" {
    import { CeilingEdgeHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/assemble/ceiling/CeilingEdgeHoldTypeEnum';
    import { AssembleCeilingEdgeElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class CeilingEdgePolygonLayoutData extends ContentBase {
        prev: AssembleCeilingEdgeElement;
        next: AssembleCeilingEdgeElement;
        leftHoldType: CeilingEdgeHoldTypeEnum;
        rightHoldType: CeilingEdgeHoldTypeEnum;
        edgeWidth: number;
        conactLength: number;
        keelOutLength: number;
        isLongSide: boolean;
        identifier: number;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { AssemblyCeilingModelCalculator } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingModelCalculator";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { AssemblyCeilingEdgeCalculatorInput } from "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeCalculatorInput";
    import { AssemblyCeilingEdgeCalculatorOutput } from "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeCalculatorOutput";
    import { CeilingEdgeParamers } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeParamers";
    import { CeilingEdgePolygonLayoutData } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgePolygonLayoutData";
    export class PlasterPlank {
        origin: Vector3;
        lengthX: number;
        lengthY: number;
        nailsLines: Array<LayoutableLine>;
        constructor(origin?: Vector3, lengthX?: number, lengthY?: number);
    }
    export class AssemblyCeilingEdgeCalculator extends AssemblyCeilingModelCalculator {
        input: AssemblyCeilingEdgeCalculatorInput;
        output: AssemblyCeilingEdgeCalculatorOutput;
        inputParams: CeilingEdgeParamers;
        layoutData: CeilingEdgePolygonLayoutData;
        private viceKeelIdentifier;
        private angleKeelIdentifier;
        private edgeKeelIdentifier;
        private hangingPlankIdentifier;
        private clipKeelIdentifier;
        calculateLayerComponent(input: AssemblyCeilingEdgeCalculatorInput, output: AssemblyCeilingEdgeCalculatorOutput): ResultObject;
        calculateComponent(input: AssemblyCeilingEdgeCalculatorInput, output: AssemblyCeilingEdgeCalculatorOutput): ResultObject;
        private calculateSimplifyBasePlank;
        private calculateSimplifySurfacePlank;
        private calculateEdgeKeels;
        private calculateKeelNails;
        private calculateOutsideEdgeKeels;
        private calculateFixedKeels;
        private calculateSurveyFromLayoutableLine;
        private calculateSurveyFromPoint;
        private calculateBolts;
        private calculateHangingPlanks;
        private calculateStraightConnection;
        private calculateLappedConnection;
        private calculateViceKeelHangings;
        private calculateViceKell;
        private calculateViceKeelCorner;
        private calculateViceKeelBeginCorner;
        private calculateViceKeelEndCorner;
        calculateViceKeelOverhang(viceKeelPoints: Array<Vector3>): void;
        calculateBasePlasterPlanks(viceKeelPoints: Array<Vector3>): void;
        calculateSufacePlasterPlanks(viceKeelPoints: Array<Vector3>, riskPoints: Array<Vector3>): void;
        calculateClipKeels(viceKeelPoints: Array<Vector3>): void;
        calculateClipViceSteeves(layoutline: LayoutableLine): void;
        calcualteBasePlasterPlankNail(plasterPlank: PlasterPlank): void;
        calcualteSurfacePlasterPlankNail(plasterPlank: PlasterPlank): void;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeModelProcess" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { AssemblyCeilingEdgeCalculatorInput } from "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeCalculatorInput";
    import { AssemblyCeilingEdgeCalculatorOutput } from "sk/rule/data/rule/lappedceilinglayout/edge/AssemblyCeilingEdgeCalculatorOutput";
    import { CeilingEdgeParamers } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeParamers";
    import { CeilingEdgePolygonLayoutData } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgePolygonLayoutData";
    export class AssemblyCeilingEdgeModelProcess {
        protected _schemeConfigService: SchemeConfigService;
        protected _calculatorService: CalculatorService;
        layoutData: CeilingEdgePolygonLayoutData;
        buildAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, layoutData: CeilingEdgePolygonLayoutData, params: CeilingEdgeParamers): Promise<RuleProcesResult>;
        buildLayerAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, layoutData: CeilingEdgePolygonLayoutData, params: CeilingEdgeParamers): Promise<RuleProcesResult>;
        calculateLayerProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: AssemblyCeilingEdgeCalculatorInput): Promise<RuleProcesResult>;
        calculateProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: AssemblyCeilingEdgeCalculatorInput): Promise<RuleProcesResult>;
        outputProcessAsync(context: ElementPerformerContext, calculatorInput: AssemblyCeilingEdgeCalculatorInput, calculatorOutput: AssemblyCeilingEdgeCalculatorOutput, input: RuleProcessInput, output: RuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeBuilder" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { CeilingEdgeParamers } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeParamers";
    import { CeilingEdgePolygonLayoutData } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgePolygonLayoutData";
    export class CeilingEdgeBuilder {
        private layoutData;
        private params;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: CeilingEdgePolygonLayoutData, params: CeilingEdgeParamers);
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcesResult>;
        buildLayerAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/AssembleCeilingDataUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { CeilingEdgeHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/assemble/ceiling/CeilingEdgeHoldTypeEnum';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ComponentPatternElement } from 'sk/data/family/element/pattern/ComponentPatternElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PatternLinkTypeEnum } from 'sk/data/family/enumeration/PatternLinkTypeEnum';
    import { ColumnNode } from 'sk/data/scheme/database/floorplan/model/ColumnNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { AssembleCeilingAreaElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingAreaElement';
    import { AssembleCeilingEdgeElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement';
    import { AssembleCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingElement';
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    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 { ProductLinkEnum } from 'sk/data/logic/module/enumeration/ProductLinkEnum';
    export type AssembleCeilingEdgeInfo = {
        antiClockwise?: boolean;
        defaultFamilyId: string;
        defaultFamilyInfo?: ISpecificationFamilyInfo;
        code: string;
    };
    export type AssembleCeilingPlaneInfo = {
        defaultFamilyId: string;
        defaultFamilyInfo?: ISpecificationFamilyInfo;
        code: string;
    };
    class AssembleCeilingBaseData {
        typeCd: PatternLinkTypeEnum;
        productCd: ProductLinkEnum;
        componentElement: ComponentElement;
        infoId: string;
    }
    export class AssembleCeilingPlaneData extends AssembleCeilingBaseData {
        x: number;
        y: number;
        polygon: Line2[];
        info: AssembleCeilingPlaneInfo;
        constructor();
        static getPlaneInfoByPlaneElementAsync(context: ElementPerformerContext, planeElement: AssembleCeilingPlaneElement): Promise<ResultObject<AssembleCeilingPlaneInfo>>;
        static createDataByPlaneElementAsync(context: ElementPerformerContext, planeElement: AssembleCeilingPlaneElement): Promise<ResultObject<AssembleCeilingPlaneData>>;
    }
    export class AssembleCeilingEdgeData extends AssembleCeilingBaseData {
        finish: number;
        width: number;
        begin: Vector2;
        end: Vector2;
        finishLine: Line2;
        leftCornerType: CornerTypeEnum;
        rightCornerType: CornerTypeEnum;
        leftHoldType: CeilingEdgeHoldTypeEnum;
        rightHoldType: CeilingEdgeHoldTypeEnum;
        clockwise: boolean;
        private _thickness;
        ceilingLine: Line2;
        info: AssembleCeilingEdgeInfo;
        leftOffset: number;
        rightOffset: number;
        constructor(edgeElement?: any, line?: Line2, origin?: Value2);
        static getEdgeInfoByEdgeElementAsync(context: ElementPerformerContext, edgeElement: AssembleCeilingEdgeElement): Promise<ResultObject<AssembleCeilingEdgeInfo>>;
        static createDataByEdgeElementAsync(context: ElementPerformerContext, edgeElement: AssembleCeilingEdgeElement): Promise<ResultObject<AssembleCeilingEdgeData>>;
        get thickness(): number;
    }
    export class AssembleCeilingAreaData {
        polygon: Line2[];
        _lengthX: number;
        _lengthY: number;
        lengthZ: number;
        _x: number;
        _y: number;
        clockwise: boolean;
        element?: AssembleCeilingAreaElement;
        edges: AssembleCeilingEdgeData[];
        plane: AssembleCeilingPlaneData;
        constructor(origin: Value2);
        private computeLength;
        get x(): number;
        get y(): number;
        get lengthX(): number;
        get lengthY(): number;
    }
    export class AssembleCeilingData extends AssembleCeilingBaseData {
        edgeTypeCd: PatternLinkTypeEnum;
        planeTypeCd: PatternLinkTypeEnum;
        edgeProductCd: ProductLinkEnum;
        planeProductCd: ProductLinkEnum;
        edgeInfoId: string;
        planeInfoId: string;
        edgeComponentElement: ComponentElement;
        planeComponentElement: ComponentElement;
        position: Vector3;
        lengthX: number;
        lengthY: number;
        points: Vector2[];
        edgeInfo: AssembleCeilingEdgeInfo;
        planeInfo: AssembleCeilingPlaneInfo;
        clockwise: boolean;
        areas: AssembleCeilingAreaData[];
        constructor(ceilling: Value2[][] | AssembleCeilingElement);
        get lengthZ(): number;
    }
    export class AssembleCeilingDataUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        protected static _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        static margeLineForPoygon(polygon: Line2[]): void;
        private static isPointOnLine;
        static setPropertyByCeilingData(ceilingElement: AssembleCeilingElement, ceilingData: AssembleCeilingData): void;
        static appendPolygonByPlaneElement(planeData: AssembleCeilingPlaneData, planeElement: AssembleCeilingPlaneElement): void;
        static appendPolygonByPlaneData(planeElement: AssembleCeilingPlaneElement, planeData: AssembleCeilingPlaneData): void;
        static createEdgeDatas(ceilingData: AssembleCeilingData, areaData: AssembleCeilingAreaData, areaElement?: AssembleCeilingAreaElement): void;
        static isLineOnLine(line1: Line2, line2: Line2, join?: boolean): boolean;
        static createPlaneData(ceilingData: AssembleCeilingData, areaData: AssembleCeilingAreaData, areaElement?: AssembleCeilingAreaElement): void;
        static computePlanePolygon(areaData: AssembleCeilingAreaData): void;
        static getLineInfos(wallSurface: WallSurfaceNode): {
            line: Line2;
            isOnColumn: boolean;
        }[];
        static getColumnPointInfosList(columns: Types<ColumnNode>, line: Line2): {
            outerPoint: Vector2;
            linePoint: Vector2;
        }[][];
        private static getSortPointByLine;
        private static getSortPointsByLine;
        static computeFinishLine(option: {
            remain: AssembleCeilingEdgeData;
            last: AssembleCeilingEdgeData;
            next: AssembleCeilingEdgeData;
            lastCornerType: CornerTypeEnum;
            nextCornerType: CornerTypeEnum;
        }): void;
        static getRectInfoByPolygon(polygon: Line2[] | Value2[]): {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        static getSpecificationFamilyInfoByFamilyIdAsync(context: ElementPerformerContext, familyId: string): Promise<ResultObject<ISpecificationFamilyInfo>>;
        static getComponentPatternElementByPatternInfoIdAsync(context: ElementPerformerContext, patternInfoId: string): Promise<ResultObject<ComponentPatternElement>>;
        static loadPatternElementByPatternInfoIdAsync(context: ElementPerformerContext, ceilingData: AssembleCeilingData, patternInfoId: string): Promise<ResultObject>;
        static getInfoByLinkerPatternElementAsync(context: ElementPerformerContext, linkerPatternElement: LinkerPatternElement): Promise<ResultObject<{
            infoId: string;
            componentElement?: ComponentElement;
            productLinkCd?: ProductLinkEnum;
        }>>;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssembleCeilingPreFabricate" {
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    export class AssemblyPreFabracate extends AssemblyCeilingContentBase {
        type: string;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingClipKeel" {
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    export class AssemblyCeilingClipKeel extends AssemblyCeilingContentBase {
        poles: Array<AssemblyCeilingContentBase>;
        constructor();
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingEdgeKeel" {
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    export class AssemblyCeilingEdgeKeel extends AssemblyCeilingContentBase {
        nails: Array<AssemblyCeilingContentBase>;
        constructor();
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/ArrangeCollisionTool" {
    export class Refline {
        type: string;
        min: number;
        max: number;
        isPositive?: boolean;
    }
    export class ArrangeCollisionTool {
        reflines: Array<Refline>;
        checkOffset: number;
        checkOffsetInner: number;
        checkOffsetOuter: number;
        current: number;
        constructor(reflines: Array<Refline>, param?: any);
        add(current: number, isPositive: boolean, startStep: number, stepDirection: boolean): number;
        private isInRange;
        private isInDirectionRange;
        private checkReflines;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingPolygonUtil" {
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { Refline, ArrangeCollisionTool } from "sk/rule/data/rule/ceilinglayout/calculator/ArrangeCollisionTool";
    export class AssemblyCeilingPolygonUtil {
        static calculatePolygonReflines(layoutSurface: LayoutablePolySurface, isHorizontal: boolean): Array<Refline>;
        static calculatePolygonDataReflines(layoutSurface: PolygonKeelLayoutData, isHorizontal: boolean): Array<Refline>;
        static calculateRefline(num: number): Refline;
        static addOnlyRefline(reflines: Array<Refline>, num: number): any;
        static addOneValue(tool: ArrangeCollisionTool, spaces: Array<number>, current: number, step: number, max?: number): number;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingViceKeel" {
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    export class AssemblyCeilingViceKeel extends AssemblyCeilingContentBase {
    }
}
declare module "sk/rule/data/rule/levelinglayout/keellayout/PolygonCeilingLayoutDataCalculator" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { KeelLayoutParamers, PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    export class PolygonCeilingLayoutDataCalculator {
        layoutData: PolygonKeelLayoutData;
        surfaceLayoutData: PolygonKeelLayoutData;
        private params;
        constructor(layoutData: PolygonKeelLayoutData, params: KeelLayoutParamers, surfaceLayoutData?: PolygonKeelLayoutData);
        caclulate(): RuleProcesResult;
        private getRefLines;
        private getDirectionRefLines;
        private getBaseRefLines;
        private computePlank;
        private computeSurfacePlank;
        private computeBaseRefLines;
        private cutColumns;
        private cutRows;
        private createPlanksByNumbers;
        private getPlankLocalHoles;
        private cutPlank;
        private addPlankData;
        private convertPolygonToRegion;
        private isPointInPlank;
        private isPointsOnPlankSameSide;
    }
}
declare module "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutDataCalculator" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { KeelLayoutParamers, PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    export class PolygonKeelLayoutDataCalculator {
        layoutData: PolygonKeelLayoutData;
        private params;
        constructor(layoutData: PolygonKeelLayoutData, params: KeelLayoutParamers);
        caclulate(): RuleProcesResult;
        private getRefLines;
        private getDirectionRefLines;
        private getBaseRefLines;
        private computePlank;
        private computeSurfacePlank;
        private cutColumns;
        private columnRefline;
        private cutRows;
        private createPlanksByNumbers;
        private getPlankLocalHoles;
        private cutPlank;
        private addPlankData;
        private convertPolygonToRegion;
        private isPointInPlank;
        private isPointsOnPlankSameSide;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlaneParamers" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export type CeilingPlaneParamers = {
        preFabricateLineId: string;
        preFabricateInnerId: string;
        preFabricateOuterId: string;
        ceilingEdgeKeelId: string;
        ceilingClipKeelId: string;
        ceilingViceKeelId: string;
        ceilingPlasterPlankId: string;
        horizontalConnectionId: string;
        viceKeelConnectionId: string;
        dryWallNailId: string;
        screwBoltId: string;
        clipKeelSteeveId: string;
        decorateFaceId: string;
        fabricatedSurfaceExtractDis: number;
        fabricatedBottomExtractDis: number;
        preFabricateLineWidth: number;
        preFabricateInnerWidth: number;
        preFabricateOuterWidth: number;
        preFabricateWidth: number;
        preFabricateHeight: number;
        ceilingEdgeKeelHeight: number;
        ceilingEdgeKeelUpWidth: number;
        ceilingEdgeKeelDownWidth: number;
        ceilingEdgeKeelSTLength: number;
        ceilingEdgeKeelThick: number;
        ceilingClipKeelThick: number;
        ceilingClipKeelWidth: number;
        ceilingClipKeelSTLength: number;
        ceilingClipKeelHeight: number;
        ceilingViceThick: number;
        ceilingViceHeight: number;
        ceilingViceSTLength: number;
        ceilingViceWidth: number;
        ceilingPlasterPlankThick: number;
        ceilingPlasterPlankSTWidth: number;
        ceilingPlasterPlankSTLength: number;
        horizontalConnectionLength: number;
        horizontalConnectionHeight: number;
        horizontalConnectionWidth: number;
        horizontalConnectionThick: number;
        viceKeelConnectionLength: number;
        viceKeelConnectionWidth: number;
        viceKeelConnectionHeight: number;
        viceKeelConnectionThick: number;
        dryWallNailDiameter: number;
        ceilingEdgeKeelEndRemain: number;
        ceilingEdgeKeelMinNailGap: number;
        ceilingEdgeKeelMinLength: number;
        clipKeelStepRuleValue: number;
        clipKeelArrangeParralelEndRemain: number;
        clipKeelArrangeVerticalEndRemain: number;
        clipKeelClawCenterToEndValue: number;
        clipKeelSteeveToKeelEndValue: number;
        clipKeelMinLength: number;
        viceKeelArrangeEndRemain: number;
        viceKeelArrangeMinGap: number;
        viceKeelToEdgeKeelGap: number;
        viceKeelJointMinLength: number;
        adjustmentPlankMinLength: number;
        nailArrangeGapToPlankEdge: number;
        nailArrangeHorionalMinGap: number;
        nailArrangeVerticalMinGap: number;
        surfacePlankGapToWall: number;
        surfacePlankFirstRankCrossGap: number;
        surfacePlankSecondRankCrossGap: number;
        surfacePlankWidthCrossGap: number;
        ceilingEdgeKeelNailModule: number;
        ceilingClipKeelClawModule: number;
        ceilingClipKeelSteeveModule: number;
        ceilingViceKeelModule: number;
        basePlankNailLongitudinalModule: number;
        basePlankNailTransverseModule: number;
        surfacePlankNailTransverseModule: number;
        decorateFaceThickness: number;
        buildType: BuildStructureTypeEnum;
    };
}
declare module "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneCalculatorInput" {
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { CeilingPlaneParamers } from "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlaneParamers";
    export class AssemblyCeilingPlaneCalculatorInput {
        params: CeilingPlaneParamers;
        layoutData: PolygonKeelLayoutData;
        polySurface: LayoutablePolySurface;
        thickness: number;
        element: AssembleCeilingPlaneElement;
        constructor();
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingSurfacePlank" {
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    export class AssemblyCeilingSurfacePlank extends AssemblyCeilingContentBase {
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneCalculatorOutput" {
    import { AssemblyCeilingBasedPlank } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingBasedPlank";
    import { AssemblyCeilingClipKeel } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingClipKeel";
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    import { AssemblyCeilingEdgeKeel } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingEdgeKeel";
    import { AssemblyCeilingSurfacePlank } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingSurfacePlank";
    import { AssemblyCeilingViceKeel } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingViceKeel";
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    export class AssemblyCeilingPlaneCalculatorOutput {
        edgeKeels: Array<AssemblyCeilingEdgeKeel>;
        clipKeels: Array<AssemblyCeilingClipKeel>;
        viceKeels: Array<AssemblyCeilingViceKeel>;
        basedPlanks: Array<AssemblyCeilingBasedPlank>;
        surfacePlanks: Array<AssemblyCeilingSurfacePlank>;
        basedNails: Array<AssemblyCeilingContentBase>;
        surfaceNails: Array<AssemblyCeilingContentBase>;
        keelNails: Array<AssemblyCeilingContentBase>;
        connectionOne: Array<AssemblyCeilingContentBase>;
        poles: Array<AssemblyCeilingContentBase>;
        connectionViceKeel: Array<AssemblyCeilingContentBase>;
        decorateFaces: Array<AssemblyCeilingContentBase>;
        preFabracates: Array<AssemblyCeilingContentBase>;
        referenceLines: Array<ReferencelineInfo>;
        constructor();
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Refline } from "sk/rule/data/rule/ceilinglayout/calculator/ArrangeCollisionTool";
    import { AssemblyCeilingModelCalculator } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingModelCalculator";
    import { KeelLayoutParamers, PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    import { PolygonColumnData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { AssemblyCeilingPlaneCalculatorInput } from "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneCalculatorInput";
    import { AssemblyCeilingPlaneCalculatorOutput } from "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneCalculatorOutput";
    export class AssemblyCeilingPlaneCalculator extends AssemblyCeilingModelCalculator {
        linkKeelLines: Array<LayoutableLine>;
        input: AssemblyCeilingPlaneCalculatorInput;
        output: AssemblyCeilingPlaneCalculatorOutput;
        viceKeelIdentifier: number;
        isUseLayoutData: boolean;
        layoutData: PolygonKeelLayoutData;
        basePolygonData: PolygonKeelLayoutData;
        surfacePolygonData: PolygonKeelLayoutData;
        stylePolygonData: PolygonKeelLayoutData;
        basepolygonSurface: LayoutablePolySurface;
        styleSurface: LayoutablePolySurface;
        surfacepolygonSurface: LayoutablePolySurface;
        polygonSurface: LayoutablePolySurface;
        constructor();
        getExtendsData(offset: number): PolygonKeelLayoutData;
        calculateBasePlank(): void;
        calculateSurfacePlank(): void;
        calcualtePlank(): void;
        calculateStyle(): void;
        getPolygonParams(): KeelLayoutParamers;
        calcualteLayerComponent(input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): ResultObject;
        calculateComponent(input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): ResultObject;
        calcualteSimplifyBasePlank(): void;
        calcualteSimplifySurfacePlank(): void;
        calculateFabricated(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): void;
        calculateHStrenthKeels(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): void;
        calculateHcKeels(layoutSurface: LayoutablePolySurface, viceKeelLines: Array<LayoutableLine>, hcKeelLines: Array<LayoutableLine>, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): void;
        calculateHcKeelLinesByXXYLines(layoutSurface: LayoutablePolySurface, xfLines: Array<LayoutableLine>, xsLines: Array<LayoutableLine>, yLines: Array<LayoutableLine>): Array<LayoutableLine>;
        calculateHcKeelLinesByXYLines(position: Vector3, vLines: Array<LayoutableLine>, hLine: LayoutableLine, isBoundary?: boolean): Array<LayoutableLine>;
        layoutData2xxy(columns: Array<PolygonColumnData>, z?: number): {
            vliness: Array<Array<LayoutableLine>>;
            hlines: Array<LayoutableLine>;
        };
        calculateGapsByLayoutDate(): Array<LayoutableLine>;
        createPlankAndNail(layoutData: PolygonKeelLayoutData, height: number, planks: Array<ContentBase>, nails: Array<ContentBase>, input: AssemblyCeilingPlaneCalculatorInput, prefix: string, isBase: boolean): void;
        calculateNailOnPolySurface(polyArea: LayoutablePolySurface, layoutSurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput, nails: Array<ContentBase>, isSurface: boolean): void;
        calculateNailOnSurface(layoutSurface: LayoutableSurface, input: AssemblyCeilingPlaneCalculatorInput, nails: Array<ContentBase>, isSurface: boolean): void;
        private addViceKeelsOnPolySurfaceOnBoundary;
        calculateHCXXX(layoutSurface: LayoutablePolySurface, vicelines: Array<LayoutableLine>): void;
        calculateViceKeelsOnPolySurface(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): Array<LayoutableLine>;
        calculateEdgeKeelsOnPolySurface(polySurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): void;
        calculateDecorateFace(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): void;
        calculateBoltRefLines(layoutSurface: LayoutablePolySurface, rowKeels: Array<Array<LayoutableLine>>, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): void;
        anlysisClipKeelBeginLocation(length: number): number;
        anlysisClipKeelEndLocation(length: number): number;
        clipKeelLayoutOnLine2(line: LayoutableLine): Array<LayoutableLine>;
        clipKeelLayoutOnLine(line: LayoutableLine): Array<LayoutableLine>;
        calculateClipKeelsOnPolySurface(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): void;
        calcualteClipKeelReflines(layoutSurface: LayoutablePolySurface): Array<Refline>;
        calculateClipKeelsSpacings(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingPlaneCalculatorInput): Array<number>;
        getViceKeelsSpacingsByLayoutData2(input: AssemblyCeilingPlaneCalculatorInput, reflines: Array<Refline>): Array<number>;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneModelProcess" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    import { AssemblyCeilingPlaneCalculatorInput } from "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneCalculatorInput";
    import { AssemblyCeilingPlaneCalculatorOutput } from "sk/rule/data/rule/lappedceilinglayout/plane/AssemblyCeilingPlaneCalculatorOutput";
    import { CeilingPlaneParamers } from "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlaneParamers";
    export class AssemblyCeilingPlaneModelProcess {
        autoPosition: Vector2;
        params: CeilingPlaneParamers;
        output: AssemblyCeilingPlaneCalculatorOutput;
        layoutData: PolygonKeelLayoutData;
        protected _schemeConfigService: SchemeConfigService;
        protected static _calculatorService: CalculatorService;
        buildAsync(context: ElementPerformerContext, layoutData: PolygonKeelLayoutData, params: CeilingPlaneParamers, element: AssembleCeilingPlaneElement): Promise<ResultObject>;
        buildLayerAsync(context: ElementPerformerContext, layoutData: PolygonKeelLayoutData, params: CeilingPlaneParamers, element: AssembleCeilingPlaneElement): Promise<ResultObject>;
        outputLayerProcessAsync(context: ElementPerformerContext, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): Promise<ResultObject>;
        static createConatinerFromParent(parent: ContentElement, name: string, identifier: number, drawingCodes: string): ContainerElement;
        outputProcessAsync(context: ElementPerformerContext, input: AssemblyCeilingPlaneCalculatorInput, output: AssemblyCeilingPlaneCalculatorOutput): Promise<ResultObject>;
        createElementByContentStyleAsync(context: ElementPerformerContext, contentBases: Array<AssemblyCeilingContentBase>, parent: NestElement, input: AssemblyCeilingPlaneCalculatorInput): Promise<ResultObject>;
        createRefrenceLines(lines: Array<ReferencelineInfo>, parent: NestElement): void;
        private createElementByContentBaseAsync;
        private createElementAsync;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlanePolygonLayoutData" {
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    export class CeilingPlanePolygonLayoutData extends PolygonKeelLayoutData {
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlaneBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { CeilingPlaneParamers } from "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlaneParamers";
    import { CeilingPlanePolygonLayoutData } from "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlanePolygonLayoutData";
    export class CeilingPlaneBuilder {
        private layoutData;
        private params;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: CeilingPlanePolygonLayoutData, params: CeilingPlaneParamers);
        rotateLayoutData(layoutData: CeilingPlanePolygonLayoutData): void;
        buildAsync(context: ElementPerformerContext, element: AssembleCeilingPlaneElement): Promise<ResultObject>;
        buildLayerAsync(context: ElementPerformerContext, element: AssembleCeilingPlaneElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/AssembleCeilingPlaneElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssembleCeilingPlanePatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingPlanePatternElement';
    import { AssembleCeilingStylePatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingStylePatternElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { CeilingPlaneParamers } from "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlaneParamers";
    import { CeilingPlanePolygonLayoutData } from "sk/rule/data/rule/lappedceilinglayout/plane/CeilingPlanePolygonLayoutData";
    export class AssembleCeilingPlaneElementUtil {
        protected static _schemeConfigService: SchemeConfigService;
        static getDefaultParamsAsync(context: ElementPerformerContext, ceilingPlaneElement: AssembleCeilingPlaneElement, assemblePatternCeiling?: AssembleCeilingPlanePatternElement): Promise<ResultObject<CeilingPlaneParamers>>;
        static updateCeilingElementAsync(context: ElementPerformerContext, ceilingPlaneElement: AssembleCeilingPlaneElement, buildType: BuildStructureTypeEnum, params?: any): Promise<ResultObject>;
        static updateCeilingLayerElementsAsync(context: ElementPerformerContext, ceilingPlaneElement: AssembleCeilingPlaneElement, buildType: BuildStructureTypeEnum, params?: any): Promise<ResultObject>;
        static getLayoutDataFromCeilingPlane(ceilingPlane: AssembleCeilingPlaneElement): CeilingPlanePolygonLayoutData;
        static clearCeilingElement(element: AssembleCeilingPlaneElement): void;
        static setCeilingPlaneLayerParamsAsync(context: ElementPerformerContext, ceilingPlaneElement: AssembleCeilingPlaneElement, params: CeilingPlaneParamers): Promise<ResultObject>;
        static setCeilingPlaneParamsAsync(context: ElementPerformerContext, ceilingPlaneElement: AssembleCeilingPlaneElement, params: CeilingPlaneParamers): Promise<ResultObject>;
        static setCeilingStyleParamsAsync(context: ElementPerformerContext, style: AssembleCeilingStylePatternElement, params: CeilingPlaneParamers): Promise<ResultObject>;
        static updateCeilingPlaneElementAsync(context: ElementPerformerContext, ceilingPlankElement: AssembleCeilingPlaneElement, simplify?: boolean, params?: any): Promise<ResultObject>;
        static findRelationRoom(element: PatternInstanceElement): RoomElement;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/AssembleCeilingEdgeElementUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { AssembleCeilingEdgeElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement';
    import { AssembleCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingElement';
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeLibraryFamilyDocumentService } from 'sk/data/scheme/config/SchemeLibraryFamilyDocumentService';
    import { CeilingEdgeParamers } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeParamers";
    import { CeilingEdgePolygonLayoutData } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgePolygonLayoutData";
    export class AssembleCeilingEdgeElementUtil {
        protected static _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        protected static _schemeConfigService: SchemeConfigService;
        static updateCeilingLayerElementsAsync(context: ElementPerformerContext, ceilingEdgeElement: AssembleCeilingEdgeElement, buildType: BuildStructureTypeEnum, params?: any): Promise<ResultObject>;
        static updateCeilingEdgeElementAsync(context: ElementPerformerContext, ceilingEdgeElement: AssembleCeilingEdgeElement, simplify?: boolean, params?: any): Promise<ResultObject>;
        static updateCeilingPlane(assembleCeilingElement: AssembleCeilingElement, plankElement: AssembleCeilingPlaneElement, edges: Types<AssembleCeilingEdgeElement>): AssembleCeilingPlaneElement;
        static updateCeilingElementAsync(context: ContextObject, ceilingEdgeElement: AssembleCeilingEdgeElement, buildType: BuildStructureTypeEnum, params?: any): Promise<ResultObject>;
        static getLayoutDataFromCeilingEdge(ceilingEdge: AssembleCeilingEdgeElement): CeilingEdgePolygonLayoutData;
        static clearCeilingElement(element: AssembleCeilingEdgeElement): void;
        static getDefaultParams(): CeilingEdgeParamers;
        static findRelationRoom(element: PatternInstanceElement): RoomElement;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/CeilingParamers" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export type CeilingParamers = {
        ceilingThick: number;
        ceilingEdgeKeelHeight: number;
        ceilingEdgeKeelUpWidth: number;
        ceilingEdgeKeelDownWidth: number;
        ceilingEdgeKeelSTLength: number;
        ceilingEdgeKeelThick: number;
        ceilingClipKeelThick: number;
        ceilingClipKeelWidth: number;
        ceilingClipKeelSTLength: number;
        ceilingClipKeelHeight: number;
        ceilingViceThick: number;
        ceilingViceHeight: number;
        ceilingViceSTLength: number;
        ceilingViceWidth: number;
        ceilingPlasterPlankThick: number;
        ceilingPlasterPlankSTWidth: number;
        ceilingPlasterPlankSTLength: number;
        horizontalConnectionLength: number;
        horizontalConnectionHeight: number;
        horizontalConnectionWidth: number;
        horizontalConnectionThick: number;
        viceKeelConnectionLength: number;
        viceKeelConnectionWidth: number;
        viceKeelConnectionHeight: number;
        viceKeelConnectionThick: number;
        dryWallNailDiameter: number;
        ceilingEdgeKeelEndRemain: number;
        ceilingEdgeKeelMinNailGap: number;
        ceilingEdgeKeelMinLength: number;
        clipKeelStepRuleValue: number;
        clipKeelArrangeParralelEndRemain: number;
        clipKeelArrangeVerticalEndRemain: number;
        clipKeelClawCenterToEndValue: number;
        clipKeelSteeveToKeelEndValue: number;
        clipKeelMinLength: number;
        viceKeelArrangeEndRemain: number;
        viceKeelArrangeMinGap: number;
        viceKeelToEdgeKeelGap: number;
        viceKeelJointMinLength: number;
        adjustmentPlankMinLength: number;
        nailArrangeGapToPlankEdge: number;
        nailArrangeHorionalMinGap: number;
        nailArrangeVerticalMinGap: number;
        surfacePlankGapToWall: number;
        surfacePlankFirstRankCrossGap: number;
        surfacePlankSecondRankCrossGap: number;
        surfacePlankWidthCrossGap: number;
        ceilingEdgeKeelNailModule: number;
        ceilingClipKeelClawModule: number;
        ceilingClipKeelSteeveModule: number;
        ceilingViceKeelModule: number;
        basePlankNailLongitudinalModule: number;
        basePlankNailTransverseModule: number;
        surfacePlankNailTransverseModule: number;
        ceilingEdgeKeelId: string;
        ceilingClipKeelId: string;
        ceilingViceKeelId: string;
        ceilingPlasterPlankId: string;
        horizontalConnectionId: string;
        viceKeelConnectionId: string;
        dryWallNailId: string;
        screwBoltId: string;
        clipKeelSteeveId: string;
        decorateFaceId: string;
        decorateFaceThickness: number;
        isYmirror: boolean;
        isXmirror: boolean;
        optionManual: boolean;
        calculateMode: BuildStructureTypeEnum;
    };
}
declare module "sk/rule/data/rule/layout/SurfaceLayoutProcess" {
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    export class SurfaceLayoutProcess {
        static layoutSurfaceOnSurface(layoutSurface: LayoutableSurface, lengthX: number, minX: number, lengthY: number, minY: number, margin: number, spacing: number, endMode: number): Array<LayoutableSurface>;
        static layoutSurfaceOnSurfaceStaggered(layoutSurface: LayoutableSurface, lengthX: number, minX: number, lengthY: number, minY: number, margin: number, spacing: number, endModeX: number, endModeY: number, staggered: number, firstStaggered: boolean, stepValueX?: number, stepValueY?: number): Array<LayoutableSurface>;
        static layoutSurfaceOnSurfaceStaggeredXXY(layoutSurface: LayoutableSurface, lengthX: number, minX: number, lengthY: number, minY: number, margin: number, spacing: number, endModeX: number, endModeY: number, staggered: number, stepValueX?: number, stepValueY?: number): {
            xfLines: Array<LayoutableLine>;
            xsLines: Array<LayoutableLine>;
            yLines: Array<LayoutableLine>;
        };
        static layoutSurfaceOnSurfaceByXXYLines(xfLines: Array<LayoutableLine>, xsLines: Array<LayoutableLine>, yLines: Array<LayoutableLine>): Array<LayoutableSurface>;
        static layoutSurfaceOnSurfaceByXYLines(xLines: Array<LayoutableLine>, yLines: Array<LayoutableLine>, columnIndex: number): Array<LayoutableSurface>;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingRectModelCalculatorInput" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    export class AssemblyCeilingRectModelCalculatorInput {
        thickness: number;
        polySurface: LayoutablePolySurface;
        decorateFaceLength: number;
        decorateFaceWidth: number;
        decorateFaceThickness: number;
        ceilingEdgeKeelHeight: number;
        ceilingEdgeKeelUpWidth: number;
        ceilingEdgeKeelDownWidth: number;
        ceilingEdgeKeelSTLength: number;
        ceilingEdgeKeelThick: number;
        ceilingClipKeelThick: number;
        ceilingClipKeelWidth: number;
        ceilingClipKeelSTLength: number;
        ceilingClipKeelHeight: number;
        ceilingViceThick: number;
        ceilingViceHeight: number;
        ceilingViceSTLength: number;
        ceilingViceWidth: number;
        ceilingPlasterPlankThick: number;
        ceilingPlasterPlankSTWidth: number;
        ceilingPlasterPlankSTLength: number;
        horizontalConnectionLength: number;
        horizontalConnectionHeight: number;
        horizontalConnectionWidth: number;
        horizontalConnectionThick: number;
        viceKeelConnectionLength: number;
        viceKeelConnectionWidth: number;
        viceKeelConnectionHeight: number;
        viceKeelConnectionThick: number;
        dryWallNailDiameter: number;
        ceilingEdgeKeelEndRemain: number;
        ceilingEdgeKeelMinNailGap: number;
        ceilingEdgeKeelMinLength: number;
        clipKeelStepRuleValue: number;
        clipKeelArrangeParralelEndRemain: number;
        clipKeelArrangeVerticalEndRemain: number;
        clipKeelClawCenterToEndValue: number;
        clipKeelSteeveToKeelEndValue: number;
        clipKeelMinLength: number;
        viceKeelArrangeEndRemain: number;
        viceKeelArrangeMinGap: number;
        viceKeelToEdgeKeelGap: number;
        viceKeelJointMinLength: number;
        adjustmentPlankMinLength: number;
        nailArrangeGapToPlankEdge: number;
        nailArrangeHorionalMinGap: number;
        nailArrangeVerticalMinGap: number;
        surfacePlankGapToWall: number;
        surfacePlankFirstRankCrossGap: number;
        surfacePlankSecondRankCrossGap: number;
        surfacePlankWidthCrossGap: number;
        ceilingEdgeKeelNailModule: number;
        ceilingClipKeelClawModule: number;
        ceilingClipKeelSteeveModule: number;
        ceilingViceKeelModule: number;
        basePlankNailLongitudinalModule: number;
        basePlankNailTransverseModule: number;
        surfacePlankNailTransverseModule: number;
        isYmirror: boolean;
        isXmirror: boolean;
        calculateMode: BuildStructureTypeEnum;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingRectModelCalculatorOutput" {
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    import { AssemblyCeilingBasedPlank } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingBasedPlank";
    import { AssemblyCeilingClipKeel } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingClipKeel";
    import { AssemblyCeilingContentBase } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingContentBase";
    import { AssemblyCeilingEdgeKeel } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingEdgeKeel";
    import { AssemblyCeilingSurfacePlank } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingSurfacePlank";
    import { AssemblyCeilingViceKeel } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingViceKeel";
    export class AssemblyCeilingRectModelCalculatorOutput {
        edgeKeels: Array<AssemblyCeilingEdgeKeel>;
        clipKeels: Array<AssemblyCeilingClipKeel>;
        viceKeels: Array<AssemblyCeilingViceKeel>;
        basedPlanks: Array<AssemblyCeilingBasedPlank>;
        surfacePlanks: Array<AssemblyCeilingSurfacePlank>;
        basedNails: Array<AssemblyCeilingContentBase>;
        surfaceNails: Array<AssemblyCeilingContentBase>;
        keelNails: Array<AssemblyCeilingContentBase>;
        connectionOne: Array<AssemblyCeilingContentBase>;
        poles: Array<AssemblyCeilingContentBase>;
        connectionViceKeel: Array<AssemblyCeilingContentBase>;
        decorateFaces: Array<AssemblyCeilingContentBase>;
        referenceLines: Array<ReferencelineInfo>;
        constructor();
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingPolygonModelCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { KeelLayoutParamers, PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutablePoint } from "sk/rule/data/rule/layout/LayoutablePoint";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    import { PolygonColumnData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { Refline } from "sk/rule/data/rule/ceilinglayout/calculator/ArrangeCollisionTool";
    import { AssemblyCeilingModelCalculator } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingModelCalculator";
    import { AssemblyCeilingRectModelCalculatorInput } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingRectModelCalculatorInput";
    import { AssemblyCeilingRectModelCalculatorOutput } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingRectModelCalculatorOutput";
    import { AssemblyCeilingViceKeel } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingViceKeel";
    export class AssemblyCeilingPolygonModelCalculator extends AssemblyCeilingModelCalculator {
        linkKeelLines: Array<LayoutableLine>;
        input: AssemblyCeilingRectModelCalculatorInput;
        output: AssemblyCeilingRectModelCalculatorOutput;
        viceKeelIdentifier: number;
        isUseLayoutData: boolean;
        layoutData: PolygonKeelLayoutData;
        constructor();
        mirrorOutline(input: AssemblyCeilingRectModelCalculatorInput, layoutData: PolygonKeelLayoutData): void;
        mirrorLayoutData(input: AssemblyCeilingRectModelCalculatorInput, layoutData: PolygonKeelLayoutData): void;
        calculateInit(input: AssemblyCeilingRectModelCalculatorInput): void;
        getPolygonParams(): KeelLayoutParamers;
        calculateSimpleMode(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): void;
        calculateComponent(input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): ResultObject;
        clipLineOnLayout(layoutSurface: LayoutablePolySurface, line: LayoutableLine): Array<LayoutableLine>;
        hasHcKeel(viceKeels: Array<AssemblyCeilingViceKeel>, x: number, y: number): boolean;
        calculateHcKeels(layoutSurface: LayoutablePolySurface, viceKeelLines: Array<LayoutableLine>, hcKeelLines: Array<LayoutableLine>, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): void;
        calculateHcKeelLinesByXXYLines(layoutSurface: LayoutablePolySurface, xfLines: Array<LayoutableLine>, xsLines: Array<LayoutableLine>, yLines: Array<LayoutableLine>): Array<LayoutableLine>;
        calculateHcKeelLinesByXYLines(layoutSurface: LayoutablePolySurface, xLines: Array<LayoutableLine>, yLines: Array<LayoutableLine>): Array<LayoutableLine>;
        layoutData2xxy(layoutSurface: LayoutablePolySurface, columns: Array<PolygonColumnData>): {
            xlines: Array<Array<LayoutableLine>>;
            ylines: Array<LayoutableLine>;
        };
        mergeColumnPlank(layoutSurface: LayoutablePolySurface, xline: Array<LayoutableLine>, yline: LayoutableLine): void;
        calculatePlankByLayoutDate(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): Array<LayoutableLine>;
        calculateBasePlankOnPolySurface(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): Array<LayoutableLine>;
        createPlankAndNail(polyArea: LayoutablePolySurface, layoutSurfaces: Array<LayoutableSurface>, thick: number, planks: Array<ContentBase>, nails: Array<ContentBase>, input: AssemblyCeilingRectModelCalculatorInput, prefix: string, isSurface: boolean): void;
        static pushPositon(targets: Array<LayoutablePoint>, orgs: Array<LayoutablePoint>): void;
        calculateNailOnPolySurface(polyArea: LayoutablePolySurface, layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, nails: Array<ContentBase>, isSurface: boolean): void;
        calculateNailOnSurface(layoutSurface: LayoutableSurface, input: AssemblyCeilingRectModelCalculatorInput, nails: Array<ContentBase>, isSurface: boolean): void;
        calculateViceKeelsOnPolySurface(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): Array<LayoutableLine>;
        calculateEdgeKeelsOnPolySurface(polySurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): void;
        calculateDecorateFace(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): void;
        calculateBoltRefLines(layoutSurface: LayoutablePolySurface, rowKeels: Array<Array<LayoutableLine>>, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): void;
        anlysisClipKeelBeginLocation(length: number): number;
        anlysisClipKeelEndLocation(length: number): number;
        clipKeelLayoutOnLine2(line: LayoutableLine): Array<LayoutableLine>;
        clipKeelLayoutOnLine(line: LayoutableLine): Array<LayoutableLine>;
        calculateClipKeelsOnPolySurface(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput, output: AssemblyCeilingRectModelCalculatorOutput): void;
        calcualteClipKeelReflines(layoutSurface: LayoutablePolySurface): Array<Refline>;
        calculateClipKeelsSpacings(layoutSurface: LayoutablePolySurface, input: AssemblyCeilingRectModelCalculatorInput): Array<number>;
        getViceKeelsSpacingsByLayoutData2(input: AssemblyCeilingRectModelCalculatorInput): Array<number>;
        getViceKeelsSpacingsByLayoutData(width: number): Array<number>;
        calculateViceKeelsSpacings(width: number, input: AssemblyCeilingRectModelCalculatorInput): Array<number>;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingStandardModelProcess" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ISpecificationFamily } from 'sk/data/specification/base/ISpecificationFamily';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    import { CeilingParamers } from "sk/rule/data/rule/ceilinglayout/CeilingParamers";
    import { AssemblyCeilingRectModelCalculatorInput } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingRectModelCalculatorInput";
    import { AssemblyCeilingRectModelCalculatorOutput } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingRectModelCalculatorOutput";
    export class AssemblyCeilingStandardModelProcess {
        autoPosition: Vector2;
        inputBoard: CeilingParamers;
        calculatorOutput: AssemblyCeilingRectModelCalculatorOutput;
        ruleProcessInput: RuleProcessInput;
        ruleProcessOutput: RuleProcessOutput;
        layoutData: PolygonKeelLayoutData;
        _infoMap: TypeMap<string, ISpecificationFamily>;
        protected _schemeConfigService: SchemeConfigService;
        protected static _calculatorService: CalculatorService;
        constructor();
        getCeilingSurfaceFromInput(input: RuleProcessInput): CeilingSurfaceElement;
        setCalculatorInputFromInputBoard(calculatorInput: AssemblyCeilingRectModelCalculatorInput, inputBoard: CeilingParamers): void;
        buildAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, layoutData: PolygonKeelLayoutData, params: CeilingParamers, layoutContainer: ContainerElement): Promise<RuleProcesResult>;
        static createConatinerFromParent(parent: ContentElement, name: string, identifier: number, drawingCodes: string): ContainerElement;
        private getFamilyInfoListAsync;
        outputProcessAsync(context: ElementPerformerContext, inputBoard: CeilingParamers, calculatoroutput: AssemblyCeilingRectModelCalculatorOutput, input: RuleProcessInput, output: RuleProcessOutput, layoutContainer: ContainerElement): Promise<RuleProcesResult>;
        createRefrenceLines(lines: Array<ReferencelineInfo>, parent: NestElement): void;
        private createElementByContentBaseAsync;
        private setProperty;
        private createElementByContentAsync;
        calculateProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: AssemblyCeilingRectModelCalculatorInput, inputBoard: CeilingParamers, layoutContainer: ContainerElement): Promise<RuleProcesResult>;
        private createElementByFamilyIdAsync;
        private createElementAsync;
        private createElement2Async;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/CeilingBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { LayoutOption } from "sk/rule/data/rule/levelinglayout/keellayout/KeelLayoutData";
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { CeilingParamers } from "sk/rule/data/rule/ceilinglayout/CeilingParamers";
    export class CeilingBuilder {
        private layoutData;
        private params;
        private context;
        private layoutContainer;
        private tanxianContainer;
        private clipKeelContainer;
        private viceKeelContainer;
        private basePlankContainer;
        private sufacePlankContainer;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: PolygonKeelLayoutData, params: CeilingParamers);
        rotateLayoutData(layoutData: PolygonKeelLayoutData): void;
        getLayoutOption(): LayoutOption;
        protected createContainerAsync(element: ContentElement, layoutOption: LayoutOption): Promise<ResultObject>;
        isValidLayoutData(layoutData: PolygonKeelLayoutData): boolean;
        calculateAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcessOutput>;
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcesResult>;
        createDecoratesAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<ResultObject>;
        private createDecorateElementAsync;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/CeilingContainerBuilder" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    export class CeilingContainerBuilder {
        constructor();
        buildAsync(element: ContentElement): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/CompleteCeilingBuilder" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Line3 } from 'foundation/runtime/math/Line3';
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ISpecificationFamily } from 'sk/data/specification/base/ISpecificationFamily';
    import { ContainerNode } from 'sk/data/family/model/brep/frame/ContainerNode';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { AssembleLevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingCeilingElement';
    import { AssembleLevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/AssembleLevelingCeilingNode';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { ReferencelineInfo } from "sk/rule/data/rule/layout/ReferencelineInfo";
    import { CeilingParamers } from "sk/rule/data/rule/ceilinglayout/CeilingParamers";
    export class KeelSection {
        center: Point3;
        normal: Vector3;
        isExcuted: boolean;
        constructor();
    }
    export class KeelInfo {
        startSectiotn: KeelSection;
        endSectiotn: KeelSection;
        leftSideLine: Line3;
        rightSideLine: Line3;
        constructor();
    }
    export class CompleteCeilingBuilder {
        private layoutData;
        private ceilingOutline;
        private params;
        private context;
        assembleCeilingElement: AssembleLevelingCeilingElement;
        assembleCeilingNode: AssembleLevelingCeilingNode;
        basedNails: Array<LoDbEntity>;
        surfaceNails: Array<LoDbEntity>;
        keelNails: Array<LoDbEntity>;
        connectionOne: Array<LoDbEntity>;
        poles: Array<LoDbEntity>;
        connectionViceKeel: Array<LoDbEntity>;
        referenceLines: Array<ReferencelineInfo>;
        hangingContainer: ContainerNode;
        keelContainer: ContainerNode;
        baseContainer: ContainerNode;
        surfaceContainer: ContainerNode;
        _infoMap: TypeMap<string, ISpecificationFamily>;
        protected _schemeConfigService: SchemeConfigService;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: PolygonKeelLayoutData, params: CeilingParamers);
        private getFamilyInfoListAsync;
        getViceKeelInfo(viceKeel: HardwareNode): KeelInfo;
        isHConnect(sectiotn1: KeelSection, sectiotn2: KeelSection): boolean;
        isOneConnect(sectiotn: KeelSection, sideLine: Line3): boolean;
        createHConnect(sectiotn: KeelSection, sectiotn2: KeelSection): void;
        createOneConnect(sectiotn: KeelSection, sideLine: Line3): void;
        completeKeelConnection(viceKeels: Array<HardwareNode>): void;
        getClipKeelLayoutLine(clipKeel: HardwareNode): LayoutableLine;
        completePole(clipKeel: HardwareNode): void;
        getEdgeKeelLayoutLine(edgeKeel: HardwareNode): LayoutableLine;
        completeKeelNail(edgeKeel: HardwareNode): void;
        completePlanksNail(planks: Array<PlankElement>, isSurface: boolean): void;
        completePlankNail(plankNode: PlankNode, isSurface: boolean): void;
        calculateNailOnPolySurface(layoutSurface: LayoutablePolySurface, nails: Array<ContentBase>, isSurface: boolean): void;
        buildAsync(context: ElementPerformerContext, assembleCeilingElement: AssembleLevelingCeilingElement): Promise<RuleProcesResult>;
        extractElement(): void;
        calculate(): void;
        createElementAsync(context: ElementPerformerContext): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/base/RectArea" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class RectArea {
        origin: Vector2;
        width: number;
        height: number;
        rotationZ: number;
        elevation: number;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingCalculatorUtil" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { SkDbExtents } from 'sk/data/family/drawing/skdbdatabase/geobject/SkDbExtents';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { RectArea } from "sk/rule/data/rule/base/RectArea";
    export class AssemblyCeilingCalculatorUtil {
        static computeCeilingArea(ceilingElment: CeilingSurfaceElement): void;
        static computeRectCeilingAreaWithColumn(ceilingElment: CeilingSurfaceElement): {
            rectArea: RectArea;
            columns: Array<SkDbExtents>;
        };
        static computeRectCeilingArea(ceilingElment: CeilingSurfaceElement): {
            rectArea: RectArea;
            outlinePts: Array<Point3>;
        };
        static findCeilingSurfaceById(floorplan: FloorplanElement, id: string): any;
    }
}
declare module "sk/rule/data/rule/integceilinglayout/IntegCeilingParamers" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export type IntegCeilingSimplyParamers = {
        hangingID: string;
        mainKeelID: string;
        mainKeelHangingID: string;
        viceKeelHangingID: string;
        viceKeelID: string;
        decorativeSheetID: string;
        edgeID: string;
        layoutWidth?: number;
        layoutHieght?: number;
    };
    export type IntegCeilingParamers = {
        thickness: number;
        hangingID: string;
        hangingLengthX: number;
        hangingLengthY: number;
        hangingEndKeelDistance: number;
        hangingModulus: number;
        mainKeelHangingID: string;
        mainKeelHangingLengthX: number;
        mainKeelHangingLengthY: number;
        mainKeelHangingLengthZ: number;
        mainKeelID: string;
        mainKeelWidth: number;
        mainKeelHeight: number;
        mainKeelStandardLength: number;
        mainKeelWallDistance: number;
        mainKeelEndWallDistance: number;
        mainKeelModulus: number;
        viceKeelHangingID: string;
        viceKeelHangingLengthX: number;
        viceKeelHangingLengthY: number;
        viceKeelHangingLengthZ: number;
        viceKeelID: string;
        viceKeelWidth: number;
        viceKeelHeight: number;
        viceKeelStandardLength: number;
        viceKeelModulus: number;
        viceKeelRemain: number;
        viceKeelConnecterID: string;
        viceKeelConnecterLengthX: number;
        viceKeelConnecterLengthY: number;
        viceKeelConnecterLengthZ: number;
        decorativeSheetID: string;
        decorativeSheetLengthX: number;
        decorativeSheetLengthY: number;
        decorativeSheetLengthZ: number;
        edgeID: string;
        edgeStandardLength: number;
        edgeWidth: number;
        edgeHeight: number;
        calculateMode: BuildStructureTypeEnum;
    };
}
declare module "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingGeneralCalculatorInput" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    export class AssemblyIntegCeilingGeneralCalculatorInput {
        ceiling: LayoutableSurface;
        flues: Array<LayoutableSurface>;
        polyCeiling: LayoutablePolySurface;
        thickness: number;
        hangingID: string;
        hangingLengthX: number;
        hangingLengthY: number;
        hangingEndKeelDistance: number;
        hangingModulus: number;
        mainKeelHangingID: string;
        mainKeelHangingLengthX: number;
        mainKeelHangingLengthY: number;
        mainKeelHangingLengthZ: number;
        mainKeelID: string;
        mainKeelWidth: number;
        mainKeelHeight: number;
        mainKeelStandardLength: number;
        mainKeelWallDistance: number;
        mainKeelEndWallDistance: number;
        mainKeelModulus: number;
        viceKeelHangingID: string;
        viceKeelHangingLengthX: number;
        viceKeelHangingLengthY: number;
        viceKeelHangingLengthZ: number;
        viceKeelID: string;
        viceKeelWidth: number;
        viceKeelHeight: number;
        viceKeelStandardLength: number;
        viceKeelModulus: number;
        viceKeelRemain: number;
        viceKeelConnecterID: string;
        viceKeelConnecterLengthX: number;
        viceKeelConnecterLengthY: number;
        viceKeelConnecterLengthZ: number;
        decorativeSheetID: string;
        decorativeSheetLengthX: number;
        decorativeSheetLengthY: number;
        decorativeSheetLengthZ: number;
        edgeID: string;
        edgeStandardLength: number;
        edgeWidth: number;
        edgeHeight: number;
        calculateMode: BuildStructureTypeEnum;
        constructor();
    }
}
declare module "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingGeneralCalculatorOutput" {
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { LoDbPlank } from "sk/rule/data/rule/layout/entitys/LoDbPlank";
    import { LoDbReferenceLine } from "sk/rule/data/rule/layout/entitys/LoDbReferenceLine";
    export class AssemblyIntegCeilingGeneralCalculatorOutput {
        hangings: Array<LoDbEntity>;
        mainKeelHangings: Array<LoDbEntity>;
        mainKeels: Array<LoDbEntity>;
        viceKeelHangings: Array<LoDbEntity>;
        viceKeels: Array<LoDbEntity>;
        viceKeelConnecters: Array<LoDbEntity>;
        decorativeSheets: Array<LoDbPlank>;
        edges: Array<LoDbEntity>;
        referenceLines: Array<LoDbReferenceLine>;
        constructor();
    }
}
declare module "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingGeneralCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    import { AssemblyIntegCeilingGeneralCalculatorInput } from "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingGeneralCalculatorInput";
    import { AssemblyIntegCeilingGeneralCalculatorOutput } from "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingGeneralCalculatorOutput";
    export class AssemblyIntegCeilingGeneralCalculator {
        input: AssemblyIntegCeilingGeneralCalculatorInput;
        output: AssemblyIntegCeilingGeneralCalculatorOutput;
        elevationFinish: number;
        elevationViceKeel: number;
        elevationViceKeelHanging: number;
        elevationMainKeel: number;
        elevationMainKeelHanging: number;
        elevationHanging: number;
        constructor();
        calculateComponentSimple(input: AssemblyIntegCeilingGeneralCalculatorInput, output: AssemblyIntegCeilingGeneralCalculatorOutput): ResultObject;
        calculateComponent(input: AssemblyIntegCeilingGeneralCalculatorInput, output: AssemblyIntegCeilingGeneralCalculatorOutput): ResultObject;
        calculateElevation(): void;
        calculateRefrenceline(): void;
        calculateEdge(): void;
        calculateMainKeelLines(): Array<LayoutableLine>;
        calculateMainKeelHanging(keelLines: Array<LayoutableLine>): Array<Point3>;
        calculateViceKeelLines(): Array<LayoutableLine>;
        cutKeelLines2(keelLines: Array<LayoutableLine>, cutSurface: Array<LayoutableSurface>, keepDistance: number): void;
        cutKeelLines(keelLines: Array<LayoutableLine>, cutSurface: LayoutablePolySurface, keepDistance: number): void;
        cutLineOnLayout(layoutSurface: LayoutablePolySurface, line: LayoutableLine, keepDistance: number): Array<LayoutableLine>;
        calculateViceKeelHanging(mainKeelLines: Array<LayoutableLine>, viceKeelLines: Array<LayoutableLine>): void;
        calculateDecorativeSheet(): void;
        calculateDecorativeSheetStartingInfo(): number;
    }
}
declare module "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingProcess" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { IntegCeilingParamers } from "sk/rule/data/rule/integceilinglayout/IntegCeilingParamers";
    import { AssemblyIntegCeilingGeneralCalculatorInput } from "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingGeneralCalculatorInput";
    import { AssemblyIntegCeilingGeneralCalculatorOutput } from "sk/rule/data/rule/integceilinglayout/calculator/AssemblyIntegCeilingGeneralCalculatorOutput";
    export class AssemblyIntegCeilingProcess {
        calculatorInput: AssemblyIntegCeilingGeneralCalculatorInput;
        calculatorOutput: AssemblyIntegCeilingGeneralCalculatorOutput;
        ruleProcessInput: RuleProcessInput;
        ruleProcessOutput: RuleProcessOutput;
        protected _calculatorService: CalculatorService;
        setCalculatorInputFromInputBoard(calculatorInput: AssemblyIntegCeilingGeneralCalculatorInput, inputBoard: IntegCeilingParamers): void;
        buildAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, layoutData: PolygonLayoutData, params: IntegCeilingParamers): Promise<RuleProcesResult>;
        processAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput): Promise<RuleProcesResult>;
        calculateProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: AssemblyIntegCeilingGeneralCalculatorInput): Promise<RuleProcesResult>;
        outputProcessAsync(context: ElementPerformerContext, calculatorInput: AssemblyIntegCeilingGeneralCalculatorInput, calculatorOutput: AssemblyIntegCeilingGeneralCalculatorOutput, input: RuleProcessInput, output: RuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/integceilinglayout/IntegCeilingBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BathroomCeilingElement } from 'sk/data/scheme/database/pattern/element/BathroomCeilingElement';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { IntegCeilingParamers, IntegCeilingSimplyParamers } from "sk/rule/data/rule/integceilinglayout/IntegCeilingParamers";
    export class IntegCeilingBuilder {
        private layoutData;
        private params;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        protected static _calculatorService: CalculatorService;
        constructor(layoutData: PolygonLayoutData, params: IntegCeilingParamers);
        static createAsync(context: ElementPerformerContext, ceiling: BathroomCeilingElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateAsync(context: ElementPerformerContext, ceiling: BathroomCeilingElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static buildAsync(context: ElementPerformerContext, element: ContentElement, params: IntegCeilingSimplyParamers): Promise<ResultObject>;
        rotateLayoutData(layoutData: PolygonLayoutData): void;
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/integceilinglayout/IntegCeilingContainerBuilder" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    export class IntegCeilingContainerBuilder {
        constructor();
        buildAsync(element: ContentElement): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/assemble/LevelingCeilingElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { AssembleIntegrationCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleIntegrationCeilingPatternElement';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleLevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingCeilingElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { LevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/LevelingCeilingElement';
    import { CeilingParamers } from "sk/rule/data/rule/ceilinglayout/CeilingParamers";
    import { IntegCeilingParamers } from "sk/rule/data/rule/integceilinglayout/IntegCeilingParamers";
    import { PolygonAreaData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class LevelingCeilingElementUtil {
        protected static _calculatorService: CalculatorService;
        static createLevelingCeilingsAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode): Promise<ResultObject>;
        static createLevelingCeilingBySurfaceAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode, surface: CeilingSurfaceElement): Promise<ResultObject>;
        static createLevelingCeilingByAreaPolygonAsync(assembleContext: AssembleRoomContext, element: LevelingCeilingElement, areaPolygon: AreaPolygonNode): Promise<ResultObject>;
        static getAreasFromCeilingSurfaces(roomNode: RoomNode): Array<{
            polygons: Array<Array<Vector2>>;
            surface: CeilingSurfaceElement;
        }>;
        private static createLevelingCeiling;
        static createLevelingCeilingByPolygonAsync(assembleContext: AssembleRoomContext, element: LevelingCeilingElement, polygon: Array<Vector2>): Promise<ResultObject>;
        private static computeColumnPolygon;
        private static computeColumnPolygonV2;
        private static loadCeilingParametersAsync;
        static setLevelingCeilingProperty(element: PatternInstanceElement, area: PolygonAreaData, thickness?: number): void;
        static updateLevelingCeilingByArea(element: LevelingCeilingElement): LevelingCeilingElement;
        static updateLevelingCeilingLinkedPatternAsync(assembleRoom: AssembleRoomElement, levelingCeiling: LevelingCeilingElement, newPatternInfoId: string): Promise<ResultObject>;
        static updateLevelingCeilingAsync(context: ElementPerformerContext, element: LevelingCeilingElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static completeLevelingCeilingAsync(context: ElementPerformerContext, levelingCeilingElement: LevelingCeilingElement): Promise<ResultObject>;
        static completeIntegLevelingCeilingAsync(context: ElementPerformerContext, element: LevelingCeilingElement): Promise<ResultObject>;
        static clearLevelingCeilingElement(element: LevelingCeilingElement): void;
        static getIntegrationParametersAsync(context: ElementPerformerContext, assembleIntegerationCeiling: AssembleIntegrationCeilingPatternElement): Promise<ResultObject>;
        static getLevelingCeilingFamilyInfoIdsAsync(context: ElementPerformerContext, element: LevelingCeilingElement): Promise<ResultObject<{
            baseId: string;
            steeve: string;
            nail: string;
            clipKeel: string;
            edgeKeel: string;
            connection: string;
            viceKeel: string;
            viceKeelConnection: string;
        }>>;
        static updateIntegCeilingElementAsync(context: ElementPerformerContext, levelingCeilingElement: LevelingCeilingElement, calculateType?: BuildStructureTypeEnum, defaultParams?: CeilingParamers | IntegCeilingParamers): Promise<ResultObject>;
        static updateCeilingElementAsync(context: ElementPerformerContext, levelingCeilingElement: LevelingCeilingElement, calculateType?: BuildStructureTypeEnum, defaultParams?: CeilingParamers | IntegCeilingParamers): Promise<ResultObject>;
        static buildAssLevelingCeilingElementAsync(context: ElementPerformerContext, assembleCeiling: AssembleLevelingCeilingElement, calculateType?: BuildStructureTypeEnum, defaultParams?: CeilingParamers | IntegCeilingParamers): Promise<ResultObject>;
        private static getParametersAsync;
        static getSpaceThickness(assembleCeilingElement: AssembleLevelingCeilingElement): number;
        static getDecorateThickness(assembleCeilingElement: AssembleLevelingCeilingElement): number;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingContent" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class AssembleCeilingContent extends ContentBase {
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingCorner" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    export class AssembleCeilingCorner {
        position: Vector2;
        cornerType: CornerTypeEnum;
        constructor(pos: Vector2);
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingLine" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { AssembleCeilingCorner } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingCorner";
    export class AssembleCeilingLine extends ContentBase {
        begin: AssembleCeilingCorner;
        end: AssembleCeilingCorner;
        normalV: Vector2;
        normal: Vector2;
        constructor(begin: AssembleCeilingCorner, end: AssembleCeilingCorner);
        normalize(): void;
        offsetLine(offset: number): Array<Vector2>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingEdgeContent" {
    import { CeilingEdgeHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/assemble/ceiling/CeilingEdgeHoldTypeEnum';
    import { AssembleCeilingLine } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingLine";
    export class AssembleCeilingEdgeInfo {
    }
    export class AssembleCeilingEdgeContent extends AssembleCeilingLine {
        prev: AssembleCeilingEdgeContent;
        next: AssembleCeilingEdgeContent;
        leftHoldType: CeilingEdgeHoldTypeEnum;
        rightHoldType: CeilingEdgeHoldTypeEnum;
        edgeWidth: number;
        conactLength: number;
        keelOutLength: number;
        isLongSide: boolean;
        identifier: number;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingPlaneContent" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { AssembleCeilingEdgeContent } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingEdgeContent";
    export class AssembleCeilingInfo {
    }
    export class AssembleCeilingPlaneContent extends ContentBase {
        polygon: Array<Vector2>;
        root: AssembleCeilingEdgeContent;
        edges: Array<AssembleCeilingEdgeContent>;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/CeilingAreaContent" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { AssembleCeilingEdgeContent } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingEdgeContent";
    import { AssembleCeilingPlaneContent } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingPlaneContent";
    export class CeilingAreaContent extends ContentBase {
        polygon: Array<Vector2>;
        root: AssembleCeilingEdgeContent;
        edges: Array<AssembleCeilingEdgeContent>;
        edgeWidth: number;
        plane: AssembleCeilingPlaneContent;
        outline: Array<Vector2>;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/ProxyCeilingContext" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssembleCeilingEdgePatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingEdgePatternElement';
    import { AssembleCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingPatternElement';
    import { AssembleCeilingPlanePatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingPlanePatternElement';
    import { AssembleCeilingStylePatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingStylePatternElement';
    import { ProxyCeilingPatternElement } from 'sk/data/family/database/pattern/element/ProxyCeilingPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ProxyCeilingElement } from 'sk/data/scheme/database/pattern/element/ProxyCeilingElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class ProxyCeilingContext {
        ceilingHeight: number;
        ceilingEdgeLengthY: number;
        styeLength: number;
        styeHeight: number;
        extractTop: number;
        extractBottom: number;
        decorateThickness: number;
        document: SchemeDocument;
        ceiling: ProxyCeilingElement;
        context: ContextObject;
        proxyCeilingInfoId: string;
        proxyCeiling: ProxyCeilingPatternElement;
        assembleCeilingInfoId: string;
        assembleCeiling: AssembleCeilingPatternElement;
        decorateFamilyInfoId: string;
        ceilingEdgeFamilyInfoId: string;
        ceilingEdgePatternElement: AssembleCeilingEdgePatternElement;
        ceilingPlaneFamilyInfoId: string;
        ceilingPlanePatternElement: AssembleCeilingPlanePatternElement;
        ceilingStyleFamilyInfoId: string;
        ceilingStylePatternElement: AssembleCeilingStylePatternElement;
        styleInnerFamilyInfoId: string;
        styleOuterFamilyInfoId: string;
        styleMiddleFamilyInfoId: string;
        loadCeilingParamsAsync(context: ElementPerformerContext, referenceInfoId: string): Promise<ResultObject>;
        loadCeilingPlaneParamsAsync(context: ElementPerformerContext, plane: AssembleCeilingPlanePatternElement): Promise<ResultObject>;
        loadCeilingEdgeParamsAsync(context: ElementPerformerContext, edge: AssembleCeilingEdgePatternElement): Promise<void>;
        loadCeilingStyleParamsAsync(context: ElementPerformerContext, style: AssembleCeilingStylePatternElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/AssembleCeilingElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleCeilingAreaElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingAreaElement';
    import { AssembleCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingElement';
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    import { AssembleCeilingContent } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingContent";
    import { CeilingAreaContent } from "sk/rule/data/rule/assemble/ceiling/data/CeilingAreaContent";
    import { ProxyCeilingContext } from "sk/rule/data/rule/assemble/ceiling/ProxyCeilingContext";
    export class AssembleCeilingElementUtil {
        static createAssembleCeilingsAsync(assembleContext: AssembleRoomContext, room: RoomNode): Promise<ResultObject>;
        static createCeilingEdgeElementsByAreaAsync(context: ElementPerformerContext, ceilingContext: ProxyCeilingContext, areaContainer: AssembleCeilingAreaElement, area: CeilingAreaContent): Promise<ResultObject>;
        static createCeilingPlaneElementsByAreaAsync(context: ElementPerformerContext, ceilingContext: ProxyCeilingContext, areaContainer: AssembleCeilingAreaElement, area: CeilingAreaContent): Promise<ResultObject>;
        static setCeilingElementProperty(ceilingElement: AssembleCeilingElement, ceilingData: AssembleCeilingContent): void;
        static updateCeilingElementAsync(context: ElementPerformerContext, ceiling: AssembleCeilingElement, buildType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateCeilingLayerElementAsync(context: ElementPerformerContext, ceiling: AssembleCeilingElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/CeilingContentUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { ProxyCeilingElement } from 'sk/data/scheme/database/pattern/element/ProxyCeilingElement';
    import { ProxyCeilingContext } from "sk/rule/data/rule/assemble/ceiling/ProxyCeilingContext";
    import { CeilingAreaContent } from "sk/rule/data/rule/assemble/ceiling/data/CeilingAreaContent";
    export class CeilingContentUtil {
        static createCeilingContentByPolygons(ceilingContext: ProxyCeilingContext, room: RoomNode, polygon: Array<Vector2>): CeilingAreaContent;
        static createCeilingEdgeContent(ceilingContext: ProxyCeilingContext, area: CeilingAreaContent): void;
        static createCeilingPlaneContent(ceilingContext: ProxyCeilingContext, area: CeilingAreaContent): void;
        static updateCeilingContentByPolygons(ceilingContext: ProxyCeilingContext, room: RoomNode, proxyCeilingElement: ProxyCeilingElement, polygon: Array<Vector2>): CeilingAreaContent;
        static updateCeilingEdgeContent(ceilingContext: ProxyCeilingContext, area: CeilingAreaContent, proxyCeilingElement: ProxyCeilingElement): void;
        static updateCeilingPlaneContent(ceilingContext: ProxyCeilingContext, area: CeilingAreaContent, proxyCeilingElement: ProxyCeilingElement): void;
        private static sortPolygonPoints;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/CeilingElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { ProxyCeilingElement } from 'sk/data/scheme/database/pattern/element/ProxyCeilingElement';
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    import { ProxyCeilingContext } from "sk/rule/data/rule/assemble/ceiling/ProxyCeilingContext";
    import { AssembleCeilingContent } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingContent";
    import { CeilingAreaContent } from "sk/rule/data/rule/assemble/ceiling/data/CeilingAreaContent";
    export class CeilingElementUtil {
        protected static _calculatorService: CalculatorService;
        static createCeilingAsync(context: ElementPerformerContext, ceilingData: CeilingAreaContent, roomNode: RoomNode, ceilingContext: ProxyCeilingContext): Promise<ResultObject>;
        static createProxyCeilingsAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode): Promise<ResultObject>;
        static updateProxyCeilingAsync(context: ElementPerformerContext, ceiling: ProxyCeilingElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateCeilingLayerElementAsync(context: ElementPerformerContext, ceiling: ProxyCeilingElement, simplify?: boolean): Promise<ResultObject>;
        static setCeilingElementProperty(ceilingElement: ProxyCeilingElement, ceilingData: AssembleCeilingContent, ceilingContext: ProxyCeilingContext): void;
        static createAssembleCeilingElement(assembleContext: ProxyCeilingContext, parent: ProxyCeilingElement, ceilingData: CeilingAreaContent): any;
        static createAssebmleDecorateLayer(assembleContext: ProxyCeilingContext, parent: ProxyCeilingElement): any;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/BathroomDataUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PatternLinkTypeEnum } from 'sk/data/family/enumeration/PatternLinkTypeEnum';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeLibraryPatternDocumentService } from 'sk/data/scheme/config/SchemeLibraryPatternDocumentService';
    import { ProductLinkEnum } from 'sk/data/logic/module/enumeration/ProductLinkEnum';
    export class BathroomBaseData {
        typeCd: PatternLinkTypeEnum;
        productCd: ProductLinkEnum;
        componentElement: ComponentElement;
        infoId: string;
    }
    export class BathroomPlankData {
        x: number;
        y: number;
        height: number;
        width: number;
        cutLines: Line2[];
        constructor(x: number, y: number, width: number, height: number);
    }
    export class BathroomTileData {
        x: number;
        y: number;
        height: number;
        width: number;
        cutLines: Line2[];
        constructor(x: number, y: number, width: number, height: number);
    }
    export class BathroomDataUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        static getPointsBySectionSurfaceStructure(polygon: SectionSurfaceStructure, origin?: Vector2): Vector2[];
        static getRectInfoByPolygon(polygon: Line2[] | Value2[]): {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        static cutPlankElementToEdgeSurface(plankElement: FamilyInstanceElement, plankData: BathroomPlankData): void;
        static getEdgeSurfaceDecorateValueStructure(plankElement: PlankElement): DecorateValueStructure;
        static createPlankElementAsync(context: ElementPerformerContext, parentElement: ContentInstanceElement, familyInfo: ISpecificationFamilyInfo, plankData: BathroomPlankData): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/calculator/BathroomFloorTileCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Bound2 } from 'foundation/runtime/math/Bound2';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BathroomTileData } from "sk/rule/data/rule/bathroomlayout/BathroomDataUtil";
    export class FloorTileLayOutPara {
        mintileWidth: number;
        maxtileWidth: number;
        tilesGap: number;
        lastMinWidth: number;
        constructor(mintileWidth: number, maxtileWidth: number, tilesGap: number, lastMinWidth: number);
    }
    export class DryFloorType {
        static unKnow: string;
        static rectArea: string;
        static LArea: string;
        static TArea: string;
        static UArea: string;
        static SpecialUArea: string;
    }
    export class BathroomFloorTileCalculator {
        static DEFAULT_GAP: number;
        tilesPara: FloorTileLayOutPara;
        minX: number;
        minY: number;
        maxX: number;
        maxY: number;
        holes: Array<Box2>;
        polygon: Line2[];
        tileWidth: number;
        tileHeight: number;
        constructor(polygon: Line2[], edgeThick: number, tilesPara: FloorTileLayOutPara);
        computeFloorTile(): ResultObject<Array<BathroomTileData>>;
        protected getCornorPoints(polygon: Line2[]): Vector2[];
        protected divideHoles(oriHoleLines: Array<Array<Line2>>): Array<Bound2>;
        protected divideConnectedHoles(holeLines: Array<Line2>): Array<Bound2>;
        protected getEdgeInLines(lines: Array<Line2>, xEdge: boolean): Vector2;
        protected retractedFrame(oriHoleLines: Array<Array<Line2>>, edgeThick: number): void;
        protected getDrayAreaType(): DryFloorType;
        protected isTFloor(hole1: Box2, hole2: Box2): Boolean;
        protected isSpecialUFloor(hole1: Box2, hole2: Box2): Boolean;
        protected getSameEdgeNum(hole: Box2, areaMinX: number, areaMinY: number, areaMaxX: number, areaMaxY: number): number;
        protected isHoleSepearteDiagonal(hole1: Box2, hole2: Box2): Boolean;
        protected computeRectAreaTiles(): Array<BathroomTileData>;
        protected computeLAreaTiles(): Array<BathroomTileData>;
        protected computeUAreaTiles(): Array<BathroomTileData>;
        protected computeSpecialUAreaTiles(): Array<BathroomTileData>;
        protected computeTAreaTiles(): Array<BathroomTileData>;
        protected computeAverageAreaTiles(startX: number, startY: number, endX: number, endY: number): Array<BathroomTileData>;
        protected computeDirectionAreaTiles(startX: number, startY: number, endX: number, endY: number, bHorizontalAscend: boolean, bVerticalAscend: boolean): Array<BathroomTileData>;
        protected processTiles(tiles: Array<BathroomTileData>, startX: number, startY: number, endX: number, endY: number, bHorizontalAscend: boolean, bVerticalAscend: boolean): void;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/BathroomFloorDryData" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { BathroomFloorDryPlankElement } from 'sk/data/scheme/database/assemble/element/BathroomFloorDryPlankElement';
    import { BathroomBaseData, BathroomPlankData, BathroomTileData } from "sk/rule/data/rule/bathroomlayout/BathroomDataUtil";
    export type BathroomFloorDryInfo = {
        edgeThickness?: number;
        edgeHeight?: number;
        code?: string;
        floorDryPlankPatternInfoId?: string;
        floorDryPlankFamilyInfoId?: string;
        floorDryPlankFamilyInfo?: ISpecificationFamilyInfo;
    };
    export type BathroomTileInfo = {
        floorDryTileFamilyInfoId?: string;
        floorDryTileFamilyInfo?: ISpecificationFamilyInfo;
    };
    export type BathroomFloorDryHardwareInfo = {
        hardwareFloorConnectorFamilyId: string;
        hardwareDrySupportId: string;
        hardwareChassisConnectorId: string;
        hardwareFloorDrainId: string;
        hardwareFloorKeelId: string;
        hardwareFloorConnectorFamilyInfo?: ISpecificationFamilyInfo;
        hardwareDrySupportInfo?: ISpecificationFamilyInfo;
        hardwareChassisConnectorInfo?: ISpecificationFamilyInfo;
        hardwareFloorDrainInfo?: ISpecificationFamilyInfo;
        hardwareFloorKeelInfo?: ISpecificationFamilyInfo;
    };
    export class BathroomFloorDryPlankData extends BathroomBaseData {
        x: number;
        y: number;
        z: number;
        width: number;
        height: number;
        polygon: Line2[];
        plankData: BathroomPlankData;
        constructor(x: number, y: number, width: number, height: number);
    }
    export class BathroomFloorDryHardwareData {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        familyInfo: ISpecificationFamilyInfo;
        code?: string;
        hardwareNum?: number;
    }
    export class BathroomFloorDryData extends BathroomBaseData {
        info: BathroomFloorDryInfo;
        tileInfo: BathroomTileInfo;
        hardwareInfo: BathroomFloorDryHardwareInfo;
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        maxEdgeCutWidth: number;
        minEdgeCutWidth: number;
        polygon: Line2[];
        floorDryplanks: BathroomFloorDryPlankData[];
        hardwares: BathroomFloorDryHardwareData[];
        tiles: BathroomTileData[];
        constructor();
        computeFloorPolygons(): void;
        computeFloorDryTileData(): void;
        static createFloorDryPlankData(floorDryData: BathroomFloorDryData, rectPolygon: Line2[]): BathroomFloorDryPlankData;
        static setFloorDryPlankPolygon(floorDryPlankElement: BathroomFloorDryPlankElement, floorDryPlankData: BathroomFloorDryPlankData): void;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/BathroomFloorDryBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDryPlankElement } from 'sk/data/scheme/database/assemble/element/BathroomFloorDryPlankElement';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { BathroomTileData } from "sk/rule/data/rule/bathroomlayout/BathroomDataUtil";
    import { BathroomFloorDryData, BathroomFloorDryPlankData } from "sk/rule/data/rule/bathroomlayout/BathroomFloorDryData";
    export class BathroomFloorDryBuilder {
        static DEFAULT_EDGE_THICKNESS: number;
        static DEFAULT_OUTLINEEDGE_THICKNESS: number;
        static DEFAULT_EDGE_HEIGHT: number;
        static DEFAULT_FINISH: number;
        protected _schemeConfigService: SchemeConfigService;
        buildAsync(context: ElementPerformerContext, element: BathroomFloorDryElement): Promise<ResultObject<BathroomFloorDryData>>;
        createChildElementAsync(context: ElementPerformerContext, element: BathroomFloorDryElement, data: BathroomFloorDryData): Promise<ResultObject>;
        computeData(context: ElementPerformerContext, element: BathroomFloorDryElement, data: BathroomFloorDryData): void;
        createDataByElement(context: ElementPerformerContext, element: BathroomFloorDryElement): BathroomFloorDryData;
        loadFamilyInfoAsync(context: ElementPerformerContext, element: BathroomFloorDryElement, data: BathroomFloorDryData): Promise<ResultObject>;
        createFloorDryTileElementAsync(context: ElementPerformerContext, parentElement: ContainerElement, floorDryData: BathroomFloorDryData, tileData: BathroomTileData): Promise<ResultObject<FamilyInstanceElement>>;
        createFloorDryPlankElementAsync(context: ElementPerformerContext, parentElement: ContainerElement, floorDryData: BathroomFloorDryData, floorDryPlankData?: BathroomFloorDryPlankData): Promise<ResultObject<BathroomFloorDryPlankElement>>;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomSplitData" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    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 BathroomSplitData {
        height: number;
        maxHeight: number;
        areas: Array<{
            name: string;
            polygon: Array<Vector2>;
            code: string;
        }>;
        constructor();
        split(room: RoomNode): void;
        getBathroomHeight(roomNode: RoomNode, areaEls?: Types<AreaPolygonElement>): number;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomContext" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { AssembleBathroomPatternElement } from 'sk/data/family/database/pattern/element/AssembleBathroomPatternElement';
    import { AssembleIntegrationCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleIntegrationCeilingPatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { BathroomSplitData } from "sk/rule/data/rule/assemble/BathroomSplitData";
    type DecorateInfo = {
        decorateValue: DecorateValueStructure;
        familyContent: any;
        symbol?: any;
    };
    type WallDecoratesInfo = {
        plank: DecorateInfo;
        holeUp: DecorateInfo;
        holeDown: DecorateInfo;
        connerOuterBegin: DecorateInfo;
        connerOuterEnd: DecorateInfo;
        tile: DecorateInfo;
    };
    type FloorDecoratesInfo = {
        plank: DecorateInfo;
    };
    export class BathroomContext {
        document: SchemeDocument;
        bathroom: BathroomElement;
        roomNode: RoomNode;
        context: ContextObject;
        assembleInfoId: string;
        assemblePatternElement: AssembleBathroomPatternElement;
        doorInfoId: string;
        doorInfo: ISpecificationFamilyInfo;
        wallInfoId: string;
        wallDecoratesInfo: WallDecoratesInfo;
        floorDryInfoId: string;
        floorDryDecoratesInfo: FloorDecoratesInfo;
        floorTileInfo: DecorateInfo;
        ceilingInfoId: string;
        ceilingPatternElement: AssembleIntegrationCeilingPatternElement;
        floorDryEdgeThickness: number;
        floorDryEdgeHeight: number;
        options: any;
        protected _schemeConfigService: SchemeConfigService;
        constructor(roomNode: RoomNode);
        loadBathroomParamsAsync(context: ContextObject, bathroom: BathroomElement): Promise<ResultObject>;
        loadDecoratesAsync(context: ElementPerformerContext, bathroomElement: BathroomElement, splitData: BathroomSplitData): Promise<ResultObject>;
        loadFloorDecoratsAsync(context: ElementPerformerContext, referenceInfoId: string, spaceHeight: number): Promise<ResultObject>;
        loadWallDecoratesAsync(context: ElementPerformerContext, referenceInfoId: string, spaceHeight: number): Promise<ResultObject>;
        setValidWallFamilyInfoByHeightAsync(decorateInfo: DecorateInfo, height: number): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleRoomDesignContext" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssembleBeamPatternElement } from 'sk/data/family/database/pattern/element/AssembleBeamPatternElement';
    import { AssembleCeilingPelmetPatternElement } from 'sk/data/family/database/pattern/element/AssembleCeilingPelmetPatternElement';
    import { AssembleCompositeWallBasePatternElement } from 'sk/data/family/database/pattern/element/AssembleCompositeWallBasePatternElement';
    import { AssembleCompositeWallSurfacePatternElement } from 'sk/data/family/database/pattern/element/AssembleCompositeWallSurfacePatternElement';
    import { CompositeCeilingPatternElement } from 'sk/data/family/database/pattern/element/CompositeCeilingPatternElement';
    import { CompositeWallPatternElement } from 'sk/data/family/database/pattern/element/CompositeWallPatternElement';
    import { PelmetPatternElement } from 'sk/data/family/database/pattern/element/PelmetPatternElement';
    import { ProxyCeilingPatternElement } from 'sk/data/family/database/pattern/element/ProxyCeilingPatternElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { DecorateLayerMaterialTypeEnum } from 'sk/data/scheme/database/pattern/node/config/DecorateLayerMaterialTypeEnum';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class AssembleRoomDesignContext {
        document: SchemeDocument;
        assembleRoom: AssembleRoomElement;
        wallInfoId: string;
        compositeWallInfoId: string;
        compositeWallPattern: CompositeWallPatternElement;
        assembleCompositeWallInfoId: string;
        assembleWallBasePattern: AssembleCompositeWallBasePatternElement;
        assembleWallSurfacePattern: AssembleCompositeWallSurfacePatternElement;
        compositeWallDecorateLinkPattern: LinkerPatternElement;
        floorInfoId: string;
        ceilingInfoId: string;
        compositeCeilingInfoId: string;
        compositeCeilingPattern: CompositeCeilingPatternElement;
        compositeCeilingDecorateLinkPattern: LinkerPatternElement;
        proxyCeilingInfoId: string;
        proxyceilingPattern: ProxyCeilingPatternElement;
        proxyCeilingDecorateLinkPattern: LinkerPatternElement;
        pelmetInfoId: string;
        pelmetDecorateLinkPattern: LinkerPatternElement;
        pelPattern: PelmetPatternElement;
        assemblePelmetInfoId: string;
        assemblePelmetPattern: AssembleCeilingPelmetPatternElement;
        beamDecrotateLinkPattern: LinkerPatternElement;
        assembleBeamCTypeInfoId: string;
        assembleBeamLTypeInfoId: string;
        assembleBeamPattern: AssembleBeamPatternElement;
        decorateLayerMaterialInfoId: string;
        decorateLayerMaterialType: DecorateLayerMaterialTypeEnum;
        context: ContextObject;
        loadAssembleRoomParamsAsync(assembleRoom: AssembleRoomElement): Promise<ResultObject>;
        loadLeveingWallPatternParamsAsync(assembleRoom: AssembleRoomElement, wallInfoId: string): Promise<ResultObject>;
        loadCompositeWallPatternParamsAsync(assembleRoom: AssembleRoomElement, wallInfoId: string): Promise<ResultObject>;
        loadPelmetPatternParamsAsync(assembleRoom: AssembleRoomElement, pelmetInfoId: string): Promise<ResultObject>;
        loadDoorPatternParamsAsync(linkPattern: LinkerPatternElement): Promise<ResultObject>;
        loadLeveingFloorPatternParamsAsync(assembleRoom: AssembleRoomElement, floorInfoId: string): Promise<ResultObject>;
        loadLeveingCeilingPatternParamsAsync(assembleRoom: AssembleRoomElement, ceilingInfoId: string): Promise<ResultObject>;
        loadComposteCeilingPatternParamsAsync(assembleRoom: AssembleRoomElement, compositeCeilingInfoId: string): Promise<ResultObject>;
        loadProxyCeilingPatternParamsAsync(assembleRoom: AssembleRoomElement, proxyCeilingInfoId: string): Promise<ResultObject>;
        loadBeamPatternParamsAsync(linkPattern: LinkerPatternElement, LtypeLinkPattern?: LinkerPatternElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/calculator/PlankDecorateWallCalculator" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class TilePartData {
        x: number;
        y: number;
        lengthX: number;
        lengthY: number;
        rotate: number;
        type: string;
        cutlines: Array<Curve2>;
        constructor();
    }
    export class TileData {
        location: number;
        length: number;
        constructor();
    }
    export class TileDatas {
        datas: Array<TileData>;
        constructor();
    }
    export class LayoutPolygon {
        name: string;
        points: Array<Vector2>;
        holes: Array<Array<Vector2>>;
        constructor();
    }
    export class LayoutInputData {
        polygon: LayoutPolygon;
        tileLengthX: number;
        tileLengthY: number;
        beginOffsetX: number;
        beginOffsetY: number;
        gap: number;
        endXSlice: number;
        endYSlice: number;
        rotation: number;
        endXJF: boolean;
        endYJF: boolean;
        reverseX: boolean;
        reverseY: boolean;
        isSlice: boolean;
        constructor();
    }
    export class LayoutOutputData {
        tiles: Array<TilePartData>;
        constructor();
    }
    export class PlankDecorateWallCalculator {
        constructor();
        layoutDataCalculator(inputData: LayoutInputData, isFloor?: boolean): LayoutOutputData;
        removeTiles(tileLists: Array<TilePartData>, outline: Array<Vector2>): void;
        processOriginPoint(inputData: LayoutInputData, bound: Array<number>): void;
        layoutCalculator(start: number, end: number, offset: number, tileLength: number, gap: number, minLength: number, endJF: boolean, isFloor?: boolean): TileDatas;
        layoutColumn(tileLength: number, gap: number, start: number, end: number, minLength: number, endJF: boolean, revese?: boolean): TileDatas;
        layoutTiles(xList: TileDatas, yList: TileDatas): Array<TilePartData>;
        sliceTiles(tileList: Array<TilePartData>, outline: Array<Vector2>): void;
        boundCollision(bound1: Array<number>, bound2: Array<number>): boolean;
    }
}
declare module "sk/rule/data/rule/levelinglayout/PlankDecorateWallBuilder" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { TilePartData } from "sk/rule/data/rule/levelinglayout/calculator/PlankDecorateWallCalculator";
    export type dividedWallArea = {
        x: number;
        y: number;
        lengthX: number;
        lengthY: number;
        type: AreaTypeEnum;
    };
    export enum AreaTypeEnum {
        WALL = "wall",
        WINDOW_UP = "window.up",
        WINDOW_DOWN = "window.down",
        DOOR = "door"
    }
    export class PlankDecorateWallBuilder {
        protected context: ElementPerformerContext;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        static buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        static createDecorateElementAsync(context: ElementPerformerContext, decorateElement: DecorateLayerElement): Promise<ResultObject>;
        static computeWallOutLine(decorateElement: DecorateLayerElement): Vector2[][];
        private static getPoints;
        private static layoutTiles;
        static divideWallFaceData(decorateElement: DecorateLayerElement): Array<dividedWallArea>;
        static findDiffHoles(decorateElement: DecorateLayerElement): any;
        static wallHolesData(decorateElement: DecorateLayerElement, areas: Array<dividedWallArea>, gap?: number): void;
        static createOneDecorateElementAsync(context: ContextObject, decorateElement: DecorateLayerElement, tiles: Array<any>): Promise<ResultObject>;
        static sliceTiles(tileList: Array<TilePartData>, outline: Array<Vector2>): void;
    }
}
declare module "sk/rule/data/rule/levelinglayout/DecorateLayerBuilder" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    export class DecorateLayerBuilder {
        protected context: ElementPerformerContext;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor();
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        protected static createDecorateElementAsync(context: ContextObject, decorateElement: DecorateLayerElement): Promise<ResultObject>;
        private static createDecorateElement2Async;
        protected static createPlankElement(parent: DecorateLayerElement, hight?: number): PlankElement;
    }
}
declare module "sk/rule/data/rule/assemble/beam/CrossAssembleBeamElementTecDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { AssembleRoomDesignContext } from "sk/rule/data/rule/assemble/AssembleRoomDesignContext";
    export class CrossAssembleBeamElementTecDivUtil {
        static findCrossAssembleBeamElementAsync(assembleBeams: AssembleBeamElement[], assembleContext?: AssembleRoomDesignContext, beams?: BeamNode[], room?: RoomNode): Promise<ResultObject>;
        static judgeCross(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): boolean;
        static isParallel(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): boolean;
        static boxToVector3Array(box: BoundaryBox): Vector3[];
        private static coincidePointCount;
        static boxToPolygonCurve2d(box: BoundaryBox): PolygonCurve2d;
        static findLowerBeam(assemblebeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): boolean;
        static getBeamInfoOnLine(beam: AssembleBeamElement, line: Line2, polygon?: Vector2[]): any;
        static computeAssembelBeamHole(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement): void;
        static getAssembleBeamInfoOnLineAutoLong(assembleBeam: AssembleBeamElement, line: Line2): any;
        static getBeamHoleData(assembleBeam: AssembleBeamElement, crossAssembleBeam: AssembleBeamElement, x: number, subLine: Line2, relativeRotate: number): any;
        static changeHeightBeamButtomCavity(assembelBeamLow: AssembleBeamElement, hole: any, assembelBeamHeigh: AssembleBeamElement, heightGap: number): void;
        static separateAssembleBeamElementByHoles(frontAssembleBeam: AssembleBeamElement, backAssembleBeam: AssembleBeamElement, hole: any): void;
        static crossAssembleBeamElementUpdate(assembleBeam: AssembleBeamElement): void;
        private static getCrossAssembleBeamData;
        private static findAssembleBeamsInSameRoom;
        static heighAssembleBeamElementUpdate(assembleBeam: AssembleBeamElement): void;
        static lowAssembleBeamElementUpdate(assembleBeam: AssembleBeamElement): void;
        static updateAssembleBeamHoles(assembleBeam: AssembleBeamElement): void;
    }
}
declare module "sk/rule/data/rule/assemble/LevelingWallElementDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { WallSurfaceLineInfo, DecorateSurfaceLineInfo } from 'sk/data/scheme/database/floorplan/model/util/WallSurfaceNodeUtil';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { HoleData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { AssembleRoomDesignContext } from "sk/rule/data/rule/assemble/AssembleRoomDesignContext";
    export class LevelingWallElementDivUtil {
        static createLevelingWallsByDefaultAsync(outline: Array<Vector2>, wallElement: LevelingWallElement, holes?: Array<Array<Vector2>>): Promise<ResultObject>;
        static createLevelingWallByOutlineAsync(infoId: string, document: SchemeDocument, outline: Array<Vector2>, element: LevelingWallElement, holes?: Array<Array<Vector2>>): Promise<ResultObject>;
        static createLevelingWallsByRoomAsync(assembleContext: AssembleRoomDesignContext, room: RoomNode): Promise<ResultObject>;
        static createDecorateLayerElement(assembleContext: AssembleRoomDesignContext, room: RoomNode, decorateSurfaceline: DecorateSurfaceLineInfo): DecorateLayerElement;
        static setDecorateLayerInfo(decorateLayer: DecorateLayerElement, decorateSurfaceline: DecorateSurfaceLineInfo): void;
        static matchDecorateAndLevelingwall(decorateLayer: DecorateLayerElement, levelingWalls: Array<LevelingWallElement>): void;
        static matchDecorateSurfaceLineAndSubLine(decorateLayer: DecorateLayerElement, wallLines: Array<WallSurfaceLineInfo>): Array<WallSurfaceLineInfo>;
        private static matchLineSpace;
        static updateDecorateLayerLinkedPatternAsync(assembleRoom: AssembleRoomElement, decorateLayer: DecorateLayerElement, newPatternInfoId: string): Promise<ResultObject>;
        static updateLevelingWallLinkedPatternAsync(assembleContext: AssembleRoomDesignContext, assembleRoom: AssembleRoomElement, levelingWall: LevelingWallElement, newPatternInfoId: string): Promise<ResultObject>;
        static caculateHolesByOutline(outline: Array<Vector2>, bound: any): Array<Array<Vector2>>;
        static createSplitLevelingWallsAsync(assembleContext: AssembleRoomDesignContext, wallSurfaceNode: WallSurfaceNode, room: RoomNode): Promise<ResultObject>;
        private static createLevelingWallByLineInfos;
        private static processDoorAndWindowOnWall;
        private static processDoorAndWindowOnDecorate;
        static getLineOpengingsHoleDatas(wallSurface: WallSurfaceNode, line: Line2): Array<HoleData>;
        private static processBeamsOnWallOnDecorate;
        static getLineBeamHoleDatasOnDecorate(line: Line2, wallSurface: WallSurfaceNode): Array<HoleData>;
        private static processBeamsOnWall;
        static getLineBeamHoleDatas(levelingWall: LevelingWallElement, wallSurface: WallSurfaceNode): Array<HoleData>;
        private static processCeilingOnWall;
        private static processCeilingOnWallOnDecorate;
        private static createLevelingWallByLineInfosAsync;
        static getLineCeilingHoleDatas(levelingWall: LevelingWallElement, wallSurface: WallSurfaceNode, line: Line2): Array<HoleData>;
        static getLineCeilingHoleDatasOnDecorate(wallSurface: WallSurfaceNode, line: Line2): Array<HoleData>;
        static createLevelingWallElement(assembleContext: AssembleRoomDesignContext, from: Vector2, to: Vector2): LevelingWallElement;
        static createAssebmleWallAndDecorateLayer(element: LevelingWallElement): void;
        static updateLevelingWallDecorateLayerAsync(context: ElementPerformerContext, decorateLayer: DecorateLayerElement): Promise<ResultObject>;
        static deleteDecorateLayerAssemblePart(decorateLayer: DecorateLayerElement): void;
        static updateLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static buildLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleBeamElementTecDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { AssembleRoomDesignContext } from "sk/rule/data/rule/assemble/AssembleRoomDesignContext";
    export class AssembleBeamElementTecDivUtil {
        static createAssembleBeamsByRoomAsync(assembleContext: AssembleRoomDesignContext, room: RoomNode): Promise<Array<AssembleBeamElement>>;
        static createAssembleBeamAsync(assembleContext: AssembleRoomDesignContext, beam: BeamNode, room: RoomNode): Promise<ResultObject>;
        static creatAssembleBeamElement(assembleContext: AssembleRoomDesignContext, beam: BeamNode): any;
        static creatAssembleBeamElementAllPlankAsync(assembleContext: AssembleRoomDesignContext, beam: BeamNode, polygon: Vector2[], assembleBeam: AssembleBeamElement, room: RoomNode): Promise<ResultObject>;
        private static findCeilingThickness;
        private static lineIsOnPolygon;
        static isSegmentsOverlapped(point1: Value2, point2: Value2, point3: Value2, point4: Value2, tolerance?: number): boolean;
        static setAssembleBeamProperty(assembleBeam: AssembleBeamElement): void;
        static createDecorateLayerElementAsync(assembleContext: AssembleRoomDesignContext): Promise<ResultObject<DecorateLayerElement>>;
        static createAssembleBeamPlankAsync(assembleContext: AssembleRoomDesignContext, assembleBeam: AssembleBeamElement, beam: BeamNode, idx: number, ceilingThickness?: number): Promise<ResultObject>;
        private static setDecorateLayerElementGeo;
        private static setLevelingWallElementGeo;
        static updateAssembleBeamPlankAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject>;
        static updateAssembleBeamAsync(context: ElementPerformerContext, assembleBeam: AssembleBeamElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateDecorateLayerAsync(context: ElementPerformerContext, element: DecorateLayerElement): Promise<ResultObject>;
        private static getBoxCalculateParameter;
    }
}
declare module "sk/rule/data/rule/assemble/LevelingCeilingElementTecDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { LevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/LevelingCeilingElement';
    import { CeilingParamers } from "sk/rule/data/rule/ceilinglayout/CeilingParamers";
    import { IntegCeilingParamers } from "sk/rule/data/rule/integceilinglayout/IntegCeilingParamers";
    import { PolygonAreaData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { AssembleRoomDesignContext } from "sk/rule/data/rule/assemble/AssembleRoomDesignContext";
    export class LevelingCeilingElementTecDivUtil {
        protected static _calculatorService: CalculatorService;
        static createLevelingCeilingsAsync(assembleContext: AssembleRoomDesignContext, roomNode: RoomNode): Promise<ResultObject>;
        static createLevelingCeilingBySurfaceAsync(assembleContext: AssembleRoomDesignContext, roomNode: RoomNode, surface: CeilingSurfaceElement): Promise<ResultObject>;
        static createLevelingCeilingByAreaPolygonAsync(assembleContext: AssembleRoomDesignContext, element: LevelingCeilingElement, areaPolygon: AreaPolygonNode): Promise<ResultObject>;
        private static createLevelingCeiling;
        static createLevelingCeilingByPolygonAsync(assembleContext: AssembleRoomDesignContext, element: LevelingCeilingElement, polygon: Array<Vector2>): Promise<ResultObject>;
        static createDecorateLayerElementAsync(assembleContext: AssembleRoomDesignContext, ceilingElement: LevelingCeilingElement, outline: Array<Vector2>, holes?: Array<Array<Vector2>>): Promise<ResultObject<any>>;
        private static computeColumnPolygon;
        private static computeColumnPolygonV2;
        private static loadCeilingParametersAsync;
        static setLevelingCeilingProperty(element: PatternInstanceElement, area: PolygonAreaData, thickness?: number): void;
        static updateLevelingCeilingByArea(element: LevelingCeilingElement): LevelingCeilingElement;
        static updateLevelingCeilingLinkedPatternAsync(assembleRoom: AssembleRoomElement, levelingCeiling: LevelingCeilingElement, newPatternInfoId: string): Promise<ResultObject>;
        static updateDecorateLayerLinkedPatternAsync(assembleRoom: AssembleRoomElement, decorateLayer: DecorateLayerElement, newPatternInfoId: string): Promise<ResultObject>;
        static updateLevelingCeilingAsync(context: ElementPerformerContext, element: LevelingCeilingElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static clearLevelingCeilingElement(element: LevelingCeilingElement): void;
        static updateCeilingElementAsync(context: ElementPerformerContext, levelingCeilingElement: LevelingCeilingElement, calculateType?: BuildStructureTypeEnum, defaultParams?: CeilingParamers | IntegCeilingParamers): Promise<ResultObject>;
        static updateDecorateLayerByPolygon(decorateLayer: DecorateLayerElement): DecorateLayerElement;
        static updateDecorateLayerAsync(context: ElementPerformerContext, element: DecorateLayerElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/AssembleCeilingElementTecDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleCeilingAreaElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingAreaElement';
    import { AssembleCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingElement';
    import { AssembleRoomDesignContext } from "sk/rule/data/rule/assemble/AssembleRoomDesignContext";
    import { AssembleCeilingContent } from "sk/rule/data/rule/assemble/ceiling/data/AssembleCeilingContent";
    import { CeilingAreaContent } from "sk/rule/data/rule/assemble/ceiling/data/CeilingAreaContent";
    import { ProxyCeilingContext } from "sk/rule/data/rule/assemble/ceiling/ProxyCeilingContext";
    export class AssembleCeilingElementTecDivUtil {
        static createAssembleCeilingsAsync(assembleContext: AssembleRoomDesignContext, room: RoomNode): Promise<ResultObject>;
        static createCeilingEdgeElementsByAreaAsync(context: ElementPerformerContext, ceilingContext: ProxyCeilingContext, areaContainer: AssembleCeilingAreaElement, area: CeilingAreaContent): Promise<ResultObject>;
        static createCeilingPlaneElementsByAreaAsync(context: ElementPerformerContext, ceilingContext: ProxyCeilingContext, areaContainer: AssembleCeilingAreaElement, area: CeilingAreaContent): Promise<ResultObject>;
        static setCeilingElementProperty(ceilingElement: AssembleCeilingElement, ceilingData: AssembleCeilingContent): void;
        static updateCeilingElementAsync(context: ElementPerformerContext, ceiling: AssembleCeilingElement, buildType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateCeilingLayerElementAsync(context: ElementPerformerContext, ceiling: AssembleCeilingElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/LevelingFloorElementTecDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { AssembleRoomDesignContext } from "sk/rule/data/rule/assemble/AssembleRoomDesignContext";
    export class LevelingFloorPartenEnum {
        static floor: string;
        static area_floor: string;
    }
    export class LevelingFloorElementTecDivUtil {
        static createLevelingFloorsByDefaultAsync(outline: Array<Vector2>, floorElement: LevelingFloorElement, holes?: Array<Array<Vector2>>): Promise<ResultObject<any>>;
        static createLevelingFloorByOutlineAsync(infoId: string, document: SchemeDocument, outline: Array<Vector2>, element: LevelingFloorElement, holes?: Array<Array<Vector2>>): Promise<ResultObject<LevelingFloorElement>>;
        static createDecorateLayerElementAsync(assembleRoom: AssembleRoomElement, outline: Array<Vector2>, floorElement: LevelingFloorElement, holes?: Array<Array<Vector2>>): Promise<ResultObject<any>>;
        static loadFloorPatternParameterDefaultsAsync(element: LevelingFloorElement): Promise<ResultObject>;
        static loadDecorateLayerParameterDefaultsAsync(decorateLayer: DecorateLayerElement): Promise<ResultObject>;
        static createLevelingFloorsAsync(assembleContext: AssembleRoomDesignContext, roomNode: RoomNode): Promise<ResultObject<any>>;
        static createLevelingFloorAsync(assembleContext: AssembleRoomDesignContext, roomNode: RoomNode, element?: LevelingFloorElement): Promise<ResultObject>;
        static updateLevelingFloorLinkedPatternAsync(assembleRoom: AssembleRoomElement, levelingFloor: LevelingFloorElement, newPatternInfoId: string): Promise<ResultObject>;
        static updateDecorateLayerLinkedPatternAsync(assembleRoom: AssembleRoomElement, decorateLayer: DecorateLayerElement, newPatternInfoId: string): Promise<ResultObject>;
        static getAreasFromFloorSurface(roomNode: RoomNode): Array<Array<Vector2>>;
        static dirtyLevelingFloorByOutline(polygon: Array<Vector2>, element: LevelingFloorElement): void;
        static createLevelingFloorByRegion(assembleContext: AssembleRoomDesignContext, region: Array<Vector2>, relationElemnt: ContentInstanceElement, element?: LevelingFloorElement): LevelingFloorElement;
        static updateLevelingFloorByArea(element: LevelingFloorElement): LevelingFloorElement;
        static updateDecorateLayerByPolygon(decorateLayer: DecorateLayerElement): DecorateLayerElement;
        static updateDecorateLayerAsync(context: ElementPerformerContext, element: DecorateLayerElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateLevelingFloorAsync(context: ElementPerformerContext, element: LevelingFloorElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static loadFloorPatternParametersAsync(floorDecorateLinkPattern: LinkerPatternElement, element: LevelingFloorElement): Promise<ResultObject>;
        static buildFloorElementAsync(context: ElementPerformerContext, levelingFloorElement: LevelingFloorElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleDoorElementTecDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { AssembleDoorElement } from 'sk/data/scheme/database/pattern/element/AssembleDoorElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class AssembleDoorElementTecDivUtil {
        static createAssembleDoorAsync(assembleContext: AssembleRoomContext, doorNode: OpeningNode, wallSurfaceNode: WallSurfaceNode, levelingWall: LevelingWallElement | CompositeWallElement): Promise<ResultObject>;
        static updateAssemleDoorElementAsync(context: ElementPerformerContext, element: AssembleDoorElement): Promise<ResultObject>;
        static updateDecorateLayerAsync(context: ElementPerformerContext, element: DecorateLayerElement): Promise<ResultObject>;
        private static calculateAssembleDoorGeo;
        private static setParameters;
        static setElementLocation(element: AssembleDoorElement, box: ContentBase): void;
        static createDoorFloorAsync(assembleContext: AssembleRoomContext, assembleDoor: AssembleDoorElement, element: OpeningElement, wallSurfaceNode: WallSurfaceNode): Promise<ResultObject>;
        static createDecorateLayerElementAsync(assembleRoom: AssembleRoomElement, outline: Array<Vector2>, floorElement: LevelingFloorElement, holes?: Array<Array<Vector2>>): Promise<ResultObject<any>>;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleWindowElementUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallSurfaceElement } from 'sk/data/scheme/database/floorplan/element/WallSurfaceElement';
    import { WindowElement } from 'sk/data/scheme/database/floorplan/element/WindowElement';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { WindowNode } from 'sk/data/scheme/database/floorplan/model/WindowNode';
    import { AssembleWindowElement } from 'sk/data/scheme/database/pattern/element/AssembleWindowElement';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class WindowParameter {
        plankSideGap: number;
        levelerMinDistance: number;
        innerDepth: number;
        windowRotation: number;
        elementId: string;
        defultThickness: number;
        wallPlankThickness: number;
        decorateThickness: number;
        elementBox: ContentBase;
        wallRotation: number;
        wallThickness: number;
        constructor();
    }
    export class AssembleWindowElementUtil {
        static createAssembleWindowAsync(assembleContext: AssembleRoomContext, windowNode: WindowNode, wallSurfaceNode: WallSurfaceNode, levelingWall: LevelingWallElement | CompositeWallElement): Promise<ResultObject>;
        static getAssembleWindowByWallSufaceOpening(wallSurface: WallSurfaceElement, window: WindowElement): AssembleWindowElement;
        private static computeAssembleWindow;
        private static calculatAssembleWindowGeo;
        static createAssembleWindowPlankAsync(assembleContext: AssembleRoomContext, windowPara: WindowParameter, assembleWindow: AssembleWindowElement, window: WindowNode, idx: number, wallSurfaceNode: WallSurfaceNode): Promise<ResultObject>;
        static updateAssembleWindowAsync(context: ElementPerformerContext, element: AssembleWindowElement): Promise<ResultObject>;
        static updateAssembleWindowStoneAsync(context: ContextObject, element: AssembleWindowElement): Promise<ResultObject>;
        private static setWindowParameters;
        private static createStoneSillElementAsync;
    }
}
declare module "sk/rule/data/rule/assemble/CompositeCeilingElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { AssembleIntegrationCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleIntegrationCeilingPatternElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleCompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCompositeCeilingElement';
    import { CompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/CompositeCeilingElement';
    import { CeilingParamers } from "sk/rule/data/rule/ceilinglayout/CeilingParamers";
    import { IntegCeilingParamers } from "sk/rule/data/rule/integceilinglayout/IntegCeilingParamers";
    import { PolygonAreaData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class CompositeCeilingElementUtil {
        protected static _calculatorService: CalculatorService;
        static createCompositeCeilingsAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode): Promise<ResultObject>;
        static createCompositeCeilingBySurfaceAsync(assembleContext: AssembleRoomContext, roomNode: RoomNode, surface: CeilingSurfaceElement): Promise<ResultObject>;
        static getAreasFromCeilingSurfaces(roomNode: RoomNode): Array<{
            polygons: Array<Array<Vector2>>;
            surface: CeilingSurfaceElement;
        }>;
        private static createCompositeCeiling;
        private static computeColumnPolygon;
        private static computeColumnPolygonV2;
        private static loadCeilingParametersAsync;
        static setCompositeCeilingProperty(element: PatternInstanceElement, area: PolygonAreaData, thickness?: number): void;
        static updateCompositeCeilingByArea(element: CompositeCeilingElement): CompositeCeilingElement;
        static updateCompositeCeilingAsync(context: ElementPerformerContext, element: CompositeCeilingElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static completeCompositeCeilingAsync(context: ElementPerformerContext, compositeCeilingElement: CompositeCeilingElement): Promise<ResultObject>;
        static completeIntegCompositeCeilingAsync(context: ElementPerformerContext, element: CompositeCeilingElement): Promise<ResultObject>;
        static clearCompositeCeilingElement(element: CompositeCeilingElement): void;
        static getIntegrationParametersAsync(context: ElementPerformerContext, assembleIntegerationCeiling: AssembleIntegrationCeilingPatternElement): Promise<ResultObject>;
        static getCompositeCeilingFamilyInfoIdsAsync(context: ElementPerformerContext, element: CompositeCeilingElement): Promise<ResultObject<{
            baseId: string;
            steeve: string;
            nail: string;
            clipKeel: string;
            edgeKeel: string;
            connection: string;
            viceKeel: string;
            viceKeelConnection: string;
        }>>;
        static updateCeilingElementAsync(context: ElementPerformerContext, compositeCeilingElement: CompositeCeilingElement, calculateType?: BuildStructureTypeEnum, defaultParams?: CeilingParamers | IntegCeilingParamers): Promise<ResultObject>;
        static buildAssCompositeCeilingElementAsync(context: ElementPerformerContext, assembleCeiling: AssembleCompositeCeilingElement, calculateType?: BuildStructureTypeEnum, defaultParams?: CeilingParamers | IntegCeilingParamers): Promise<ResultObject>;
        private static getParametersAsync;
    }
}
declare module "sk/rule/data/rule/assemble/DecorateLayerElementTecDivUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { MaterialLayoutElement } from 'sk/data/family/element/instance/layout/MaterialLayoutElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { PlaneSurfaceElement } from 'sk/data/family/element/instance/PlaneSurfaceElement';
    import { DecorateLayerFamilyInfo } from 'sk/data/scheme/database/pattern/node/config/DecorateLayerFamilyInfo';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    export type DecorateLayerInfoCache = {
        isNull: boolean;
        materialInfoId?: string;
        layoutElement?: MaterialLayoutElement;
        directionEnum?: RelativeDirectionEnum;
        areaPolygonElements?: Types<AreaPolygonElement>;
    };
    export class DecorateLayerElementTecDivUtil {
        static syncDecorateLayerInfoAsync(context: ContextObject, decorateLayer: DecorateLayerElement, decorateLayerMaterialInfoId?: string): Promise<ResultObject>;
        static buildPatternDecorateLayerAsync(context: ContextObject, element: any, builderAsync: any): Promise<ResultObject>;
        static findPlaneSurfaceElement(element: any, directionEnum?: RelativeDirectionEnum): PlaneSurfaceElement;
        static updateAssembleDecorateLayerAsync(context: ContextObject, element: DecorateLayerElement, directionEnum?: RelativeDirectionEnum): Promise<ResultObject>;
        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;
    }
}
declare module "sk/rule/data/rule/curtainboxlayout/CurtainBoxParamers" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export type CurtainBoxParamers = {
        length: number;
        leftMargin: number;
        rightMargin: number;
        spaceWidth: number;
        spaceHeight: number;
        fixedKeelID: string;
        fixedKeelWidth: number;
        fixedKeelHeight: number;
        fixedKeelThickness: number;
        fixedKeelStandardLength: number;
        fixedKeelEndWallDistance: number;
        fixedKeelBoltID: string;
        fixedKeelBoltLengthX: number;
        fixedKeelBoltLengthY: number;
        fixedKeelBoltLengthZ: number;
        fixedKeelBoltEndDistance: number;
        fixedKeelBoltModulus: number;
        edgeKeelID: string;
        edgeKeelElevation: number;
        edgeKeelWidth: number;
        edgeKeelHeight: number;
        edgeKeelThickness: number;
        edgeKeelStandardLength: number;
        edgeKeelEndWallDistance: number;
        edgeKeelNailEndDistance: number;
        edgeKeelNailModulus: number;
        viceKeelID: string;
        viceKeelWidth: number;
        viceKeelHeight: number;
        viceKeelModulus: number;
        viceKeelRemain: number;
        basePlankID: string;
        basePlankStandardWidth: number;
        basePlankStandardHeight: number;
        basePlankThickness: number;
        surfacePlankID: string;
        surfacePlankStandardWidth: number;
        surfacePlankStandardHeight: number;
        surfacePlankThickness: number;
        wormNail15ID: string;
        wormNail15Diameter: number;
        wormNail15Length: number;
        wormNail25ID: string;
        wormNail25Diameter: number;
        wormNail25Length: number;
        dryNail15ID: string;
        dryNail15Diameter: number;
        dryNail15Length: number;
        dryNail25ID: string;
        dryNail25Diameter: number;
        dryNail25Length: number;
        firstPlankNailModulus: number;
        fisrtPlankNailRemain: number;
        secondPlankNailModulus: number;
        secondPlankNailRemain: number;
        surfacePlankNailModulus: number;
        surfacePlankNailRemain: number;
        decorateID: string;
        isLappedCeiling: boolean;
        calculateMode: BuildStructureTypeEnum;
    };
}
declare module "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxCalculatorBase" {
    export class AssemblyCurtainBoxCalculatorBase {
    }
}
declare module "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxGeneralCalculatorInput" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export class AssemblyCurtainBoxGeneralCalculatorInput {
        sideMaxMargin: number;
        length: number;
        leftMargin: number;
        rightMargin: number;
        spaceWidth: number;
        spaceHeight: number;
        fixedKeelID: string;
        fixedKeelWidth: number;
        fixedKeelHeight: number;
        fixedKeelThickness: number;
        fixedKeelStandardLength: number;
        fixedKeelEndWallDistance: number;
        fixedKeelBoltID: string;
        fixedKeelBoltLengthX: number;
        fixedKeelBoltLengthY: number;
        fixedKeelBoltLengthZ: number;
        fixedKeelBoltEndDistance: number;
        fixedKeelBoltModulus: number;
        edgeKeelID: string;
        edgeKeelElevation: number;
        edgeKeelWidth: number;
        edgeKeelHeight: number;
        edgeKeelThickness: number;
        edgeKeelStandardLength: number;
        edgeKeelEndWallDistance: number;
        edgeKeelNailEndDistance: number;
        edgeKeelNailModulus: number;
        viceKeelID: string;
        viceKeelWidth: number;
        viceKeelHeight: number;
        viceKeelModulus: number;
        viceKeelRemain: number;
        basePlankID: string;
        basePlankStandardWidth: number;
        basePlankStandardHeight: number;
        basePlankThickness: number;
        surfacePlankID: string;
        surfacePlankStandardWidth: number;
        surfacePlankStandardHeight: number;
        surfacePlankThickness: number;
        wormNail15ID: string;
        wormNail15Diameter: number;
        wormNail15Length: number;
        wormNail25ID: string;
        wormNail25Diameter: number;
        wormNail25Length: number;
        dryNail15ID: string;
        dryNail15Diameter: number;
        dryNail15Length: number;
        dryNail25ID: string;
        dryNail25Diameter: number;
        dryNail25Length: number;
        firstPlankNailModulus: number;
        fisrtPlankNailRemain: number;
        secondPlankNailModulus: number;
        secondPlankNailRemain: number;
        surfacePlankNailModulus: number;
        surfacePlankNailRemain: number;
        decorateID: string;
        isLappedCeiling: boolean;
        simply: boolean;
        calculateMode: BuildStructureTypeEnum;
        constructor();
    }
}
declare module "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxGeneralCalculatorOutput" {
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { LoDbPlank } from "sk/rule/data/rule/layout/entitys/LoDbPlank";
    import { LoDbReferenceLine } from "sk/rule/data/rule/layout/entitys/LoDbReferenceLine";
    export class AssemblyCurtainBoxGeneralCalculatorOutput {
        referenceLines: Array<LoDbReferenceLine>;
        fixedKeels: Array<LoDbEntity>;
        edgeKeels: Array<LoDbEntity>;
        viceKeels: Array<LoDbEntity>;
        basePlanks: Array<LoDbPlank>;
        surfacePlanks: Array<LoDbPlank>;
        decorativePlanks: Array<LoDbPlank>;
        constructor();
    }
}
declare module "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxGeneralCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { AssemblyCurtainBoxCalculatorBase } from "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxCalculatorBase";
    import { AssemblyCurtainBoxGeneralCalculatorInput } from "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxGeneralCalculatorInput";
    import { AssemblyCurtainBoxGeneralCalculatorOutput } from "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxGeneralCalculatorOutput";
    export class AssemblyCurtainBoxGeneralCalculator extends AssemblyCurtainBoxCalculatorBase {
        input: AssemblyCurtainBoxGeneralCalculatorInput;
        output: AssemblyCurtainBoxGeneralCalculatorOutput;
        private baseIndex;
        private surfaceIndex;
        constructor();
        calculateComponentSimple(input: AssemblyCurtainBoxGeneralCalculatorInput, output: AssemblyCurtainBoxGeneralCalculatorOutput): ResultObject;
        calculateComponent(input: AssemblyCurtainBoxGeneralCalculatorInput, output: AssemblyCurtainBoxGeneralCalculatorOutput): ResultObject;
        calculateFixedKeels(): void;
        calculateEdgeKeelOnLine(layoutLine: LayoutableLine): void;
        calculateEdgeKeels(): void;
        calculateOneRowNail(plankOrigin: Point3, xlength: number, xAxis: Vector3, yAxis: Vector3, xmargin: number, ymargin: number, spacing: number, nailId: string, lengthX: number, lengthY: number, lengthZ: number): void;
        calculateEdgePlank(): void;
        calculateBottomPlank(): void;
        private calculateSurvey;
    }
}
declare module "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxProcess" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { CurtainBoxParamers } from "sk/rule/data/rule/curtainboxlayout/CurtainBoxParamers";
    import { AssemblyCurtainBoxGeneralCalculatorInput } from "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxGeneralCalculatorInput";
    import { AssemblyCurtainBoxGeneralCalculatorOutput } from "sk/rule/data/rule/curtainboxlayout/calculator/AssemblyCurtainBoxGeneralCalculatorOutput";
    export class AssemblyCurtainBoxProcess {
        calculatorInput: AssemblyCurtainBoxGeneralCalculatorInput;
        calculatorOutput: AssemblyCurtainBoxGeneralCalculatorOutput;
        ruleProcessInput: RuleProcessInput;
        ruleProcessOutput: RuleProcessOutput;
        inputBoard: CurtainBoxParamers;
        protected _schemeConfigService: SchemeConfigService;
        protected _calculatorService: CalculatorService;
        setCalculatorInputFromInputBoard(calculatorInput: AssemblyCurtainBoxGeneralCalculatorInput, inputBoard: CurtainBoxParamers): void;
        buildAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, length: number, params: CurtainBoxParamers): Promise<RuleProcesResult>;
        processAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput): Promise<RuleProcesResult>;
        calculateProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: AssemblyCurtainBoxGeneralCalculatorInput): Promise<RuleProcesResult>;
        outputProcessAsync(context: ElementPerformerContext, calculatorInput: AssemblyCurtainBoxGeneralCalculatorInput, calculatorOutput: AssemblyCurtainBoxGeneralCalculatorOutput, input: RuleProcessInput, output: RuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/curtainboxlayout/CurtainBoxBuilder" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { CurtainBoxParamers } from "sk/rule/data/rule/curtainboxlayout/CurtainBoxParamers";
    export class CurtainBoxBuilder {
        private length;
        private params;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(length: number, params: CurtainBoxParamers);
        buildAsync(context: ElementPerformerContext, element: ContentElement, decorateLayer: DecorateLayerElement): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/CeilingPolygonUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class CeilingPolygonUtil {
        static isRectPolygon(points: Vector2[]): boolean;
        static getOverlapLine(polygonA: Vector2[], polygonB: Vector2[]): Line2;
        static getLineSegmentOverlap(lineA: Line2, lineB: Line2): Line2;
    }
}
declare module "sk/rule/data/rule/assemble/PelmetElementUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    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 { CurtainBoxParamers } from "sk/rule/data/rule/curtainboxlayout/CurtainBoxParamers";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export type PelmetContainerData = {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationZ: number;
    };
    export class PelmetElementUtil {
        protected static _calculatorService: CalculatorService;
        static createPelmetsAsync(assembleContext: AssembleRoomContext, levelingWallNode: LevelingWallNode): Promise<ResultObject>;
        static createPelmetByAreaPolygonAsync(assembleContext: AssembleRoomContext, pelmetElement: PelmetElement, areaPolygon: AreaPolygonNode): Promise<ResultObject>;
        private static createPelmet;
        static createAssemblePelmet(assembleContext: AssembleRoomContext, element: PelmetElement, areaPolygon: AreaPolygonNode): PelmetElement;
        static updatePelmetAsync(context: ContextObject, element: PelmetElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static loadDocumentParametersAsync(assembleContext: AssembleRoomContext, element: PelmetElement): Promise<void>;
        static initPelmetTransform(element: PelmetElement, polygon: Vector2[], room: RoomNode): void;
        static overturnPelmet(element: PelmetElement): void;
        static setPelmetProperty(element: PelmetElement, containerData: PelmetContainerData): void;
        static buildPelmetElementAsync(context: ContextObject, pelmetElement: PelmetElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static getParamsFromPelmetAsync(context: ContextObject, element: PelmetElement): Promise<ResultObject<CurtainBoxParamers>>;
        static clearPelmetElement(element: PelmetElement): void;
        static getLinkLevelingWallElement(pelmetElement: PelmetElement): LevelingWallElement;
        static getPelmetBaseLines(levelingWallElement: LevelingWallElement): Array<Line2>;
        static getLevelingWallSplitLinesForPelmet(levelingWallElement: LevelingWallElement): Array<Line2>;
        private static deduplicationPoints;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleRoomElementTecDivUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { SpatialSurfaceNode } from 'sk/data/family/model/instance/SpatialSurfaceNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    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 { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { CompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/CompositeCeilingElement';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    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 { ProxyCeilingElement } from 'sk/data/scheme/database/pattern/element/ProxyCeilingElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    import { LevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/LevelingCeilingNode';
    import { LevelingWallNode } from 'sk/data/scheme/database/pattern/node/LevelingWallNode';
    export class AssembleRoomElementTecDivUtil {
        static createAssembleRoomAsync(elementPerformerContext: ElementPerformerContext, assembleRoom: AssembleRoomElement, room: RoomNode): Promise<ResultObject>;
        static buildAssembleRoomContentAfterAsync(elementPerformerContext: ElementPerformerContext, assembleRoomNode: AssembleRoomNode): Promise<ResultObject>;
        static createLevelingWallsByRoomAsync(levelingWall: LevelingWallElement, room: RoomNode): Promise<ResultObject>;
        static updateAssembleElementLinkedPatternAsync(levelingElement: PatternInstanceElement, newPatternInfoId: string): Promise<ResultObject>;
        static createLevelingWallsByWallSurfaceAsync(levelingWall: LevelingWallElement, wallSurfaceNode: WallSurfaceNode): Promise<ResultObject>;
        static createPelmetsByLevelingWallAsync(pelmetElement: PelmetElement, levelingWallNode: LevelingWallNode): Promise<ResultObject>;
        static createPelmetByAreaPolygonAsync(pelmetElement: PelmetElement, areaPolygon: AreaPolygonNode): Promise<ResultObject>;
        static createLevelingFloorByRoomAsync(levelingFloor: LevelingFloorElement, room: RoomNode): Promise<ResultObject>;
        static createLevelingFloorsByRoomAsync(levelingFloor: LevelingFloorElement, room: RoomNode): Promise<ResultObject>;
        static createLevelingCeilingsByRoomAsync(levelingCeiling: LevelingCeilingElement, room: RoomNode): Promise<ResultObject>;
        static createCompositeCeilingsByRoomAsync(compositeCeiling: CompositeCeilingElement, room: RoomNode): Promise<ResultObject>;
        static clearSurfaceLeveilingCeiling(surface: CeilingSurfaceNode): void;
        static clearAreaPolygonLeveilingCeiling(areaPolygon: AreaPolygonNode): void;
        static createLevelingCeilingByAreaPolygonAsync(levelingCeiling: LevelingCeilingElement, areaPolygon: AreaPolygonNode): Promise<ResultObject>;
        static createLevelingCeilingByCeilingSurfaceAsync(levelingCeiling: LevelingCeilingElement, surface: CeilingSurfaceNode): Promise<ResultObject>;
        static createCeilingsByRoomAsync(proxyCeiling: ProxyCeilingElement, room: RoomNode): Promise<ResultObject>;
        static deleteAssembleRoom(assembleRoom: AssembleRoomElement, notIncludeSelf?: boolean): void;
        private static clearRoomLevelingWalls;
        private static clearAssembleRoomDecorateLayers;
        private static clearWallSurfaceLevelingWalls;
        private static clearLevelingWallPelmets;
        private static clearAreaPolygonPelmets;
        private static clearDecorateLayerByElement;
        private static clearRoomLevelingFloor;
        private static clearRoomLevelingCeiling;
        private static clearRoomCeiling;
        private static clearRoomAssembleBeam;
        static getAssembleRoomOfRoom(room: RoomNode): AssembleRoomElement;
        static syncAssembleRoom(room: RoomNode, assembleRoom?: AssembleRoomElement): AssembleRoomElement;
        static updateAssembleRoomByRoomAsync(room: RoomNode): Promise<ResultObject>;
        static updateAssembleRoomAsync(assembleRoom: AssembleRoomElement, force?: boolean): Promise<ResultObject>;
        static dirtyRoomFloorAndCeiling(room: RoomNode): void;
        static dirtyRoomFloor(room: RoomNode): void;
        static getSimilarPolygon(results: {
            polygon: Vector2[];
            surface: CeilingSurfaceElement;
        }[], levelingCeiling: LevelingCeilingNode): Array<Vector2>;
        static dirtyRoomCeiling(room: RoomNode): void;
        static getRoomOfLevelingCeiling(levelingCeiling: LevelingCeilingElement): RoomNode;
        static getRoomOfDecorateLayerElement(decorateLayer: DecorateLayerElement): RoomNode;
        static getRoomOfLevelingWall(levelingwall: LevelingWallElement): RoomNode;
        static getAssembleRoomOfLevelingWall(levelingwall: LevelingWallElement): AssembleRoomElement;
        static getRoomOfCompositeWall(compositewall: CompositeWallElement): RoomNode;
        static getAssembleRoomOfCompositeWall(compositewall: CompositeWallElement): AssembleRoomElement;
        static getAssembleBeamsOfAssembleRoom(assembleRoom: AssembleRoomElement): AssembleBeamElement[];
        static getRoomOfPelmet(pelmet: PelmetElement): RoomNode;
        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 getRoomOfAssebmleRoom(assembleRoom: AssembleRoomElement): RoomNode;
        static getRoomOfAssembleBathroom(bathroom: BathroomElement): RoomNode;
        static createLevelingWallBySpatialSurfaceAsync(levelingWall: LevelingWallElement, spatialSurface: SpatialSurfaceNode): Promise<ResultObject>;
        static createLevelingFloorAsync(levelingFloor: LevelingFloorElement, outline?: Array<Vector2>, holes?: Array<Array<Vector2>>): Promise<ResultObject>;
        static createLevelingCelingAsync(levelingCeiling: LevelingCeilingElement, outline?: Array<Vector2>): Promise<ResultObject>;
        static createLevelingFloorByRoomDefaultAsync(element: LevelingFloorElement, roomNode: RoomNode): Promise<ResultObject>;
        private static setDecorateInfoInContext;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleStyleUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    export type AssembleStyleInfo = {
        styleCode: string;
        colorCode: string;
        gradeCode: string;
    };
    export class AssembleStyleUtil {
        static updateAssembleStyleAsync(element: FloorplanElement | BathroomElement | AssembleRoomElement, info: AssembleStyleInfo): Promise<ResultObject>;
        private static updateBathroomStyleAsync;
        private static updateAssembleRoomStyleAsync;
        static updateLevelingObjectStyleAsync(context: ElementPerformerContext, element: PatternInstanceElement): Promise<ResultObject>;
        static updateChestStyleAsync(chest: FamilyInstanceElement): Promise<ResultObject>;
        static updatePlankElementStyleAsync(context: ElementPerformerContext, element: PlankElement, info?: AssembleStyleInfo): Promise<ResultObject>;
        static updateContentStyleAsync(context: ElementPerformerContext, child: PatternInstanceElement): Promise<ResultObject>;
        private static setDecorateByStyleAsync;
        private static findMatchStyleDecorateLinkIdAsync;
        static buildContentAsync(context: ElementPerformerContext, content: PatternInstanceElement): Promise<ResultObject>;
        static setAnchor(el1: ContentElement, el2: ContentElement): void;
        static buildContent1Async(context: ElementPerformerContext, content: PatternInstanceElement, contentDecorateCode: string): Promise<ResultObject>;
        static buildContent2Async(context: ElementPerformerContext, content: PatternInstanceElement, decorate: DecorateValueStructure): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/calculator/BathroomTileCalculator" {
    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 { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomTileData } from "sk/rule/data/rule/bathroomlayout/BathroomDataUtil";
    export class TileLayOutPara {
        tileWidth: number;
        tileHeight: number;
        tilesGap: number;
        minWidth: number;
        constructor(tileWidth: number, tileHeight: number, gap: number, minWidth: number);
    }
    export class DoorCoordinatePos {
        x: number;
        y: number;
        lenghtX: number;
        lengthY: number;
        constructor(x: number, y: number, lenghtX: number, lengthY: number);
    }
    export class TileLineSection {
        start: number;
        end: number;
        crossLines: Array<Line2>;
        constructor();
    }
    export class BathroomTileCalculator {
        minX: number;
        minY: number;
        maxX: number;
        maxY: number;
        holes: Array<Box2>;
        doorPos: DoorCoordinatePos;
        polygon: Line2[];
        tilesPara: TileLayOutPara;
        edgeThick: number;
        constructor(context: ElementPerformerContext, polygon: Line2[], edgeThick: number, tilesPara: TileLayOutPara);
        computeFloorTile(): ResultObject<Array<BathroomTileData>>;
        computeWallTile(divideNum: number): ResultObject<Array<BathroomTileData>>;
        protected getCornorPoints(polygon: Line2[]): Vector2[];
        protected retractedFrame(oriHoleLines: Array<Array<Line2>>, edgeThick: number): void;
        protected getDoorCoordinatPos(context: ElementPerformerContext, minX: number, minY: number, maxX: number, maxY: number): DoorCoordinatePos;
        protected computeTiles(bHorizontalAscend: boolean, bVerticalAscend: boolean): Array<BathroomTileData>;
        protected computeTilesWall(bHorizontalAscend: boolean, bVerticalAscend: boolean): Array<BathroomTileData>;
        protected computeSectionTilesWall(xStart: number, xEnd: number, yStart: number, yEnd: number, bHorizontalAscend: boolean, bVerticalAscend: boolean): Array<BathroomTileData>;
        protected computeTiles_nHDivide(bHorizontalAscend: boolean, bVerticalAscend: boolean, divideNum: number): Array<BathroomTileData>;
        protected computeSectionTiles(xStart: number, xEnd: number, yStart: number, yEnd: number, bHorizontalAscend: boolean, bVerticalAscend: boolean): Array<BathroomTileData>;
        protected appendHoleSideTiles(hSectons: TileLineSection[], bVerticalAscend: boolean): Array<BathroomTileData>;
        protected getTileSections(coordinateStart: number, coordinateEnd: number, step: number, minStep: number, stepGap: number, bAscend: boolean): Array<TileLineSection>;
        protected cutVerticalSectionLines(section: TileLineSection, coordinateStartY: number, coordinateEndY: number, holes: Array<Box2>): TileLineSection;
        protected cutLineByHole(startX: number, endX: number, verticalLine: Line2, hole: Box2): Array<Line2>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/bathroomwall/BathroomWallData" {
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { WallPlankHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/bathroom/WallPlankHoldTypeEnum';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    export type BathroomWallPlankInfo = {
        antiClockwise?: boolean;
        defaultFamilyInfoId: string;
        overFamilyInfoId: string;
        underFamilyInfoId: string;
        outerCornerStartFamilyInfoId: string;
        outerCornerEndFamilyInfoId: string;
        tileInfoFamilyInfoId: string;
        defaultFamilyInfo?: ISpecificationFamilyInfo;
        overFamilyInfo?: ISpecificationFamilyInfo;
        underFamilyInfo?: ISpecificationFamilyInfo;
        outerCornerStartFamilyInfo?: ISpecificationFamilyInfo;
        outerCornerEndFamilyInfo?: ISpecificationFamilyInfo;
        tileInfoFamilyInfo?: ISpecificationFamilyInfo;
    };
    export type BathroomWallHardwareInfo = {
        hardwareAmongKeelFamilyId: string;
        hardwareInnerKeelFamilyId: string;
        hardwareOuterKeelFamilyId: string;
        hardwareFloorFamilyId: string;
        hardwareAmongKeelFamilyInfo?: ISpecificationFamilyInfo;
        hardwareInnerKeelFamilyInfo?: ISpecificationFamilyInfo;
        hardwareOuterKeelFamilyInfo?: ISpecificationFamilyInfo;
        hardwareFloorFamilyInfo?: ISpecificationFamilyInfo;
    };
    export type BathroomWallHoleData = {
        x: number;
        y: number;
        width: number;
        height: number;
        type?: "window" | "door";
    };
    export class BathroomWallPlankTypeEnum {
        static Default: string;
        static Over: string;
        static Under: string;
        static OuterCornerStart: string;
        static OuterCornerEnd: string;
    }
    export type BathroomWallPlankData = {
        type: BathroomWallPlankTypeEnum;
        x: number;
        y: number;
        height: number;
        width: number;
        invalid?: boolean;
        message?: string;
    };
    export class BathroomWallHardwareData {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        familyInfo: ISpecificationFamilyInfo;
    }
    type BathroomWallBaseLayerData = {
        leftOffset: number;
        rightOffset: number;
        topOffset: number;
        bottomOffset: number;
        backOffset: number;
        planks: BathroomWallPlankData[];
    };
    export class BathroomWallData {
        plankInfo: BathroomWallPlankInfo;
        hardwareInfo: BathroomWallHardwareInfo;
        finish: number;
        leftCornerType: CornerTypeEnum;
        rightCornerType: CornerTypeEnum;
        leftHoldType: WallPlankHoldTypeEnum;
        rightHoldType: WallPlankHoldTypeEnum;
        clockwise: boolean;
        width: number;
        height: number;
        _thickness: number;
        holes: BathroomWallHoleData[];
        baseLayerData: BathroomWallBaseLayerData;
        hardwares: BathroomWallHardwareData[];
        floorWetSideHoles: BathroomWallHoleData[];
        static DEFAULT_CREVICE_WIDTH: number;
        constructor();
        get thickness(): number;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/bathroomwall/BathroomWallBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomWallElement } from 'sk/data/scheme/database/pattern/element/BathroomWallElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeLibraryFamilyDocumentService } from 'sk/data/scheme/config/SchemeLibraryFamilyDocumentService';
    import { BathroomTileData } from "sk/rule/data/rule/bathroomlayout/BathroomDataUtil";
    import { BathroomWallData, BathroomWallHoleData, BathroomWallPlankTypeEnum, BathroomWallPlankData } from "sk/rule/data/rule/bathroomlayout/bathroomwall/BathroomWallData";
    export enum AssembleLinkCodeEnum {
        Default = "default.plank",
        OuterBegin = "outer.begin.plank",
        OuterEnd = "outer.end.plank",
        OverHole = "over.hole.plank",
        UnderHole = "under.hole.plank"
    }
    export class BathroomWallBuilder {
        static DEFAULT_CREVICE_WIDTH: number;
        static DEFAULT_SIDE_PLANK_MIN_WIDTH: number;
        protected _schemeConfigService: SchemeConfigService;
        protected _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        buildAsync(context: ElementPerformerContext, element: BathroomWallElement): Promise<ResultObject<BathroomWallData>>;
        getBathroomWallDataAsync(context: ElementPerformerContext, element: BathroomWallElement): Promise<ResultObject<BathroomWallData>>;
        createDataByElement(context: ElementPerformerContext, element: BathroomWallElement): BathroomWallData;
        loadFamilyInfoAsync(context: ElementPerformerContext, element: BathroomWallElement, data: BathroomWallData): Promise<ResultObject>;
        computeData(context: ElementPerformerContext, element: BathroomWallElement, data: BathroomWallData): void;
        getWallPlankData(context: ElementPerformerContext, element: BathroomWallElement, wallData: BathroomWallData): void;
        private createPlankData;
        createChildElementAsync(context: ElementPerformerContext, element: BathroomWallElement, data: BathroomWallData): Promise<ResultObject>;
        createPlankElementAsync(context: ElementPerformerContext, layerElement: ContainerElement, wallData: BathroomWallData, plankData: BathroomWallPlankData): Promise<ResultObject>;
        cleanWareElement(plank: FamilyInstanceElement): void;
        computeWallPlankData(context: ElementPerformerContext, wallData: BathroomWallData): void;
        computeWallTileData(context: ElementPerformerContext, wallData: BathroomWallData, plankData: BathroomWallPlankData, dividedNum: number): Array<BathroomTileData>;
        createPlankDataByHole(holeData: BathroomWallHoleData, wallData: BathroomWallData, familyInfos: {
            under: ISpecificationFamilyInfo;
            over: ISpecificationFamilyInfo;
        }): void;
        createPlankDataByLength(x: number, y: number, length: number, height: number, familyInfo: ISpecificationFamilyInfo, plankList: BathroomWallPlankData[], type: BathroomWallPlankTypeEnum, minWidth?: number, reverse?: boolean): void;
        private getLengthInfosByWallData;
        isHolesValid(holes: BathroomWallHoleData[]): boolean;
        static getHoleDatasByWallElement(wallElement: BathroomWallElement): BathroomWallHoleData[];
        private static sortHoleFun;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomDataUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { WallPlankHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/bathroom/WallPlankHoldTypeEnum';
    import { AssembleBathroomFloorDryPatternElement } from 'sk/data/family/database/pattern/element/AssembleBathroomFloorDryPatternElement';
    import { AssembleBathroomFloorDryPlankPatternElement } from 'sk/data/family/database/pattern/element/AssembleBathroomFloorDryPlankPatternElement';
    import { AssembleBathroomWallPatternElement } from 'sk/data/family/database/pattern/element/AssembleBathroomWallPatternElement';
    import { AssembleIntegrationCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleIntegrationCeilingPatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ComponentPatternElement } from 'sk/data/family/element/pattern/ComponentPatternElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PatternLinkTypeEnum } from 'sk/data/family/enumeration/PatternLinkTypeEnum';
    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';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { BathroomCeilingElement } from 'sk/data/scheme/database/pattern/element/BathroomCeilingElement';
    import { BathroomDoorElement } from 'sk/data/scheme/database/pattern/element/BathroomDoorElement';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { BathroomWallElement } from 'sk/data/scheme/database/pattern/element/BathroomWallElement';
    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 { ProductLinkEnum } from 'sk/data/logic/module/enumeration/ProductLinkEnum';
    import { BathroomPlankData, BathroomBaseData } from "sk/rule/data/rule/bathroomlayout/BathroomDataUtil";
    import { BathroomFloorDryData } from "sk/rule/data/rule/bathroomlayout/BathroomFloorDryData";
    export type BathroomWallLayerInfo = {
        antiClockwise?: boolean;
        defaultFamilyId: string;
        overFamilyId: string;
        underFamilyId: string;
        outerCornerStartFamilyId: string;
        outerCornerEndFamilyId: string;
        defaultFamilyInfo?: ISpecificationFamilyInfo;
        overFamilyInfo?: ISpecificationFamilyInfo;
        underFamilyInfo?: ISpecificationFamilyInfo;
        outerCornerStartFamilyInfo?: ISpecificationFamilyInfo;
        outerCornerEndFamilyInfo?: ISpecificationFamilyInfo;
        code: string;
    };
    export type BathroomDoorInfo = {
        familyId: string;
        familyInfo?: ISpecificationFamilyInfo;
        code?: string;
    };
    export type BathroomCeilingInfo = {
        familyId: string;
        familyInfo?: ISpecificationFamilyInfo;
        code?: string;
    };
    export type BathroomFloorDryInfo = {
        edgeThickness?: number;
        edgeHeight?: number;
        code?: string;
        floorDryPlankInfo?: BathroomFloorDryPlankInfo;
        floorDryPlankFamilyId?: string;
    };
    export type BathroomFloorDryPlankInfo = {
        familyId: string;
        familyInfo?: ISpecificationFamilyInfo;
    };
    export class BathroomHardwareInfo {
        familyId: string;
        familyInfo?: ISpecificationFamilyInfo;
        code?: string;
    }
    export class BathroomHardwareData {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        info: BathroomHardwareInfo;
    }
    export class BathroomWallPlankTypeEnum {
        static Default: string;
        static Over: string;
        static Under: string;
        static OuterCornerStart: string;
        static OuterCornerEnd: string;
    }
    export class BathroomWallPlankData extends BathroomPlankData {
        type: BathroomWallPlankTypeEnum;
        constructor(x: number, y: number, width: number, height: number, type?: BathroomWallPlankTypeEnum);
    }
    export class BathroomWallLayerData {
        info: BathroomWallLayerInfo;
        leftOffset: number;
        rightOffset: number;
        topOffset: number;
        bottomOffset: number;
        backOffset: number;
        planks: BathroomWallPlankData[];
        constructor();
    }
    export type BathroomHoleData = {
        x: number;
        y: number;
        width: number;
        height: number;
        type?: "door" | "window";
    };
    export class BathroomCeilingData extends BathroomBaseData {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        info: BathroomCeilingInfo;
        polygon: Line2[];
        planks: BathroomPlankData[];
        protected static _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        constructor();
        get lengthZ(): number;
        static getCeilingInfoByCeilingElementAsync(context: ElementPerformerContext, ceilingElement: BathroomCeilingElement): Promise<ResultObject<BathroomCeilingInfo>>;
        static createDataByCeilingElementAsync(context: ElementPerformerContext, ceilingElement: BathroomCeilingElement): Promise<ResultObject<BathroomCeilingData>>;
    }
    export class BathroomDoorData extends BathroomBaseData {
        collisionLine: Line2;
        bathLine: Line2;
        x: number;
        y: number;
        z: number;
        rotationZ: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        info: BathroomDoorInfo;
        constructor(collisionLine?: Line2);
        static getDoorInfoByDoorElementAsync(context: ElementPerformerContext, doorElement: BathroomDoorElement): Promise<ResultObject<BathroomDoorInfo>>;
        static createDataByDoorElementAsync(context: ElementPerformerContext, doorElement: BathroomDoorElement): Promise<ResultObject<BathroomDoorData>>;
    }
    export class BathroomWallData extends BathroomBaseData {
        finish: number;
        width: number;
        height: number;
        begin: Vector2;
        end: Vector2;
        finishLine: Line2;
        leftCornerType: CornerTypeEnum;
        rightCornerType: CornerTypeEnum;
        leftHoldType: WallPlankHoldTypeEnum;
        rightHoldType: WallPlankHoldTypeEnum;
        clockwise: boolean;
        holes: BathroomHoleData[];
        innerCornerHardwareInfo: BathroomHardwareInfo;
        outerCornerHardwareInfo: BathroomHardwareInfo;
        parallelCornerHardwareInfo: BathroomHardwareInfo;
        connectFloorHardwareInfo: BathroomHardwareInfo;
        hardwares: BathroomHardwareData[];
        private _thickness;
        isNoSpace: boolean;
        bathroomLine: Line2;
        layers: BathroomWallLayerData[];
        protected static _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        constructor(wall?: BathroomWallElement, bathroomLine?: Line2, origin?: Value2);
        static getWallInfoByWallElementAsync(context: ElementPerformerContext, wallElement: BathroomWallElement): Promise<ResultObject<BathroomWallLayerInfo>>;
        static createDataByWallElementAsync(context: ElementPerformerContext, wallElement: BathroomWallElement): Promise<ResultObject<BathroomWallData>>;
        get thickness(): number;
    }
    export class BathroomAreaData {
        polygon: Line2[];
        _lengthX: number;
        _lengthY: number;
        lengthZ: number;
        _x: number;
        _y: number;
        clockwise: boolean;
        element?: ContainerElement;
        walls: BathroomWallData[];
        ceiling: BathroomCeilingData;
        floorDry: BathroomFloorDryData;
        constructor();
        private computeLength;
        get x(): number;
        get y(): number;
        get lengthX(): number;
        get lengthY(): number;
    }
    export class BathroomData extends BathroomBaseData {
        wallTypeCd: PatternLinkTypeEnum;
        ceilingTypeCd: PatternLinkTypeEnum;
        floorDryTypeCd: PatternLinkTypeEnum;
        wallProductCd: ProductLinkEnum;
        ceilingProductCd: ProductLinkEnum;
        floorDryProductCd: ProductLinkEnum;
        floorDryPlankProductCd: ProductLinkEnum;
        doorProductCd: ProductLinkEnum;
        wallInfoId: string;
        ceilingInfoId: string;
        floorDryInfoId: string;
        floorDryPlankInfoId: string;
        doorInfoId: string;
        wallComponentElement: AssembleBathroomWallPatternElement;
        ceilingComponentElement: AssembleIntegrationCeilingPatternElement;
        floorDryComponentElement: AssembleBathroomFloorDryPatternElement;
        floorDryPlankComponentElement: AssembleBathroomFloorDryPlankPatternElement;
        roomNode: RoomNode;
        position: Vector3;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        points: Vector2[];
        wallLayerInfos: BathroomWallLayerInfo[];
        ceilingInfo: BathroomCeilingInfo;
        floorDryInfo: BathroomFloorDryInfo;
        doorInfo: BathroomDoorInfo;
        clockwise: boolean;
        areas: BathroomAreaData[];
        doors: BathroomDoorData[];
        constructor(room: RoomNode | BathroomElement);
    }
    export class BathroomDataUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        protected static _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        static margeLineForPoygon(polygon: Line2[]): void;
        private static isPointOnLine;
        static setPropertyByBathroomData(roomElement: BathroomElement, roomData: BathroomData): void;
        static appendPolygonByCeilingElement(ceilingData: BathroomCeilingData, ceilingElement: BathroomCeilingElement): void;
        static getHoleDatasByWallElement(wallElement: any): BathroomHoleData[];
        static appendHolesByWallElement(wallData: BathroomWallData, wallElement: BathroomWallElement): void;
        static appendHolesByWallData(wallElement: BathroomWallElement, wallData: BathroomWallData): void;
        static appendPolygonByCeilingData(ceilingElement: BathroomCeilingElement, ceilingData: BathroomCeilingData): void;
        static createHoleDatas(bathroomWallData: BathroomWallData, wallSurfaces: WallSurfaceNode[], line: Line2, origin?: Value2): void;
        static createWallDatas(bathRoomData: BathroomData, areaData: BathroomAreaData, areaContainerElement?: ContainerElement): void;
        private static isLineOnWallSurface;
        static isLineOnLine(line1: Line2, line2: Line2, join?: boolean): boolean;
        static createDoorData(roomData: BathroomData, roomElement?: BathroomElement): void;
        static createCeilingData(bathroomData: BathroomData, areaData: BathroomAreaData, areaContainerElement?: ContainerElement): BathroomCeilingData;
        static getPointsBySectionSurfaceStructure(polygon: SectionSurfaceStructure, origin?: Vector2): Vector2[];
        static getCollisionLines(areaData1: BathroomAreaData, areaData2: BathroomAreaData): Line2[];
        static getCollisionLine(line1: Line2, line2: Line2): Line2;
        static getPointsSortFun: (compareField: string, dv: number) => (point1: Vector2, point2: Vector2) => number;
        static getLineInfos(wallSurface: WallSurfaceNode): {
            line: Line2;
            isOnColumn: boolean;
        }[];
        static getColumnPointInfosList(columns: Types<ColumnNode>, line: Line2): {
            outerPoint: Vector2;
            linePoint: Vector2;
        }[][];
        static getOpeningOffset(line: Line2, opening: OpeningNode): number;
        private static sortByX;
        private static getSortPointByLine;
        private static getSortPointsByLine;
        static getBathroomHeight(roomHeight: number): number;
        static isClockwise(points: Vector2[]): boolean;
        static cutPlankElementToMilling(plankElement: FamilyInstanceElement, plankData: BathroomPlankData, familyInfo: ISpecificationFamilyInfo, clockwise: boolean): void;
        static cutPlankElementToEdgeSurface(plankElement: FamilyInstanceElement, plankData: BathroomPlankData): void;
        static getEdgeSurfaceDecorateValueStructure(plankElement: PlankElement): DecorateValueStructure;
        static createPlankElementAsync(context: ElementPerformerContext, parentElement: ContentInstanceElement, familyInfo: ISpecificationFamilyInfo, plankData: BathroomPlankData): Promise<ResultObject>;
        static computeCeilingPolygon(areaData: BathroomAreaData): void;
        static appendHolesByDoors(wallData: BathroomWallData, doorDatas: BathroomDoorData[]): void;
        static computeFinishLine(option: {
            remain: BathroomWallData;
            last: BathroomWallData;
            next: BathroomWallData;
            lastCornerType: CornerTypeEnum;
            nextCornerType: CornerTypeEnum;
        }): void;
        static getRectInfoByPolygon(polygon: Line2[] | Value2[]): {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        static cutPlankData(plankData: BathroomPlankData, polygon: Line2[]): void;
        static getBathroomWorkPolygon(areaData: BathroomAreaData): Value2[];
        static loadFamilyInfoByWallPatternInfoIdAsync(context: ElementPerformerContext, wallData: BathroomWallData, wallPatternInfoId: string): Promise<ResultObject>;
        static getSpecificationFamilyInfoByFamilyIdAsync(context: ElementPerformerContext, familyId: string): Promise<ResultObject<ISpecificationFamilyInfo>>;
        static getComponentPatternElementByPatternInfoIdAsync(context: ElementPerformerContext, patternInfoId: string): Promise<ResultObject<ComponentPatternElement>>;
        static loadPatternElementByPatternInfoIdAsync(context: ElementPerformerContext, roomData: BathroomData, patternInfoId: string): Promise<ResultObject>;
        static getInfoByLinkerPatternElementAsync(context: ElementPerformerContext, linkerPatternElement: LinkerPatternElement): Promise<ResultObject<{
            infoId: string;
            componentElement?: ComponentElement;
            productLinkCd?: ProductLinkEnum;
        }>>;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomWallElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { CornerTypeEnum } from 'sk/data/family/enumeration/pattern/rule/CornerTypeEnum';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomWallElement } from 'sk/data/scheme/database/pattern/element/BathroomWallElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    import { BathroomData, BathroomWallLayerData, BathroomWallData, BathroomWallPlankData, BathroomHoleData, BathroomWallLayerInfo, BathroomWallPlankTypeEnum, BathroomAreaData } from "sk/rule/data/rule/assemble/BathroomDataUtil";
    type WallComputeOption = {
        remain: BathroomWallData;
        left: BathroomWallData;
        right: BathroomWallData;
        last: BathroomWallData;
        next: BathroomWallData;
        lastCornerType: CornerTypeEnum;
        nextCornerType: CornerTypeEnum;
    };
    export class BathroomWallElementUtil {
        static DEFAULT_FINISH: number;
        static DEFAULT_CREVICE_WIDTH: number;
        static DEFAULT_WALL_FINISH: number;
        private static _schemeLibraryFamilyDocumentService;
        protected static _schemeConfigService: SchemeConfigService;
        protected static _calculatorService: CalculatorService;
        static updateBathroomWallElementsAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static createBathroomWallElementsByAreaAsync(context: ElementPerformerContext, roomContext: BathroomContext, polygons: Vector2[][], polygon: Vector2[], area: BathroomAreaElement): Promise<ResultObject>;
        private static createBathroomWallByLine;
        static updateloopWallsRelation(walls: Array<BathroomWallElement>): void;
        private static getHolesByBathroomElement;
        private static getHolesByRoomNode;
        private static getHoleType;
        static getOpeningOffset(line: Line2, opening: OpeningNode): any;
        private static sortByX;
        static getPointsSortFun: (compareField: string, dv: number) => (point1: Vector2, point2: Vector2) => number;
        static adjustWallPress(formerWall: BathroomWallElement, latterWall: BathroomWallElement): void;
        static createData(roomData: BathroomData, areaData: BathroomAreaData, areaContainerElement?: ContainerElement): void;
        static computeWallDatasByRoomDataAsync(context: ElementPerformerContext, roomData: BathroomData, areaData: BathroomAreaData): Promise<ResultObject>;
        static computeHoldType(wallElement: BathroomWallElement): void;
        static loadPlankFamilyInfoByWallLayerInfoAsync(context: ElementPerformerContext, layerInfo: BathroomWallLayerInfo, height: number): Promise<ResultObject>;
        static computeWallDataAsync(context: ElementPerformerContext, wallData: BathroomWallData): Promise<ResultObject>;
        static computeLayersOffset(option: WallComputeOption, bottomOffset: number): void;
        static computeWallPlankDataAsync(context: ElementPerformerContext, wallData: BathroomWallData, layerData: BathroomWallLayerData): Promise<ResultObject>;
        static createPlankDataByHole(holeData: BathroomHoleData, wallData: BathroomWallData, familyInfos: {
            under: ISpecificationFamilyInfo;
            over: ISpecificationFamilyInfo;
        }, layerData: BathroomWallLayerData): void;
        static createPlankDataByLength(x: number, y: number, length: number, height: number, familyInfo: ISpecificationFamilyInfo, plankList: BathroomWallPlankData[], type: BathroomWallPlankTypeEnum): void;
        private static getAreaInfosByWallData;
        static createWallElementAsync(context: ElementPerformerContext, areaContainerElement: ContainerElement, wallData: BathroomWallData): Promise<ResultObject>;
        static createContainerElementAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData, layerData: BathroomWallLayerData): Promise<ResultObject>;
        static createPlankElementAsync(context: ElementPerformerContext, layerElement: ContainerElement, layerData: BathroomWallLayerData, plankData: BathroomWallPlankData): Promise<ResultObject>;
        static getBathroomWallFamilyInfoIdsAsync(context: ElementPerformerContext, element: BathroomWallElement): Promise<ResultObject<{
            baseId: string;
            steeve: string;
            nail: string;
            clipKeel: string;
            edgeKeel: string;
            connection: string;
            viceKeel: string;
            viceKeelConnection: string;
        }>>;
        static getValidWallFamilyInfoAsync(context: ElementPerformerContext, familyId: string, height?: number): Promise<ResultObject<ISpecificationFamilyInfo>>;
        static getCornerType(wallElement1: BathroomWallElement, wallElement2: BathroomWallElement, clockwise?: boolean): CornerTypeEnum;
        static isHolesValid(holes: BathroomHoleData[]): void;
        static buildWallElementAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData?: BathroomWallData): Promise<ResultObject<BathroomWallData>>;
        private static isLineOnWallSurface;
        static isLineOnLine(line1: Line2, line2: Line2, join?: boolean): boolean;
        private static isPointOnLine;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomContentContext" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssembleBathroomPatternElement } from 'sk/data/family/database/pattern/element/AssembleBathroomPatternElement';
    import { BathroomPatternElement } from 'sk/data/family/database/pattern/element/BathroomPatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDataDocument } from 'sk/data/family/model/FamilyDataDocument';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomClosestoolElement } from 'sk/data/scheme/database/pattern/element/BathroomClosestoolElement';
    import { BathroomConverElement } from 'sk/data/scheme/database/pattern/element/BathroomConverElement';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { BathroomFloorDrainElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDrainElement';
    import { BathroomFloorWetElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetElement';
    import { BathroomHeaterElement } from 'sk/data/scheme/database/pattern/element/BathroomHeaterElement';
    import { BathroomShowerElement } from 'sk/data/scheme/database/pattern/element/BathroomShowerElement';
    import { BathroomSpliterElement } from 'sk/data/scheme/database/pattern/element/BathroomSpliterElement';
    import { BathroomWallCupboardElement } from 'sk/data/scheme/database/pattern/element/BathroomWallCupboardElement';
    import { FloorCupboardElement } from 'sk/data/scheme/database/pattern/element/FloorCupboardElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    export class BathroomContentContext {
        context: ElementPerformerContext;
        bathroomContext: BathroomContext;
        document: SchemeDocument;
        bathroom: AssembleBathroomElement;
        proxyBathroom: BathroomElement;
        areas: Array<BathroomAreaElement>;
        assemblePatternElement: AssembleBathroomPatternElement;
        proxyPatternElement: BathroomPatternElement;
        closestoolDecorateValue: DecorateValueStructure;
        closestoolContent: any;
        closestoolFamilyDataDocument: FamilyDataDocument;
        heaterDecorateValue: DecorateValueStructure;
        heaterContent: any;
        spliterDecorateValue: DecorateValueStructure;
        spliterContent: any;
        ceilingConverDecorateValue: DecorateValueStructure;
        ceilingConverContent: any;
        showerDecorateValue: DecorateValueStructure;
        showerContent: any;
        floorWetDecorateValue: DecorateValueStructure;
        floorWetContent: any;
        floorCabinetDecorateValue: DecorateValueStructure;
        floorCabinetContent: any;
        washBasinDecorateValue: DecorateValueStructure;
        washBasinContent: any;
        waterTapDecorateValue: DecorateValueStructure;
        waterTapContent: any;
        wallCabinetDecorateValue: DecorateValueStructure;
        wallCabinetContent: any;
        floorDrainDecorateValue: DecorateValueStructure;
        floorDrainContent: any;
        closestool: BathroomClosestoolElement;
        heater: BathroomHeaterElement;
        conver: BathroomConverElement;
        shower: BathroomShowerElement;
        floorCupboard: FloorCupboardElement;
        wallCupboard: BathroomWallCupboardElement;
        floorWet: BathroomFloorWetElement;
        spliter: BathroomSpliterElement;
        floorDrain: BathroomFloorDrainElement;
        loadAllContentsAsync(context: ElementPerformerContext, proxyBathroom: BathroomElement, bathroom: AssembleBathroomElement): Promise<ResultObject>;
        loadWetFloorAsync(context: ElementPerformerContext, proxyBathroom: BathroomElement, bathroom: AssembleBathroomElement): Promise<ResultObject>;
        private loadBaseAsync;
        private loadContentAsync;
        private loadClosestoolContentAsync;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { BathroomContentContext } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentContext";
    export class BathroomContentBuilder {
        bathroom: AssembleBathroomElement;
        document: SchemeDocument;
        element: PatternInstanceElement;
        contentContext: BathroomContentContext;
        protected _schemeConfigService: SchemeConfigService;
        constructor(contentContext: BathroomContentContext, bathroom: AssembleBathroomElement);
        put(context: IContext): void;
        buildAsync(context: ElementPerformerContext): Promise<ResultObject>;
        protected computeWallOutlines(): PathCurve2d[];
        protected createPathFromPoints(points: Vector2[]): PathCurve2d;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomFloorWetBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    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 { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomFloorElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorElement';
    import { BathroomFloorWetElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetElement';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export type FarPointAndLineResult = {
        point: Vector2;
        line: LineCurve2d;
    };
    export class BathroomFloorWetBuilder extends BathroomContentBuilder {
        static DEFAULT_EDGE_THICKNESS: number;
        static DEFAULT_EDGE_HEIGHT: number;
        set(parent: BathroomFloorElement): void;
        put(): void;
        protected computeFloorWetLine(): LineCurve2d;
        protected computeWetFloorLinesPre(): LineCurve2d[];
        protected computeWindowLines(): LineCurve2d[];
        protected computeRealWetFloorLines(prewetfloorlines: LineCurve2d[], windowlines: LineCurve2d[]): LineCurve2d;
        protected computeNotOverWetFloorLine(prewetfloorlines: LineCurve2d[], windowlines: LineCurve2d[]): LineCurve2d;
        protected checkLineIntersectionWithSeg(point: Vector2, direction: Vector2, line: Line2): boolean;
        protected computeNodeInnerLine(node: ContentNode): LineCurve2d;
        protected computeDoorPos(): Vector2;
        protected computeWetFloorLinesFromFarPoints(walloutline: PathCurve2d, farpoints: Vector3[]): LineCurve2d[];
        protected computeFarWetFloorLinesFromDoor(walloutline: PathCurve2d, doorpos: Vector2): LineCurve2d[];
        protected getPointFromLineCurve(distance2begin: number, linecurve: LineCurve2d): Vector3;
        protected pointsContainPoint(points: Vector3[], point: Vector3): boolean;
        protected computeRandomWallInnerPosition(area: BathroomAreaElement, wallThickness: number): Vector2;
        computeFloorWetOutline(floorwet: BathroomFloorWetElement): void;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
        private findClosedWallElement;
        private calculateLayoutPositon;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomCeilingElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomCeilingElement } from 'sk/data/scheme/database/pattern/element/BathroomCeilingElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeLibraryFamilyDocumentService } from 'sk/data/scheme/config/SchemeLibraryFamilyDocumentService';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    import { BathroomData, BathroomCeilingData, BathroomAreaData } from "sk/rule/data/rule/assemble/BathroomDataUtil";
    export class BathroomCeilingElementUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        static DEFAULT_FINISH: number;
        static createData(roomData: BathroomData, areaData: BathroomAreaData, areaContainerElement?: ContainerElement): void;
        static createCeilingElementByAreaAsync(context: ElementPerformerContext, roomContext: BathroomContext, area: BathroomAreaElement): Promise<ResultObject>;
        static updateCeilingAsync(context: ElementPerformerContext, ceilingElement: BathroomCeilingElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static computeCeilingDataByRoomDataAsync(context: ElementPerformerContext, roomData: BathroomData, areaData: BathroomAreaData): Promise<ResultObject>;
        static computeCeilingDataAsync(context: ElementPerformerContext, ceilingData: BathroomCeilingData): Promise<ResultObject>;
        static createCeilingElementAsync(context: ElementPerformerContext, areaContainerElement: ContainerElement, ceilingData: BathroomCeilingData): Promise<ResultObject>;
        static buildCeilingElementAsync(context: ElementPerformerContext, ceilingElement: BathroomCeilingElement, ceilingData?: BathroomCeilingData): Promise<ResultObject<BathroomCeilingData>>;
        static getValidCeilingFamilyInfoAsync(context: ElementPerformerContext, familyId: string): Promise<ResultObject<ISpecificationFamilyInfo>>;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/BathroomValidatorUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { BathroomCeilingNode } from 'sk/data/scheme/database/pattern/node/BathroomCeilingNode';
    import { BathroomClosestoolNode } from 'sk/data/scheme/database/pattern/node/BathroomClosestoolNode';
    import { BathroomFloorDrainNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorDrainNode';
    import { BathroomFloorDryNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorDryNode';
    import { BathroomFloorWetNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorWetNode';
    import { BathroomWallNode } from 'sk/data/scheme/database/pattern/node/BathroomWallNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class BathroomValidatorUtil {
        private static PIT_TO_WALL_DISTANCE;
        private static FLOORDRAIN_TO_WALL_DISTANCE;
        private static ROOM_MIN_LENGTHX;
        private static ROOM_MIN_LENGTHY;
        private static AREA_MIN_LENGTHX;
        private static AREA_MIN_LENGTHY;
        private static ROOM_MIN_HEIGHT;
        private static PLANK_TO_WALL_DISTANCE;
        private static OPOING_TO_WALL_DISTANCE;
        private static FLOORDRY_MIN_LENGTHX;
        private static FLOORDRY_MIN_LENGTHY;
        protected static _calculatorService: CalculatorService;
        protected static _schemeConfigService: SchemeConfigService;
        static bathroomValidTestAsync(context: any, node: any): Promise<void>;
        static getFloorDryTileNodes(node: ContentInstanceNode): Array<any>;
        static bathroomWallPlankNodeValidTest(context: ValidateContext, node: BathroomWallNode): boolean;
        static bathroomFloorWetNodeValidTestAsync(context: ValidateContext, node: BathroomFloorWetNode): Promise<boolean>;
        static bathroomCeilingFinishValidTest(context: ValidateContext, node: BathroomCeilingNode): boolean;
        private static checkFloorWetCuttingFormatAsync;
        static bathroomFloorDryNodeValidTestAsync(context: ValidateContext, node: BathroomFloorDryNode): Promise<boolean>;
        static computePolygonByFloorWetElement(floorDryElement: BathroomFloorDryElement, floorDryPolygon: any): Promise<ResultObject>;
        static getWetValidPolygon(wetPolygon: Vector2[], dryPolygon: Vector2[]): Value2[];
        static isAdjacent(line: Line2, polygon: Value2[]): boolean;
        static isLineInside(line1: Line2, line2: Line2): boolean;
        static roomValidTest(context: ValidateContext, roomNode: RoomNode): void;
        static bathroomAreaValidTest(context: ValidateContext, roomNode: RoomNode): boolean;
        static bathroomFloorDrainValidTest(context: ValidateContext, node: BathroomFloorDrainNode, roomNode: RoomNode): boolean;
        static bathroomClosestoolValidTest(context: ValidateContext, node: BathroomClosestoolNode, roomNode: RoomNode): boolean;
        static bathroomPitValidTest(context: ValidateContext, pitNode: WareNode, wallNodes: Types<WallNode>): any;
        static bathroomRoomNodeValidTest(context: ValidateContext, roomNode: RoomNode): any;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomDoorElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeLibraryFamilyDocumentService } from 'sk/data/scheme/config/SchemeLibraryFamilyDocumentService';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    import { BathroomSplitData } from "sk/rule/data/rule/assemble/BathroomSplitData";
    export class BathroomDoorElementUtil {
        static DEFAULT_WALL_FINISH: number;
        protected static _schemeConfigService: SchemeConfigService;
        protected static _schemeLibraryFamilyDocumentService: SchemeLibraryFamilyDocumentService;
        static createDoorElementsAsync(context: ElementPerformerContext, roomContext: BathroomContext, splitData: BathroomSplitData, roomElement: BathroomElement): Promise<ResultObject>;
        static createDoorElementByLineAsync(context: ElementPerformerContext, roomContext: BathroomContext, roomElement: BathroomElement, line: Line2): Promise<ResultObject>;
        static getCollisionLines(areaData1: Vector2[], areaData2: Vector2[]): Line2[];
        static getCollisionLine(line1: Line2, line2: Line2): Line2;
        static isLineOnLine(line1: Line2, line2: Line2, join?: boolean): boolean;
        private static isPointOnLine;
        static getPointsSortFun: (compareField: string, dv: number) => (point1: Vector2, point2: Vector2) => number;
    }
}
declare module "sk/rule/data/pattern/process/BathroomFloorDryStructureCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { BathroomTileData } from "sk/rule/data/rule/bathroomlayout/BathroomDataUtil";
    import { BathroomFloorDryData, BathroomFloorDryPlankData, BathroomFloorDryHardwareData } from "sk/rule/data/rule/bathroomlayout/BathroomFloorDryData";
    export class BathroomFloorDryStructureCalculator {
        private static TO_FOORDRY_X_EDGE_DISTANCE;
        private static TO_FOORDRY_Y_EDGE_DISTANCE;
        private static FLOORKEEL_X_EDGE_DISTANCE;
        private static FLOORKEEL_INTERVAL_MIN_DISTANCE;
        private static FLOORKEEL_INTERVAL_MAX_DISTANCE;
        private static FLOORKEEL_X_AXIS_LAYOUT;
        private static FLOORKEEL_Y_AXIS_LAYOUT;
        private static CLOSESTOOL_ANCHOR_DIAMETER;
        private static FLOORDRYPLANK_MIN_EDGE_1840;
        private static FLOORDRYPLANK_MIN_EDGE_1400;
        private static FLOORDRYPLANK_MIN_EDGE_1000;
        protected static _schemeConfigService: SchemeConfigService;
        static buildAsync(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): Promise<ResultObject>;
        static loadFamilyInfoAsync(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): Promise<ResultObject>;
        static computeData(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): ResultObject;
        static computeFloorDryHardwareData(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): void;
        static computeFloorDryAndWetConnectHardwareData(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): void;
        static computeFloorKeelHardwareDataAsync(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): Promise<ResultObject>;
        static createAsync(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): Promise<ResultObject>;
        static createFloorDryTileElementAsync(context: ElementPerformerContext, parentElement: ContainerElement, floorDryData: BathroomFloorDryData, tileData: BathroomTileData): Promise<ResultObject<FamilyInstanceElement>>;
        static createFloorDryPlankElementAsync(context: ElementPerformerContext, parentElement: ContainerElement, floorDryData: BathroomFloorDryData, floorDryPlankData: BathroomFloorDryPlankData): Promise<ResultObject>;
        static setFamilyInfo(familyInfo: ISpecificationFamilyInfo, element: FamilyInstanceElement): void;
        static computeFloorDryFloorMatData(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): void;
        static computePolygonByFloorWetElement(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData): ResultObject;
        static getWetValidPolygon(wetPolygon: Vector2[], dryPolygon: Vector2[]): Value2[];
        static isAdjacent(line: Line2, polygon: Value2[]): boolean;
        static isLineInside(line1: Line2, line2: Line2): boolean;
        static computeFloorDryAndWetIntersectPolygon(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement): Array<LineCurve2d>;
        static computFloorDryAndWetConnectorData(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, floorDryData: BathroomFloorDryData, line: LineCurve2d, code?: string): void;
        static createFloorHardwareElementAsync(context: ElementPerformerContext, contentElement: ContentElement, floorDryData: BathroomFloorDryData, hardwareData: BathroomFloorDryHardwareData): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomFloorDryElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { BathroomFloorDryPlankPatternElement } from 'sk/data/family/database/pattern/element/BathroomFloorDryPlankPatternElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BathroomFloorDryPlankElement } from 'sk/data/scheme/database/assemble/element/BathroomFloorDryPlankElement';
    import { BathroomFloorDryPlankNode } from 'sk/data/scheme/database/assemble/node/BathroomFloorDryPlankNode';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { BathroomFloorElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { BathroomFloorDryData } from "sk/rule/data/rule/bathroomlayout/BathroomFloorDryData";
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    import { BathroomAreaData, BathroomData } from "sk/rule/data/rule/assemble/BathroomDataUtil";
    export class BathroomFloorDryElementUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _calculatorService: CalculatorService;
        static createFloorDryElementByFloorAsync(context: ElementPerformerContext, roomContext: BathroomContext, floor: BathroomFloorElement): Promise<ResultObject>;
        static updateFloorDryAsync(context: ElementPerformerContext, floorDryElement: BathroomFloorDryElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        private static createDataByElement;
        static loadFamilyInfoAsync(context: ElementPerformerContext, element: BathroomFloorDryElement, data: BathroomFloorDryData): Promise<ResultObject>;
        static createFloorDryElementAsync(context: ElementPerformerContext, roomData: BathroomData, areaContainerElement: ContainerElement, areaData: BathroomAreaData): Promise<ResultObject>;
        static getBathroomFloorPolygon(areaData: BathroomAreaData, floorEdgeThickness: number): Line2[];
        static appendPolygonByFloorDryData(floorDryElement: BathroomFloorDryElement, polygon: Line2[]): void;
        static computePlankOutlineAsync(context: ElementPerformerContext, element: BathroomFloorDryPlankElement, node: BathroomFloorDryPlankNode, bathroomFloorDryPlankPatternElement?: BathroomFloorDryPlankPatternElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomFloorWetElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BathroomFloorElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorElement';
    import { BathroomFloorWetElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetElement';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    export class BathroomFloorWetElementUtil {
        static createFloorWetElementByFloorAsync(context: ElementPerformerContext, roomContext: BathroomContext, floor: BathroomFloorElement): Promise<ResultObject>;
        static updateFloorDryAsync(context: ElementPerformerContext, floorDryElement: BathroomFloorWetElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomFloorElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomFloorElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorElement';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    export class BathroomFloorElementUtil {
        static createFloorElementByAreaAsync(context: ElementPerformerContext, roomContext: BathroomContext, area: BathroomAreaElement): Promise<ResultObject>;
        static updateBathroomFloorElementsAsync(context: ElementPerformerContext, floorElement: BathroomFloorElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomPartElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    export class BathroomPartElementUtil {
        static createPartElementByAreaAsync(context: ElementPerformerContext, roomContext: BathroomContext, area: BathroomAreaElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { DoorNode } from 'sk/data/scheme/database/floorplan/model/DoorNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { SchemeLibraryPatternDocumentService } from 'sk/data/scheme/config/SchemeLibraryPatternDocumentService';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    type BathroomContentOptions = {
        washtable: boolean;
        closestool: boolean;
        conver: boolean;
        floorWet: boolean;
        heater: boolean;
        shower: boolean;
        spliter: boolean;
        drain: boolean;
    };
    export class BathroomElementUtil {
        protected static _schemeLibraryPatternDocumentService: (SchemeLibraryPatternDocumentService);
        static createBathroomAsync(context: ElementPerformerContext, bathroom: BathroomElement, room: RoomNode, options?: BathroomContentOptions): Promise<ResultObject>;
        static getDoorHoleByAreaElement(area: BathroomAreaElement): {
            x: number;
            y: number;
            rotationZ: number;
            width: number;
            height: number;
        };
        private static getDoorHoleInfoByWallElements;
        static getAreaByName(name: string, areas: BathroomAreaElement[]): any;
        static getLastAreaByDoor(door: DoorNode, areas: BathroomAreaElement[]): BathroomAreaElement;
        static isPolygonAdjacent(points1: {
            x: number;
            y: number;
        }[], points2: {
            x: number;
            y: number;
        }[]): boolean;
        static getBathroomOfRoom(room: RoomNode): BathroomElement;
        static syncBathroom(room: RoomNode, bathroom?: BathroomElement): BathroomElement;
        static createAssembleBathroomElement(context: ElementPerformerContext, roomContext: BathroomContext, parentElement: NestElement): AssembleBathroomElement;
        static createAreaContainerElement(bathroom: AssembleBathroomElement, areaInfo: {
            name: string;
            polygon: Array<Vector2>;
            code: string;
        }, height: number): BathroomAreaElement;
        static getWallsInnerPolygonByAreaElement(areaElement: BathroomAreaElement): Line2[];
        static getWallsOuterPolygonByAreaElement(areaElement: BathroomAreaElement, floorEdgeThickness: number): Line2[];
        static updateBathroomAsync(context: ElementPerformerContext, bathroom: AssembleBathroomElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static isLineOnLine(line1: Line2, line2: Line2, join?: boolean): boolean;
        private static isPointOnLine;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BashroomWashtableBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export class BathroomWashtableBuilder extends BathroomContentBuilder {
        put(): void;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomClosestoolBuilder" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export class BathroomClosestoolBuilder extends BathroomContentBuilder {
        put(context: IContext): void;
        private computeClosestoolPosByPit;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomFloorDrainBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export class BathroomFloorDrainBuilder extends BathroomContentBuilder {
        put(): void;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomHeaterBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export class BathroomHeaterBuilder extends BathroomContentBuilder {
        put(): void;
        private getPosition;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomShowerBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export class BathroomShowerBuilder extends BathroomContentBuilder {
        put(): void;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomSpliterBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomSpliterElement } from 'sk/data/scheme/database/pattern/element/BathroomSpliterElement';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export class BathroomSpliterBuilder extends BathroomContentBuilder {
        spliters: BathroomSpliterElement[];
        put(): void;
        protected computeSpliterLines(): LineCurve2d[];
        protected computeSpliterLinesFromPaths(wetpaths: PathCurve2d[], areas: PathCurve2d[]): LineCurve2d[];
        protected computeWetareasInWallOutlines(wetpaths: PathCurve2d[], areas: PathCurve2d[]): PathCurve2d[];
        protected computeWetareaInWallOutlines(wetpath: PathCurve2d, area: PathCurve2d): PathCurve2d[];
        protected computePathsSubstract(p1: PathCurve2d, p2: PathCurve2d): LineCurve2d[];
        protected computeWetPlankOutlines(): PathCurve2d[];
        protected computeSpliters(lines: LineCurve2d[]): BathroomSpliterElement[];
        protected computeOneSpliter(line: LineCurve2d): BathroomSpliterElement;
        protected computeIntersectionLines(): LineCurve2d[];
        protected combineLines(lines: LineCurve2d[]): LineCurve2d[];
        protected combineTwoLinkLines(line1: LineCurve2d, line2: LineCurve2d): LineCurve2d;
        protected computeCurve2dsRealCoincideWithDirection(c1: PathCurve2d, c2: PathCurve2d): LineCurve2d[];
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
        protected buildSplitersAsync(context: ElementPerformerContext, contents: BathroomSpliterElement[]): Promise<ResultObject>;
        protected buildOneSpliterAsync(context: ElementPerformerContext, content: BathroomSpliterElement): Promise<ResultObject>;
        protected computeViewContentByParent(parent: BathroomSpliterElement, viewcontent: FamilyInstanceElement): FamilyInstanceElement;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomWallCupboardBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    export class BathroomWallCupboardBuilder extends BathroomContentBuilder {
        static DEFAULT_WALLCUPBOARD_HEIGHT: number;
        put(): void;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomContentArranger" {
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    import { BathroomContentContext } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentContext";
    export class BathroomContentArranger {
        context: ElementPerformerContext;
        roomContext: BathroomContext;
        document: SchemeDocument;
        contentContext: BathroomContentContext;
        bathroom: AssembleBathroomElement;
        proxyBathroom: BathroomElement;
        areas: Array<BathroomAreaElement>;
        private closestoolBuilder;
        private heaterBuilder;
        private showerBuilder;
        private floorWetBuilder;
        private spliterBuilder;
        private washtableBuilder;
        private wallCupboardBuilder;
        private floorDrainBuilder;
        arrangeAsync(context: ElementPerformerContext, roomContext: BathroomContext, proxyBathroom: BathroomElement, assembleBathroom: AssembleBathroomElement): Promise<void>;
        private createBuilder;
        private putContents;
        private buildContentsAsync;
    }
}
declare module "sk/rule/data/rule/contentlayout/AssembleRoomContentBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RoomPatternElement } from 'sk/data/family/database/pattern/element/RoomPatternElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { AssembleRoomContentArranger } from "sk/rule/data/rule/contentlayout/AssembleRoomContentArranger";
    export abstract class AssembleRoomContentBuilder {
        context: ElementPerformerContext;
        roomPattern: RoomPatternElement;
        element: PatternInstanceElement;
        document: SchemeDocument;
        assembleRoom: AssembleRoomElement;
        arranger: AssembleRoomContentArranger;
        abstract loadAsync(): Promise<void>;
        abstract put(): void;
        buildAsync(context: ElementPerformerContext): Promise<ResultObject>;
        buildContentAfterAsync(assembleRoomNode: AssembleRoomNode): Promise<void>;
        loadContentTempAsync(context: ElementPerformerContext, pattern: any, name: string, container?: any): Promise<any>;
        loadContentAsync(context: ElementPerformerContext, pattern: any, name: string, container?: any): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/contentlayout/AssembleRoomContentContext" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BedroomBedPatternElement } from 'sk/data/family/database/pattern/element/BedroomBedPatternElement';
    import { BedroomPatternElement } from 'sk/data/family/database/pattern/element/BedroomPatternElement';
    import { BedroomWardrobePatternElement } from 'sk/data/family/database/pattern/element/BedroomWardrobePatternElement';
    import { RoomPatternElement } from 'sk/data/family/database/pattern/element/RoomPatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { BedroomWardrobeElement } from 'sk/data/scheme/database/pattern/element/BedroomWardrobeElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class AssembleRoomContentContext {
        context: ElementPerformerContext;
        roomPattern: RoomPatternElement;
        assembleRoomContext: AssembleRoomContext;
        document: SchemeDocument;
        assembleRoom: AssembleRoomElement;
        wardrobeDecorateValue: DecorateValueStructure;
        wardrobeContent: any;
        wardrobeElem: BedroomWardrobeElement;
        protected _bedroomPattern: BedroomPatternElement;
        protected _bedPattern: BedroomBedPatternElement;
        protected _bedWardrobePattern: BedroomWardrobePatternElement;
        constructor();
        loadAssembleRoomAsync(context: ElementPerformerContext, assembleRoom: AssembleRoomElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/contentlayout/AssembleRoomContentArranger" {
    import { RoomPatternElement } from 'sk/data/family/database/pattern/element/RoomPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    import { AssembleRoomContentBuilder } from "sk/rule/data/rule/contentlayout/AssembleRoomContentBuilder";
    import { AssembleRoomContentContext } from "sk/rule/data/rule/contentlayout/AssembleRoomContentContext";
    export class AssembleRoomContentArranger {
        context: ElementPerformerContext;
        roomContext: AssembleRoomContext;
        document: SchemeDocument;
        contentContext: AssembleRoomContentContext;
        assembleRoom: AssembleRoomElement;
        builders: Array<AssembleRoomContentBuilder>;
        roomPattern: RoomPatternElement;
        constructor();
        arrangeAsync(context: ElementPerformerContext, roomContext: AssembleRoomContext, assembleRoom: AssembleRoomElement, roomPattern: RoomPatternElement): Promise<void>;
        arrangeAfterAsync(assembleRoomNode: AssembleRoomNode, roomPattern: RoomPatternElement): Promise<void>;
        findBuilderByClass(clazz: Function): AssembleRoomContentBuilder;
        protected buildContentsAfterAsync(assembleRoomNode: AssembleRoomNode): Promise<void>;
        protected createBuilders(): void;
        protected addBuilder<T extends AssembleRoomContentBuilder>(builderClass: new () => T): void;
        private loadBuildersAsync;
        private putContents;
        private buildContentsAsync;
    }
}
declare module "sk/rule/data/rule/contentlayout/bedroom/BedroomBedBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BedroomBedPatternElement } from 'sk/data/family/database/pattern/element/BedroomBedPatternElement';
    import { BedroomPatternElement } from 'sk/data/family/database/pattern/element/BedroomPatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { BedroomBedElement } from 'sk/data/scheme/database/pattern/element/BedroomBedElement';
    import { FloorCupboardElement } from 'sk/data/scheme/database/pattern/element/FloorCupboardElement';
    import { AssembleRoomContentBuilder } from "sk/rule/data/rule/contentlayout/AssembleRoomContentBuilder";
    export class BedroomBedBuilder extends AssembleRoomContentBuilder {
        roomPattern: BedroomPatternElement;
        bedElem: BedroomBedElement;
        bedCupboardElem: FloorCupboardElement;
        protected bedPattern: BedroomBedPatternElement;
        bedDecorateValue: DecorateValueStructure;
        bedContent: any;
        bedCupboardDecorateValue: DecorateValueStructure;
        bedCupboardContent: any;
        loadAsync(): Promise<void>;
        put(): void;
        buildAsync(): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/contentlayout/bedroom/BedroomWardrobeBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BedroomPatternElement } from 'sk/data/family/database/pattern/element/BedroomPatternElement';
    import { BedroomWardrobePatternElement } from 'sk/data/family/database/pattern/element/BedroomWardrobePatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BedroomWardrobeElement } from 'sk/data/scheme/database/pattern/element/BedroomWardrobeElement';
    import { AssembleRoomContentBuilder } from "sk/rule/data/rule/contentlayout/AssembleRoomContentBuilder";
    export class BedroomWardrobeBuilder extends AssembleRoomContentBuilder {
        roomPattern: BedroomPatternElement;
        wardrobeElem: BedroomWardrobeElement;
        protected wardrobePattern: BedroomWardrobePatternElement;
        wardrobeDecorateValue: DecorateValueStructure;
        wardrobeContent: any;
        loadAsync(): Promise<void>;
        put(): void;
        buildAsync(context: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/contentlayout/bedroom/BedroomContentArranger" {
    import { AssembleRoomContentArranger } from "sk/rule/data/rule/contentlayout/AssembleRoomContentArranger";
    export class BedroomContentArranger extends AssembleRoomContentArranger {
        protected createBuilders(): void;
    }
}
declare module "sk/rule/data/rule/assemble/kitchenroom/KitchenroomContentArrangerUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { KitchenRoomSurfaceArea } from "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenRoomArea";
    export enum KitchenroomContentEnum {
        FloorCabinet = 0,
        WallCabinet = 1
    }
    export class KitchenroomContentArrangerUtil {
        static getContent(type: KitchenroomContentEnum): void;
        static findDividers(area: KitchenRoomSurfaceArea, options?: {}): any[];
        static divideLine(line: Line2, contentLines: Line2[]): Line2[];
    }
}
declare module "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenRoomArea" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WallSurfaceElement } from 'sk/data/scheme/database/floorplan/element/WallSurfaceElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { KitchenroomFloorCabinetElement } from 'sk/data/scheme/database/pattern/element/KitchenroomFloorCabinetElement';
    import { KitchenroomSurfaceElement } from 'sk/data/scheme/database/pattern/element/KitchenroomSurfaceElement';
    import { KitchenroomWallCabinetElement } from 'sk/data/scheme/database/pattern/element/KitchenroomWallCabinetElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { KitchenRoomContentArranger } from "sk/rule/data/rule/contentlayout/kitchenroom/KitchenRoomContentArranger";
    import { KitchenroomCabinetBuilder } from "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenroomCabinetBuilder";
    export class KitchenRoomArea {
        arranger: KitchenRoomContentArranger;
    }
    export class KitchenRoomSurfaceArea extends KitchenRoomArea {
        protected _cabinetAreas: Array<KitchenRoomSurfaceArea>;
        protected _floorCabinets: Array<KitchenroomFloorCabinetElement>;
        protected _wallCabinets: Array<KitchenroomWallCabinetElement>;
        levelingWall: LevelingWallElement;
        wallSurface: WallSurfaceNode;
        room: RoomNode;
        kitchenroomSurface: KitchenroomSurfaceElement;
        builder: KitchenroomCabinetBuilder;
        from: Vector2;
        to: Vector2;
        execBuild(): void;
        protected execBuildFloorCabinet(): void;
        protected execBuildWallCabinet(): void;
        execArrangeAsync(): Promise<ResultObject>;
        protected execArrangeFloorCabinetAsync(): Promise<void>;
        protected execArrangeWallCabinetAsync(): Promise<void>;
        protected fetchOpenings(wallSurface: WallSurfaceElement): Array<OpeningNode>;
    }
}
declare module "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenroomCabinetBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { KitchenroomFloorCabinetPatternElement } from 'sk/data/family/database/pattern/element/KitchenroomFloorCabinetPatternElement';
    import { KitchenroomPatternElement } from 'sk/data/family/database/pattern/element/KitchenroomPatternElement';
    import { KitchenroomWallCabinetPatternElement } from 'sk/data/family/database/pattern/element/KitchenroomWallCabinetPatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { KitchenroomFloorCabinetElement } from 'sk/data/scheme/database/pattern/element/KitchenroomFloorCabinetElement';
    import { KitchenroomSurfaceElement } from 'sk/data/scheme/database/pattern/element/KitchenroomSurfaceElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { AssembleRoomContentBuilder } from "sk/rule/data/rule/contentlayout/AssembleRoomContentBuilder";
    import { KitchenRoomSurfaceArea } from "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenRoomArea";
    class KitchenroomFloorCabinetContainer {
        cabinetDecorateDecorateValue: DecorateValueStructure;
        cabinetDecorateContent: any;
        hearthDecorateDecorateValue: DecorateValueStructure;
        hearthDecorateContent: any;
        basinDecorateDecorateValue: DecorateValueStructure;
        basinDecorateContent: any;
    }
    class KitchenroomWallCabinetContainer {
        cabientDecorateDecorateValue: DecorateValueStructure;
        cabientDecorateContent: any;
        rangeHoodDecorateDecorateValue: DecorateValueStructure;
        rangeHoodDecorateContent: any;
    }
    export class KitchenroomCabinetBuilder extends AssembleRoomContentBuilder {
        floorCabinetContainer: KitchenroomFloorCabinetContainer;
        wallCabinetContainer: KitchenroomWallCabinetContainer;
        roomPattern: KitchenroomPatternElement;
        elements: Array<KitchenroomFloorCabinetElement>;
        floorCabinetPattern: KitchenroomFloorCabinetPatternElement;
        wallCabinetPattern: KitchenroomWallCabinetPatternElement;
        kitchenroomSurfaces: [];
        private floorCabinetElements;
        private wallCabinetElements;
        protected _cabinetAreas: KitchenRoomSurfaceArea[];
        protected _calculatorService: CalculatorService;
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        loadAsync(): Promise<void>;
        put(): void;
        prev(area: KitchenRoomSurfaceArea): KitchenRoomSurfaceArea;
        next(area: KitchenRoomSurfaceArea): KitchenRoomSurfaceArea;
        private putKitchenroomSurface;
        private putBasin;
        private computeBasinPosition;
        private putHearth;
        private putRangeHood;
        buildAsync(): Promise<ResultObject>;
        protected createCupboardTopAsync(parentElement: KitchenroomSurfaceElement): Promise<ResultObject>;
        buildContentAfterAsync(assembleRoomNode: AssembleRoomNode): Promise<void>;
    }
}
declare module "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenroomSurfaceBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { KitchenroomFloorCabinetPatternElement } from 'sk/data/family/database/pattern/element/KitchenroomFloorCabinetPatternElement';
    import { KitchenroomPatternElement } from 'sk/data/family/database/pattern/element/KitchenroomPatternElement';
    import { KitchenroomWallCabinetPatternElement } from 'sk/data/family/database/pattern/element/KitchenroomWallCabinetPatternElement';
    import { KitchenroomFloorCabinetElement } from 'sk/data/scheme/database/pattern/element/KitchenroomFloorCabinetElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { AssembleRoomContentBuilder } from "sk/rule/data/rule/contentlayout/AssembleRoomContentBuilder";
    import { KitchenRoomSurfaceArea } from "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenRoomArea";
    export class KitchenroomSurfaceBuilder extends AssembleRoomContentBuilder {
        roomPattern: KitchenroomPatternElement;
        elements: Array<KitchenroomFloorCabinetElement>;
        floorCabinetPattern: KitchenroomFloorCabinetPatternElement;
        wallCabinetPattern: KitchenroomWallCabinetPatternElement;
        kitchenroomSurfaces: [];
        private floorCabinetElements;
        private wallCabinetElements;
        protected _cabinetAreas: KitchenRoomSurfaceArea[];
        protected _calculatorService: CalculatorService;
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        loadAsync(): Promise<void>;
        put(): void;
        get areas(): KitchenRoomSurfaceArea[];
        prev(area: KitchenRoomSurfaceArea): KitchenRoomSurfaceArea;
        next(area: KitchenRoomSurfaceArea): KitchenRoomSurfaceArea;
        private putKitchenroomSurface;
        buildAsync(): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/contentlayout/kitchenroom/KitchenRoomContentArranger" {
    import { AssembleRoomContentArranger } from "sk/rule/data/rule/contentlayout/AssembleRoomContentArranger";
    export class KitchenRoomContentArranger extends AssembleRoomContentArranger {
        protected createBuilders(): void;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleContentElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    import { BathroomContext } from "sk/rule/data/rule/assemble/BathroomContext";
    export class AssembleContentElementUtil {
        static arrangeBathroomContentsAsync(context: ElementPerformerContext, roomContext: BathroomContext, proxyBathroom: BathroomElement, assembleBathroom: AssembleBathroomElement): Promise<ResultObject>;
        static arrangeAssembleRoomContentsAsync(context: ElementPerformerContext, roomContext: AssembleRoomContext, assembleRoom: AssembleRoomElement): Promise<ResultObject>;
        static arrangeContentAfterComputeAsync(context: ElementPerformerContext, assembleRoom: AssembleRoomNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleRoomElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { SpatialSurfaceNode } from 'sk/data/family/model/instance/SpatialSurfaceNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    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 { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { CompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/CompositeCeilingElement';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    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 { ProxyCeilingElement } from 'sk/data/scheme/database/pattern/element/ProxyCeilingElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    import { LevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/LevelingCeilingNode';
    import { LevelingWallNode } from 'sk/data/scheme/database/pattern/node/LevelingWallNode';
    export class AssembleRoomElementUtil {
        static createAssembleRoomAsync(elementPerformerContext: ElementPerformerContext, assembleRoom: AssembleRoomElement, room: RoomNode): Promise<ResultObject>;
        static buildAssembleRoomContentAfterAsync(elementPerformerContext: ElementPerformerContext, assembleRoomNode: AssembleRoomNode): Promise<ResultObject>;
        static createLevelingWallsByRoomAsync(levelingWall: LevelingWallElement, room: RoomNode): Promise<ResultObject>;
        static updateAssembleElementLinkedPatternAsync(levelingElement: PatternInstanceElement, newPatternInfoId: string): Promise<ResultObject>;
        static createLevelingWallsByWallSurfaceAsync(levelingWall: LevelingWallElement, wallSurfaceNode: WallSurfaceNode): Promise<ResultObject>;
        static createPelmetsByLevelingWallAsync(pelmetElement: PelmetElement, levelingWallNode: LevelingWallNode): Promise<ResultObject>;
        static createPelmetByAreaPolygonAsync(pelmetElement: PelmetElement, areaPolygon: AreaPolygonNode): Promise<ResultObject>;
        static createLevelingFloorByRoomAsync(levelingFloor: LevelingFloorElement, room: RoomNode): Promise<ResultObject>;
        static createLevelingFloorsByRoomAsync(levelingFloor: LevelingFloorElement, room: RoomNode): Promise<ResultObject>;
        static createLevelingCeilingsByRoomAsync(levelingCeiling: LevelingCeilingElement, room: RoomNode): Promise<ResultObject>;
        static createCompositeCeilingsByRoomAsync(compositeCeiling: CompositeCeilingElement, room: RoomNode): Promise<ResultObject>;
        static clearSurfaceLeveilingCeiling(surface: CeilingSurfaceNode): void;
        static clearAreaPolygonLeveilingCeiling(areaPolygon: AreaPolygonNode): void;
        static createLevelingCeilingByAreaPolygonAsync(levelingCeiling: LevelingCeilingElement, areaPolygon: AreaPolygonNode): Promise<ResultObject>;
        static createLevelingCeilingByCeilingSurfaceAsync(levelingCeiling: LevelingCeilingElement, surface: CeilingSurfaceNode): Promise<ResultObject>;
        static createCeilingsByRoomAsync(proxyCeiling: ProxyCeilingElement, room: RoomNode): Promise<ResultObject>;
        static deleteAssembleRoom(assembleRoom: AssembleRoomElement, notIncludeSelf?: boolean): void;
        private static clearRoomLevelingWalls;
        private static clearWallSurfaceLevelingWalls;
        private static clearLevelingWallPelmets;
        private static clearAreaPolygonPelmets;
        private static clearRoomLevelingFloor;
        private static clearRoomLevelingCeiling;
        private static clearRoomCeiling;
        private static clearRoomAssembleBeam;
        static getAssembleRoomOfRoom(room: RoomNode): AssembleRoomElement;
        static syncAssembleRoom(room: RoomNode, assembleRoom?: AssembleRoomElement): AssembleRoomElement;
        static updateAssembleRoomByRoomAsync(room: RoomNode): Promise<ResultObject>;
        static updateAssembleRoomAsync(assembleRoom: AssembleRoomElement, force?: boolean): Promise<ResultObject>;
        static dirtyRoomFloorAndCeiling(room: RoomNode): void;
        static dirtyRoomFloor(room: RoomNode): void;
        static getSimilarPolygon(results: {
            polygon: Vector2[];
            surface: CeilingSurfaceElement;
        }[], levelingCeiling: LevelingCeilingNode): Array<Vector2>;
        static dirtyRoomCeiling(room: RoomNode): void;
        static getRoomOfLevelingCeiling(levelingCeiling: LevelingCeilingElement): RoomNode;
        static getRoomOfLevelingWall(levelingwall: LevelingWallElement): RoomNode;
        static getAssembleRoomOfLevelingWall(levelingwall: LevelingWallElement): AssembleRoomElement;
        static getRoomOfCompositeWall(compositewall: CompositeWallElement): RoomNode;
        static getAssembleRoomOfCompositeWall(compositewall: CompositeWallElement): AssembleRoomElement;
        static getAssembleBeamsOfAssembleRoom(assembleRoom: AssembleRoomElement): AssembleBeamElement[];
        static getRoomOfPelmet(pelmet: PelmetElement): RoomNode;
        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 getRoomOfAssebmleRoom(assembleRoom: AssembleRoomElement): RoomNode;
        static getRoomOfAssembleBathroom(bathroom: BathroomElement): RoomNode;
        static getBathroomByRoom(room: RoomElement): BathroomElement;
        static createLevelingWallBySpatialSurfaceAsync(levelingWall: LevelingWallElement, spatialSurface: SpatialSurfaceNode): Promise<ResultObject>;
        static createLevelingFloorAsync(levelingFloor: LevelingFloorElement, outline?: Array<Vector2>, holes?: Array<Array<Vector2>>): Promise<ResultObject>;
        static createLevelingCelingAsync(levelingCeiling: LevelingCeilingElement, outline?: Array<Vector2>): Promise<ResultObject>;
        static createLevelingFloorByRoomDefaultAsync(element: LevelingFloorElement, roomNode: RoomNode): Promise<ResultObject>;
        private static setDecorateInfoInContext;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomLayoutElementUtil" {
    import { BathroomLayoutAreaElement } from 'sk/data/family/element/instance/BathroomLayoutAreaElement';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    export class BathroomLayoutElementUtil {
        static getBathroomLayout(room: RoomNode): BathroomLayoutAreaElement;
        static getBathroomLayoutByRoomElement(room: RoomElement): BathroomLayoutAreaElement;
        static removeBathroomLayout(layout: BathroomLayoutAreaElement): void;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleRoomRelationUtil" {
    import { BathroomLayoutAreaElement } from 'sk/data/family/element/instance/BathroomLayoutAreaElement';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { AssembleCeilingEdgeElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement';
    import { AssembleCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingElement';
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    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 { BathroomCeilingElement } from 'sk/data/scheme/database/pattern/element/BathroomCeilingElement';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { BathroomFloorWetElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetElement';
    import { BathroomWallElement } from 'sk/data/scheme/database/pattern/element/BathroomWallElement';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    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';
    export class AssembleRoomRelationUtil {
        static addLevelingWallRelation(levelingWall: LevelingWallElement, wallSurfaceNode: WallSurfaceNode, isPrev: boolean): void;
        static addCompositeWallRelation(levelingWall: CompositeWallElement, wallSurfaceNode: WallSurfaceNode, isPrev: boolean): void;
        static getWallSurfaceNeighbourCompositeWall(wallSurfaceNode: WallSurfaceNode, isPrev: boolean): CompositeWallElement;
        static getWallSurfaceNeighbourLevelingWall(wallSurfaceNode: WallSurfaceNode, isPrev: boolean): LevelingWallElement;
        static isLevelingWallAllFlatWalls(levelingWall: LevelingWallElement): boolean;
        static getWallSurfaceFlatWallSurfaces(wallSurfaceNode: WallSurfaceNode): Array<WallSurfaceNode>;
        static deleteLevelingWall(levelingWall: LevelingWallElement): void;
        static deleteLevelingWallBySpatialSurface(levelingWall: LevelingWallElement): void;
        static deleteBeamLevelingWall(levelingWall: LevelingWallElement): void;
        static deletePelmet(pelmet: PelmetElement): void;
        static deleteWindow(window: AssembleWindowElement): void;
        static deleteDoor(door: AssembleDoorElement): void;
        static deleteLevelingFloor(levelingFloor: LevelingFloorElement): void;
        static deleteBathRoom(bathRoom: AssembleBathroomElement): void;
        static deleteBathroomLayout(layout: BathroomLayoutAreaElement): void;
        static deleteBathRoomWall(bathRoomWall: BathroomWallElement): void;
        static deleteBathRoomFloorWet(bathRoomFloorWet: BathroomFloorWetElement): void;
        static deleteBathRoomFloor(bathRoomFloor: BathroomFloorDryElement): void;
        static deleteBathRoomCeiling(bathRoomCeiling: BathroomCeilingElement): void;
        static deleteLevelingCeiling(levelingCeiling: LevelingCeilingElement): void;
        static deleteAssembleBeam(assembleBeam: AssembleBeamElement): void;
        static deleteAssembleCeilingEdge(assembleCeilingEdge: AssembleCeilingEdgeElement): void;
        static deleteAssembleCeilingPlane(assembleCeilingPlane: AssembleCeilingPlaneElement): void;
        static deleteAssembleCeiling(assembleCeiling: AssembleCeilingElement): void;
        static updateAssembleRoomRelation(assembleRoom: AssembleRoomElement): void;
        static updateSerialLevelWallsRelation(levelingWalls: Array<LevelingWallElement>): void;
        static updateLevelWallRelation(levelingWall: LevelingWallElement): void;
        static updateAssembleBeamByLevelingWall(levelingWall: LevelingWallElement, thickness?: number): void;
        private static updateAssembleOpeningsRelation;
        static updateAssembleDoorRelation(element: LevelingWallElement): void;
        static updateLevelinWallElement(windowLevelingWall: LevelingWallElement): void;
        static setFirstLevelingWall(levelingWall: LevelingWallElement): void;
        static makeLevelingWallBeginActive(levelingWall: LevelingWallElement): void;
        static makeLevelingWallEndActive(levelingWall: LevelingWallElement): void;
        private static adjustWallWallPress;
        static isOuterCorner(formerWall: LevelingWallElement | CompositeWallElement, latterWall: LevelingWallElement | CompositeWallElement): boolean;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutDataUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { WallElement } from 'sk/data/scheme/database/floorplan/element/WallElement';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { LayoutSurfaceData } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData";
    import { HoleData, LevelingLayoutData, PlankData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export interface LevelerSegment {
        line: Array<number>;
    }
    export interface LevelerSegments {
        segs: Array<LevelerSegment>;
        validLevelingLineIdxs: Array<number>;
    }
    export interface AreaCalculatOption {
        layer: string;
    }
    export class LevelingLayoutDataUtil {
        static getLayoutDataFromLevelingWall(levelingWall: LevelingWallElement): LevelingLayoutData;
        static getLayoutDataFromCompositeWall(compositeWall: CompositeWallElement): LevelingLayoutData;
        static quadratePipeCompositeWallTypeData(layoutData: LevelingLayoutData, element: CompositeWallElement): void;
        static quadratePipeTypeData(layoutData: LevelingLayoutData, element: LevelingWallElement): void;
        private static setFlatWallInfoToLayoutData;
        static getContentSegmentOnLine(content: ContentInstanceElement, from: Vector2, to: Vector2): any;
        static getSubContentSegmentOnLine(content: ContentInstanceElement, from: Vector2, to: Vector2): any;
        private static setFlatWallInfoToLayoutData2;
        static getLineOpengingsHoleDatas(wallSurface: WallSurfaceNode, line: Line2): any;
        static getFlatLineOpengingsHoleDatas(wallelement: WallElement, line: Line2): any;
        static getOpeningHoleData(opening: OpeningNode, x: number): any;
        static getOpeningHoleDataByElement(opening: OpeningElement, x: number): any;
        static getDoorOpeningSubHoleData(opening: OpeningNode, line: Line2): any;
        static getLineBeamHoleDatas(layoutData: LevelingLayoutData, wallSurface: WallSurfaceNode, line: Line2): any;
        static getBeamHoleData2(left: number, right: number, beam: BeamNode, x: number, subLine: Line2): any;
        static getLineCeilingHoleDatas(layoutData: LevelingLayoutData, wallSurface: WallSurfaceNode, line: Line2): any;
        static getBeamHoleData(layoutData: LevelingLayoutData, beam: BeamNode, x: number, subLine: Line2): any;
        static getCeilingHoleData(layoutData: LevelingLayoutData, ceilingSurface: CeilingSurfaceNode, x: number, subLine: Line2, ceilingZ: number): any;
        static getCeilingHoleData2(left: number, right: number, ceilingSurface: CeilingSurfaceNode, x: number, subLine: Line2, ceilingZ: number): any;
        static getBeamHoles(levelingWall: LevelingWallElement, side: LayoutSurfaceData): any;
        static deepCopyBeamHoles(hole: any): any;
        static clonePlank(plank: PlankData): PlankData;
        static cloneHole(hole: HoleData): HoleData;
        static getLevelingWallArea(element: LevelingWallElement, layer?: any): number;
        private static getHardWareChildCount;
        static getLayoutDataArea(layoutData: LevelingLayoutData, option: AreaCalculatOption, levellerCount: number): number;
        private static wallHeightIsSame;
        static getSegPolygon(layoutData: LevelingLayoutData, option: AreaCalculatOption, seg: LevelerSegment): Array<Vector2>;
        private static getWallPolygons;
        private static getflatWallPolygons;
        static getSegPolygons(layoutData: LevelingLayoutData, option: AreaCalculatOption, segs: Array<LevelerSegment>): Array<Array<Vector2>>;
        static getHolesPolygon(layoutData: LevelingLayoutData, option: AreaCalculatOption): Array<Array<Vector2>>;
        static getPolygonByHoleData(hole: HoleData, isConsiderOffset: boolean): Array<Vector2>;
        static getWallLineSegments(layoutData: LevelingLayoutData, isDivide?: boolean): LevelerSegments;
        static isHoleInXRange(hole: HoleData, min: number, max: number): boolean;
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/LevellerTypeEnum" {
    export enum LevellerTypeEnum {
        Normal = 0,
        Fix = 1,
        Strength = 2,
        HOLE_SIDE = 3
    }
}
declare module "sk/rule/data/rule/levelinglayout/ArrangeOptimizationTool" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export type Point = {
        position: Vector2;
        node: any;
        relations: TypeMap<string, Relation>;
    };
    export type Relation = {
        name: string;
        location: string;
    };
    export type Region = {
        lines: TypeMap<string, Line2>;
        node: any;
        type: string;
    };
    export class ArrangeOptimizationTool {
        pointSets: Array<Array<Point>>;
        points: Array<Point>;
        holes: Array<Region>;
        region: Region;
        layout: Region;
        tolerance: number;
        constructor(region: Region, points: Array<Point>, holes: Array<Region>, tolerance: number);
        prepare(): void;
        private computePointsRelation;
        private saveRelation;
        edgeTest(region: Region, point: Point, tolerance: number): Array<string>;
        private dataArrange;
    }
}
declare module "sk/rule/data/rule/levelinglayout/ContentArea" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class ContentArea {
        origin: Vector2;
        length: number;
        height: number;
        constructor();
    }
}
declare module "sk/rule/data/rule/levelinglayout/OptimizeUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ArrangeOptimizationTool, Point } from "sk/rule/data/rule/levelinglayout/ArrangeOptimizationTool";
    import { ContentArea } from "sk/rule/data/rule/levelinglayout/ContentArea";
    import { HoleData, LevelingLayoutData, LevellerData, PlankData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    type Option = {
        isLeftValid: boolean;
        isRightValid: boolean;
        isValid: boolean;
        isTopValid: boolean;
        isRect: boolean;
        isLeftExternalCorner: boolean;
        isRightExternalCorner: boolean;
    };
    export class OptimizeUtil {
        static computePlankType(layoutData: LevelingLayoutData, plank: PlankData, isLeft: boolean, isRight: boolean): Option;
        static numFilter(array: Array<Array<Point>>): Array<Array<Point>>;
        static computeFixedLevers(layoutData: LevelingLayoutData, levelers: Array<LevellerData>, plank: PlankData, isLeft: boolean, isRight: boolean): Array<LevellerData>;
        static findRowFixedLeveler(option: Option, points: Array<Point>): Array<LevellerData>;
        private static isHoleEdge;
        static getInteratorRowList(option: Option, length: number): Array<number>;
        static getInteratorColumnList(option: Option, start: number, end: number): Array<number>;
        static plankLevelersArrange(levelers: Array<LevellerData>, plank: PlankData, holeList: Array<HoleData>): ArrangeOptimizationTool;
        static removeMoreLevelers(levelers: Array<LevellerData>, plank: PlankData, layoutData: LevelingLayoutData): void;
        static isPointInRegion(region: ContentArea, point: Vector2): boolean;
        static filterLevelersInPlank(levelers: Array<LevellerData>, plank: PlankData): Array<LevellerData>;
        static optimizeLevlers(pointSets: Array<Array<Point>>, list: Array<Point>): void;
        static deleteLeveler(points: Array<Point>, list: Array<Point>): any;
        private static isHoleCorner;
        private static divideByHoleLine;
        private static constructorLines;
        private static constructorHoleLines;
        private static buildHoleLines;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutLevellerCalculator" {
    import { LevelingLayoutData, PlankData, LevellerData, LevelingLayoutParamers, HoleData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingLayoutLevellerCalculator {
        private layoutData;
        private params;
        private allLevellers;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers);
        calculate(): void;
        getAllLevellers(): LevellerData[];
        calculateByPlanks(planks: Array<PlankData>): void;
        private addLevellers;
        private improveLevellers;
        private tryAddPlankCornerLeveller;
        private sortNumber;
        private sortX;
        private addPlankFixLevellers;
        private loopY;
        private loopX;
        private checkInPlankHoles;
        private addLevellerToPlank;
        private createRectLevellers;
        getLevelerHole(hole: HoleData): any;
        private createLevellersByHole;
        private createLevellersByNarrowPlank;
        private createLevellersByCutType;
        createLevelers(plank: PlankData): boolean;
        getKeyPoints(plank: PlankData): Array<any>;
        getPlankKeyPoints(plank: PlankData): Array<any>;
        getPlankHoleKeyPoints(plank: PlankData): Array<any>;
        private checkInPlank;
        collisionCheck(plank: PlankData, x: number, y: number): boolean;
        getPositionListByPoints(keyPoints: Array<any>): any;
        moveKeyPoint(keyPoints: Array<any>, index: number, key: string): void;
        insertKeyPoint(keyPoints: Array<any>, index: number, key: string, gap: number): number;
        sortList(keyPoints: Array<any>, key: string): Array<any>;
        addLevelerByLocation(plank: PlankData, xList: Array<any>, yList: Array<any>): void;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LineLayoutUtil" {
    export class LineLayoutUtil {
        static layoutOnLineByStep(length: number, startOffset: number, endOffset: number, step: number, endType?: number, min?: number): Array<number>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutScrewCalculator" {
    import { LevelingLayoutData, LevelingLayoutParamers, PlankData, LevellerData, ScrewData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingLayoutScrewCalculator {
        private layoutData;
        private params;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers);
        calculate(): void;
        private addScrews;
        static createScrews(leveller: LevellerData, planks: PlankData[], levellerScrewDistance: number, vSeam?: number, hSeam?: number): Array<ScrewData>;
        private createQuadratePipeScrew;
        private static createScrewDataByPositionTypes;
        private static isPositionOnPlank;
        private static isPositionOnHole;
    }
}
declare module "sk/rule/data/rule/levelinglayout/collision/EludeCollision" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PlankData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export type BoxBoundary = {
        left: number;
        right: number;
        buttom: number;
        top: number;
    };
    export class EludeCollision {
        static getPath(position: Vector2, plankData: PlankData, offsetTop: number, offsetRight: number, offsetBottom: number, offsetLeft: number): Array<Vector2>;
        private static optimizeDirection;
        private static fuseStep;
        private static positionOnBasePlankEdge;
        private static positionOnHoleEdge;
        private static changePath;
        private static changePathHole;
        private static isInHole;
    }
}
declare module "sk/rule/data/rule/levelinglayout/collision/SearchTreeNode" {
    export class PointValue {
        dimension: number;
        values: Array<number>;
        point: any;
        constructor(point: any);
        getSubPointValue(): PointValue;
        get value(): any;
    }
    export class RangeValue {
        dimension: number;
        values: Array<number>;
        constructor(boundary: Array<number>);
        getSubRangeValue(): RangeValue;
        get min(): number;
        get max(): number;
    }
    export class SearchTreeNode {
        left: SearchTreeNode;
        right: SearchTreeNode;
        minValue: PointValue;
        maxValue: PointValue;
        key: number;
        isLeaf: boolean;
        values: Array<PointValue>;
        subPointer: SearchTreeNode;
        constructor();
    }
}
declare module "sk/rule/data/rule/levelinglayout/collision/SearchTreeUtil" {
    import { SearchTreeNode, PointValue, RangeValue } from "sk/rule/data/rule/levelinglayout/collision/SearchTreeNode";
    export class SearchTreeUtil {
        static searchTreeBuild(list: Array<PointValue>): SearchTreeNode;
        static searchTreeQuery(tree: SearchTreeNode, range: RangeValue): any;
        static isInRange(min: number, max: number, range: RangeValue): boolean;
        static isCrossRange(min: number, max: number, range: RangeValue): boolean;
        static getKeyValue(splitList: Array<Array<PointValue>>): PointValue;
        static split(list: Array<PointValue>): Array<Array<PointValue>>;
        static getLeafValues(tree: SearchTreeNode): Array<PointValue>;
        static getLeafNodes(tree: SearchTreeNode): Array<SearchTreeNode>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/collision/RangeTreeUtil" {
    import { PointValue, SearchTreeNode, RangeValue } from "sk/rule/data/rule/levelinglayout/collision/SearchTreeNode";
    export class RangeTreeUtil {
        static rangeTreeBuild(list: Array<PointValue>, d: number): any;
        static rangeTreeQuery(tree: SearchTreeNode, range: RangeValue, d: number): Array<SearchTreeNode>;
        static getValues(leafNodes: Array<SearchTreeNode>): Array<any>;
        static sort(list: Array<PointValue>): any;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutSurfaceScrewCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LevelingLayoutData, LevelingLayoutParamers, PlankData, HoleData, ScrewData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingLayoutSurfaceScrewCalculator {
        private layoutData;
        private params;
        private defaultOffsets;
        private minGapWithBaseScrew;
        private minGapWithSurfaceScrew;
        private supplementLength;
        private static moveList;
        private baseScrewTree;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers);
        calculate(): void;
        createBaseScrewTree(baseScrews: Array<ScrewData>): void;
        private addscrews;
        getPlankOffset(plank: PlankData): {
            offsetTop: number;
            offsetRight: number;
            offsetBottom: number;
            offsetLeft: number;
        };
        createscrews(plank: PlankData, screwGapX: number, screwGapY: number, offsetTop: number, offsetRight: number, offsetBottom: number, offsetLeft: number): Array<ScrewData>;
        private createSupplementPoints;
        uniqueSortArray(array: Array<number>, gap: number): Array<number>;
        getPositionListByPoints(points: KeyPoint[], screwGapX: number, screwGapY: number): {
            xList: number[];
            yList: number[];
        };
        getAddNumbers(n1: number, n2: number, gap: number): number[];
        sortNumber(n1: number, n2: number): any;
        getKeyPointsByPlank(plank: PlankData, offsetTop: number, offsetRight: number, offsetBottom: number, offsetLeft: number): KeyPoint[];
        getSubRectByHole(plank: PlankData, holeData: HoleData): any;
        private validateAndPush;
        private isPositionOnPlank;
        private moveToValidPosition;
        private moveToValidPosition2;
        private isPositionOnHoles;
        private isInRange;
        private isInAndOnRange;
        private isPositionOnBasePlankEdge;
        private isPositionOnScrews;
        private deleteConflictScrews;
        private isCollisionBaseScrew;
    }
    type KeyPoint = {
        point: Vector2;
        edgeType: "plank" | "hole";
        holeIndex?: number;
    };
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutDataCalculator" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { LevelingLayoutData, HoleData, AreaData, ColumnData, PlankData, LevelingLayoutParamers, LayoutOption, ScrewData, QuadratePipeData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingLayoutDataCalculator {
        layoutData: LevelingLayoutData;
        protected params: LevelingLayoutParamers;
        protected layoutOption: LayoutOption;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers, layoutOption: LayoutOption);
        caclulate(): RuleProcesResult;
        protected cutHole(): void;
        protected computeQuadratePipe(): void;
        createQuadratePipeScrew(planks: Array<PlankData>, quadratePipeLength: number, hasQuadratePipe: boolean, type: "left" | "right"): Array<ScrewData>;
        protected createQuadratePipeDataByColum(colum: ColumnData, type: "left" | "right"): void;
        createQuadratePipeDataByPlanks(planks: Array<PlankData>, quadratePipeLength: number, type: "left" | "right"): Array<QuadratePipeData>;
        protected quadratePipeFilter(colum: ColumnData, plank: PlankData, type: "left" | "right"): boolean;
        protected quadratePipeHeight(hole: HoleData, plank: PlankData, quadratePipeLength: number, type: "left" | "right", height: number): number;
        protected computeWindowStone(): void;
        protected calculateReflines(): void;
        protected computeDecorate(layoutData: LevelingLayoutData): RuleProcesResult;
        protected computeSurfacePlank(): RuleProcesResult;
        protected computePlank(): RuleProcesResult;
        protected getBaseRefLines(areaData: AreaData, vertical?: boolean, columnData?: ColumnData): RefLine[];
        protected getRefLines(holes: Array<HoleData>, vertical?: boolean): Array<RefLine>;
        protected cutColumns(layoutData: LevelingLayoutData, isSurface: boolean, columns: ColumnData[], offset?: number, optimize?: boolean, baseRefLines?: RefLine[]): boolean;
        protected setColumns(columns: ColumnData[], isSurface: boolean, numbersList: number[][], levelingLineIdxs: number[], startOffsetX: number, endOffsetX: number): void;
        protected getWallLineSegments(isSurface: boolean): {
            segs: Array<{
                line: Array<number>;
                reverse?: boolean;
                offset?: number;
            }>;
            levelingLineIdxs: Array<number>;
        };
        protected getCutColumnNumbers(isSurface: boolean, offset: number, startOffset: number, endOffset: number, reflines: RefLine[]): any;
        protected static setPlankHoleRect(plank: PlankData, hole: HoleData): void;
        static getPlankLocalHoles(plank: PlankData, inputHoles: Array<HoleData>): void;
        protected createPlanksByNumbers(column: ColumnData, numbers: Array<number>, startOffsetY: number): void;
        protected getPlankPolygons(plank: PlankData): void;
        protected cutRows(column: ColumnData, lastColumn: ColumnData, offset?: number, optimize?: boolean, baseRefLines?: RefLine[]): boolean;
        protected getOnlyWindowOrDoorHole(holes: Array<HoleData>): any;
        protected preOptimizeColumn(column: ColumnData, startOffsetY: number, endOffsetY: number): boolean;
        protected optimizePlanks(planks: Array<PlankData>, optimize: boolean): void;
        private mergePlankholes;
        protected splitUpDownPlank(data: PlankData, hole: HoleData): number;
        protected splitLeftRightPlank(data: PlankData, hole: HoleData): number;
        protected discardNarrowPlank(planks: PlankData[], allPlank: PlankData[]): void;
        protected optimizeDoorPlank(plank: PlankData, hole: HoleData): number;
        protected dividePlank(plank: any, num: number): number;
        protected optimizeWindowPlank(data: PlankData, hole: HoleData): number;
        protected sortPlanksIdx(planks: Array<PlankData>, idx: number): void;
        protected tryMergePlanks(downPlank: PlankData, upPlank: PlankData, mergeHole?: boolean): boolean;
        protected cutPlank(plankData: PlankData): void;
        convertHolePointsToHoleCutLines(outline: Vector2[], holePoints: Vector2[]): Line2[];
        static setLocalHolePosition(plankData: PlankData): void;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingPlankScrewCalculator" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { HoleData, LevelingLayoutParamers, LevellerData, PlankData, QuadratePipeData, ScrewData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { ReferenceLineData } from "sk/rule/data/rule/levelinglayout/ReferenceLineCalculator";
    export class LevelingPlankScrewCalculator {
        private params;
        planks: PlankData[];
        levellers: LevellerData[];
        baseScrewData: ScrewData[];
        layer: string;
        private supplementLength;
        resScrews: Array<ScrewData>;
        plankElement: PlankElement;
        base: ContentElement;
        surface: ContentElement;
        hardware: ContentElement;
        survey: ContentElement;
        quadratePipes: Array<QuadratePipeData>;
        protected holes: Array<HoleData>;
        surveyLines: Array<ReferenceLineData>;
        private verticalSeam;
        private horizontalSeam;
        constructor(params: LevelingLayoutParamers);
        calculateByLevelingWall(levelingWall: LevelingWallElement): void;
        calculateByPlankElement(plank: PlankElement): void;
        private calculate;
        private convertAllPlanks;
        private convertPlankDate;
        private getRealHolesByLevelingWall;
        private getHoleDatas;
        private createHoleData;
        private getLevellers;
        private getBaseScrews;
        private addBaseScrews;
        private addSurfacescrews;
        getPlankOffset(plank: PlankData): {
            offsetTop: number;
            offsetRight: number;
            offsetBottom: number;
            offsetLeft: number;
        };
        private createQuadratePipeAndScrew;
        private createQuadrateScrew;
        private getLeftPlanks;
        private getRightlanks;
        private createHoleSideScrew;
        private getColumns;
        private isPositionOnPlank;
        private isPositionOnHole;
        calculateReflinesByLevelingWall(levelingWall: LevelingWallElement, params: LevelingLayoutParamers): Array<ReferenceLineData>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingPlankScrewBuild" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { QuadratePipeData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { ReferenceLineData } from "sk/rule/data/rule/levelinglayout/ReferenceLineCalculator";
    export class LevelingPlankScrewBuild {
        private params;
        private context;
        constructor();
        buildLevelingWallAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        private createElementsAsync;
        private createScrewElementAsync;
        protected createQuadratePipeAsync(container: ContentElement, quadratePipes: Array<QuadratePipeData>): Promise<ResultObject>;
        protected createQuadratePipeElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo, quadratePipe: QuadratePipeData, depth: number): Promise<ResultObject>;
        protected createSurveyLines(container: ContentElement, lines: Array<ReferenceLineData>, depth: number): void;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingWallBuilder" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { DrawingCodeEnum } from 'sk/data/family/enumeration/drawing/DrawingCodeEnum';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { LevelingLayoutData, LevellerData, PlankData, ScrewData, LevelingLayoutParamers, DecorateData, LevelingLayoutTypeEnum, WindowStoneData, LayoutOption, QuadratePipeData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingWallBuilder {
        protected layoutData: LevelingLayoutData;
        protected params: LevelingLayoutParamers;
        protected context: ElementPerformerContext;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers);
        isValidLayoutData(layoutData: LevelingLayoutData): boolean;
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        getLayoutOption(layoutData: LevelingLayoutData): LayoutOption;
        protected createConatiner(parent: ContentElement, name: string, identifier: number, drawingCodes: string, isWallType?: boolean, layerType?: string): ContainerElement;
        protected choiceLeveller(empty: number, symbols: Types<any>): any;
        protected modifyElementNameAndCode(element: ContentElement, type: LevelingLayoutTypeEnum): DrawingCodeEnum;
        protected createContainerAsync(element: ContentElement, layoutOption: LayoutOption): Promise<ResultObject>;
        protected createElementsErroModeAsync(element: ContentElement, layoutOption: LayoutOption): Promise<ResultObject>;
        protected createElementsAsync(element: ContentElement, layoutOption: LayoutOption): Promise<ResultObject>;
        protected createSurveyLines(container: ContentElement, depth: number): void;
        protected createPlankElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo, plank: PlankData, thick: number, isNz: boolean, offset: number, column: number, row: number): Promise<ResultObject>;
        protected createDecorateElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo, decorate: DecorateData, isNz: boolean, offset: number): Promise<ResultObject>;
        protected createSimpleBasePlankElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject>;
        protected createSimpleSurfacePlankElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject>;
        createPlanksAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, isNz: boolean, offset: number): Promise<ResultObject>;
        createSurfacePlanksAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, isNz: boolean, offset: number): Promise<ResultObject>;
        createDecoratesAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, isNz: boolean, offset: number): Promise<ResultObject>;
        protected createLevellerElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo, leveller: LevellerData, length: number, lengthZ: number, isNz: boolean, depth: number, index: number): Promise<ResultObject>;
        protected createWindowStoneElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo, windowStoneData: WindowStoneData, isNz: boolean, offset: number): Promise<ResultObject>;
        protected createQuadratePipeElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo, quadratePipe: QuadratePipeData, isNz: boolean, depth: number, index: number): Promise<ResultObject>;
        protected createScrewElementAsync(parent: ContentElement, familyInfo: ISpecificationFamilyInfo, screwData: ScrewData, screwLength: number, screwDiameter: number, isNz: boolean, depth: number, index: number): Promise<ResultObject>;
        protected createLevellersAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, levellerLength: number, strengthFamilyInfo: ISpecificationFamilyInfo, strengthLevellerLength: number, levellerLengthZ: number, isNz: boolean, depth: number, strengthDepth: number, boltFamilyInfo: ISpecificationFamilyInfo, boltLength: number, boltDiameter: number): Promise<ResultObject>;
        protected createBaseScrewsAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, screwLength: number, screwDiameter: number, isNz: boolean, depth: number): Promise<ResultObject>;
        protected createQuadratePipeAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, isNz: boolean, offest: number): Promise<ResultObject>;
        protected createWindowStoneAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, isNz: boolean, offest: number): Promise<ResultObject>;
        protected createSurfaceScrewsAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, surfaceScrewLength: number, surfaceScrewDiameter: number, isNz: boolean, depth: number): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutDataMonoCalculator" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { ColumnData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { LevelingLayoutDataCalculator } from "sk/rule/data/rule/levelinglayout/LevelingLayoutDataCalculator";
    export class LevelingLayoutDataMonoCalculator extends LevelingLayoutDataCalculator {
        caclulate(): RuleProcesResult;
        protected cutRows(column: ColumnData, lastColumn: ColumnData, offset?: number, optimize?: boolean, baseRefLines?: RefLine[]): boolean;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingWallMonoBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { LayoutOption, LevelingLayoutData, LevelingLayoutParamers } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { LevelingWallBuilder } from "sk/rule/data/rule/levelinglayout/LevelingWallBuilder";
    export class LevelingWallMonoBuilder extends LevelingWallBuilder {
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers);
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        protected createElementsAsync(element: ContentElement, layoutOption: LayoutOption): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLineArea" {
    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 { WallJoinnerNode } from 'sk/data/scheme/database/floorplan/model/WallJoinnerNode';
    export class FlatWallLineArea {
        private m_cowallNode;
        private m_sameDir;
        constructor(curWall: CowallNode, sameDir: boolean);
        getWallLine(): Line2;
        protected getJoinnerPos(bFromJoinner: boolean): Vector2;
        protected computePosByWallSurface(joinner: WallJoinnerNode, curWall: CowallNode): Vector2;
        protected computePosByJoinner(joinner: WallJoinnerNode): Vector2;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningTypeEnum" {
    export class OpeningTypeEnum {
        static Window: string;
        static Door: string;
        static BeamWindow: string;
        static PlankGap: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallExpandTypeEnum" {
    export class FlatWallExpandTypeEnum {
        static Begin: string;
        static End: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlankGapPosEnum" {
    export class FlatWallPlankGapPosEnum {
        static none: string;
        static LeftUp: string;
        static LeftBottom: string;
        static RightUp: string;
        static RightBottom: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlank" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallPlankGapPosEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlankGapPosEnum";
    export class FlatWallPlank extends ContentBase {
        gapWidth: number;
        gapLength: number;
        gapPos: FlatWallPlankGapPosEnum;
        holeArea: Array<Array<Line2>>;
        surfaceNailsPose: Array<Vector3>;
        row: number;
        colum: number;
        constructor();
        calculateSurfaceNails(nailRadius: number, nailLength: number, nailEdgeDistance: number, nailDistance: number, minNailDistance: number, bInner: boolean): Array<Vector3>;
        private calculateNailsArray;
        private eraseGapNails;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class ContentArea {
        origin: Vector2;
        length: number;
        height: number;
        width: number;
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallProcessUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
    import { FlatWallPlank } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlank";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class FlatWallProcessUtil {
        protected static _calculatorService: CalculatorService;
        private static familyInfoIdMap;
        static createConatinerFromParent(parent: ContentElement, name: string, identifier: number, drawingCodes: string, posContainerZ: number, sizeContainer: Vector3): ContainerElement;
        static getDefaultInfoIdByFamilyIdAsync(context: RuleProcessContext, id: string): Promise<ResultObject<any>>;
        static createElementByFamilyIdAsync(context: RuleProcessContext, parent: ContentElement, id: string, data: ContentBase): Promise<ResultObject<any>>;
        static createPlankElement(parent: ContentElement, data: ContentBase): PlankElement;
        static createElementByFamilyInfoIdAsync(context: RuleProcessContext, parent: ContentElement, familyInfoId: string, data: ContentBase): Promise<ResultObject<any>>;
        static getComponentSymbolsParaAsync(context: RuleProcessContext, familyId: string, symbolsId: Array<string>, symbolsSize: Array<Vector3>): Promise<ResultObject<any>>;
        static getComponentSizeAsync(context: RuleProcessContext, componentIds: string, componentSize: Vector3): Promise<ResultObject<any>>;
        private static getElementConfigFamilyAsync;
        static getReallyCutHoleAttributes(cutlines: Line2[]): ContentArea;
        static mergeHoles(plankPara: FlatWallPlank, holes: ContentArea[]): Array<Array<Line2>>;
        static convertHolePointsToHoleCutLines1(outline: Vector2[], holePoints: Vector2[]): Line2[];
        static convertHolePointsToHoleCutLines2(plankPara: FlatWallPlank, holePoints: Vector2[]): Line2[];
        static sortAntiClockWise(holePoints: Vector2[]): any;
        static getFlatWallType(realFlatWallThickness: number): any;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { AssembleFlatWallPatternElement } from 'sk/data/family/database/pattern/element/AssembleFlatWallPatternElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    export class FlatWallInput {
        earthKeelId60_80: Array<string>;
        earthKeelId: string;
        heavenKeelId60_80: Array<string>;
        heavenKeelId: string;
        verticalKeelId60_80: Array<string>;
        verticalKeelId: string;
        pierceKeelId: string;
        strengthKeelId60_80: Array<string>;
        strengthKeelId: string;
        stullKeelId60_80: Array<string>;
        stullKeelId: string;
        plankId: string;
        rubberPadId60_80: Array<string>;
        rubberPadId: string;
        openingComponentId60_80: Array<string>;
        openingComponentId: string;
        enclosedComponentId60_80: Array<string>;
        enclosedComponentId: string;
        plugBoltId: string;
        antiSkidNail25Id: string;
        antiSkidNail35Id: string;
        platScrewNailId: string;
        decorateContainerId: string;
        decorateId: string;
        beamKeelStrgthComponentId: string;
        minLevelerId: string;
        middleLevelerId: string;
        maxLevelerId: string;
        hardWareHorizontalKeelId: string;
        hardWareSupportClipId: string;
        hardWareSupportClipId60_80: Array<string>;
        doorId: string;
        windowId: string;
        horizontalModuleA: number;
        horizontalModuleB: number;
        maxKeelLength: number;
        heavenEarthKeelSize60_80: Array<Vector3>;
        heavenEarthKeelSizeX: number;
        heavenEarthKeelSizeY: number;
        heavenEarthKeelSizeZ: number;
        rubberPadSize60_80: Array<Vector3>;
        rubberPadSizeX: number;
        rubberPadSizeY: number;
        rubberPadSizeZ: number;
        rubberPadThickness: number;
        openingComponentSize60_80: Array<Vector3>;
        openingComponentSizeX: number;
        openingComponentSizeY: number;
        openingComponentSizeZ: number;
        keelThickness: number;
        verticalToHeavenKeelGap: number;
        verticalKeelSize60_80: Array<Vector3>;
        verticalKeelSizeX: number;
        verticalKeelSizeY: number;
        verticalKeelSizeZ: number;
        doorUpVKeelLength: number;
        strengthKeelSize60_80: Array<Vector3>;
        strengthKeelSizeX: number;
        strengthKeelSizeY: number;
        strengthKeelSizeZ: number;
        enclosedComponentSize60_80: Array<Vector3>;
        enclosedComponentSizeX: number;
        enclosedComponentSizeY: number;
        enclosedComponentSizeZ: number;
        stullKeelSize60_80: Array<Vector3>;
        stullKeelSizeX: number;
        stullKeelSizeY: number;
        stullKeelSizeZ: number;
        stullKeelToVerKeelGap: number;
        openingComponentToHeavenEarthKeelGap: number;
        basePlankHeightA: number;
        basePlankHeightB: number;
        wallHeightThreshold: number;
        plankThickness: number;
        decorateThickness: number;
        topPlankToCeilGap: number;
        surfaceToBasePlankGap: number;
        antiSkidNail25SizeX: number;
        antiSkidNail35SizeX: number;
        antiSkidNail25SizeY: number;
        antiSkidNail25SizeZ: number;
        sizePlatScrewNailX: number;
        sizePlatScrewNailY: number;
        sizePlatScrewNailZ: number;
        depthOfAntiSkidNail25: number;
        antiSkidNaiToEdgeDistance: number;
        minDistanceBetweenNails25: number;
        surfaceToBaseNailGap: number;
        antiSkidNaiVerticalGapForBase: number;
        antiSkidNaiVerticalGapForOuter: number;
        nailToKeelEdgeDistance: number;
        plugBoltSizeX: number;
        plugBoltSizeY: number;
        plugBoltSizeZ: number;
        dcorateThickness: number;
        plugBoltToKeelEdgeDistance: number;
        plugBoltToplugBoltDistance: number;
        plugBoltToKeelEdgeCornorDistance: number;
        plugBoltIdInnerDepth: number;
        keelLengthOfCornorPlugBoltA: number;
        keelLengthOfCornorPlugBoltB: number;
        beamKeelStrgthComponentSizeX: number;
        beamKeelStrgthComponentSizeY: number;
        beamKeelStrgthComponentSizeZ: number;
        beamKeelStrgthComponentToKeelEdgeDistance: number;
        beamKeelStrgthComponentToComponentDistance: number;
        beamLeverToLeverDistance: number;
        beamLeverToLeverVerticalDistance: number;
        plugBoltInBeamComponentToEdgeDistance: number;
        minLevelerSizeX: number;
        minLevelerSizeY: number;
        middleLevelerSizeX: number;
        middleLevelerSizeY: number;
        maxLevelerSizeX: number;
        maxLevelerSizeY: number;
        minLevelerGapRange: Vector2;
        middleLevelerGapRange: Vector2;
        maxLevelerGapRange: Vector2;
        beamLevelerToEdgeDistance: number;
        beamLevelerToHoleEdgeDistance: number;
        miniSizeBetweenLastLevers: number;
        beamHeightWithNoLeveler: number;
        beamHeightWithBrokenlineLeveler: number;
        beamHeightWithTworowLeveler: number;
        beamHeightWithThreerowLeveler: number;
        minSpaceBeteeenWallBeam: number;
        pierceKeelSizeY: number;
        pierceKeelSizeZ: number;
        pierceKeelToEarthKeelDis: number;
        pierceKeelByEarthKeelLengthOffset: number;
        onePierceKeelWallLength: number;
        doublePierceKeelWallLength: number;
        pierceKeelOverlap: number;
        hardWareHorizontalKeelSizeX: number;
        hardWareHorizontalKeelSizeY: number;
        hardWareHorizontalKeelSizeZ: number;
        hardWareSupportClipSizeX: number;
        hardWareSupportClipSizeY: number;
        hardWareSupportClipSizeZ: number;
        hardWareSupportClipSize60_80: Array<Vector3>;
        thickness: number;
        errorStorage: Array<string>;
        constructor();
        loadParametersFromModelAsync(context: ContextObject, element: FlatWallElement): Promise<ResultObject<any>>;
        setParaAsWallType(b60Wall: boolean): void;
        load60_80ParametersFromModelAsync(context: ContextObject, assembleFlatPatternWall: AssembleFlatWallPatternElement): Promise<ResultObject<any>>;
        getFlatwallComponentSizesAsync(context: ContextObject, componentId: string): Promise<ResultObject<any>>;
        getComponentPara6080Async(context: ContextObject, componentId: string, componentSymbolIds: Array<string>, componentSize60_80: Array<Vector3>): Promise<ResultObject<any>>;
        setAntiSkidNailSizesAsync(context: ContextObject): Promise<ResultObject<any>>;
        setLelverDataAsync(context: ContextObject, familyId: string): Promise<ResultObject<any>>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallNailDirectionEnum" {
    export class FlatWallNailDirectionEnum {
        static Up: string;
        static Down: string;
        static Left: string;
        static Right: string;
        static YForward: string;
        static YBackForward: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallAntiSkidNail25" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallNailDirectionEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallNailDirectionEnum";
    export class FlatWallAntiSkidNail25 extends ContentBase {
        nailDirectionType: FlatWallNailDirectionEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum" {
    export class FlatWallOpenDirectionTypeEnum {
        static Unknow: string;
        static Left: string;
        static Right: string;
        static Up: string;
        static Down: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHardwareHorizontalKeel" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    export class FlatWallHardwareHorizontalKeel extends ContentBase {
        openDirectionType: FlatWallOpenDirectionTypeEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpeningComponentTypeEnum" {
    export class FlatWallOpeningComponentTypeEnum {
        static VerticalKeelUp: string;
        static VerticalKeelDown: string;
        static HorizontalKeelLeft: string;
        static HorizontalKeelRight: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpeningComponent" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    import { FlatWallOpeningComponentTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpeningComponentTypeEnum";
    export class FlatWallOpeningComponent extends ContentBase {
        openDirectionType: FlatWallOpenDirectionTypeEnum;
        openingType: FlatWallOpeningComponentTypeEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallVerticalKeel" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    export class FlatWallVerticalKeel extends ContentBase {
        openDirectionType: FlatWallOpenDirectionTypeEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallBeamKeelStrgthComponent" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallNailDirectionEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallNailDirectionEnum";
    export class FlatWallBeamKeelStrgthComponent extends ContentBase {
        openDirectionType: FlatWallNailDirectionEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallDecorteSurface" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class FlatWallDecorateSurface extends ContentBase {
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallEnclosedComponent" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    import { FlatWallOpeningComponentTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpeningComponentTypeEnum";
    export class FlatWallEnclosedComponent extends ContentBase {
        openDirectionType: FlatWallOpenDirectionTypeEnum;
        openingType: FlatWallOpeningComponentTypeEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHardwareSupportClip" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class FlatWallHardwareSupportClip extends ContentBase {
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHorizontalKeel" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    export class FlatWallHorizontalKeel extends ContentBase {
        openDirectionType: FlatWallOpenDirectionTypeEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHorizontalStullKeel" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    export class FlatWallHorizontalStullKeel extends ContentBase {
        openDirectionType: FlatWallOpenDirectionTypeEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWalllevelerTargetEnum" {
    export class FlatWallLelverTargetEnum {
        static Bottom: string;
        static Up: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallleveler" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallLelverTargetEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWalllevelerTargetEnum";
    export class LelverType {
        static none: string;
        static min: string;
        static middle: string;
        static max: string;
    }
    export class FlatWallLelver extends ContentBase {
        type: LelverType;
        target: FlatWallLelverTargetEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPierceKeel" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class FlatWallPierceKeel extends ContentBase {
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlatScrewNail" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallNailDirectionEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallNailDirectionEnum";
    export class FlatWallPlatScrewNail extends ContentBase {
        nailDirectionType: FlatWallNailDirectionEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlugBoltTargetEnum" {
    export class FlatWallPlugBoltTargetEnum {
        static Up: string;
        static Bottom: string;
        static Left: string;
        static Right: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlugBolt" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallPlugBoltTargetEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlugBoltTargetEnum";
    export class FlatWallPlugBolt extends ContentBase {
        openDirectionType: FlatWallPlugBoltTargetEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallRubberPad" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class FlatWallRubberPad extends ContentBase {
    }
}
declare module "sk/rule/data/rule/flatwalllayout/calculator/FlatWallStrengthenKeel" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    export class FlatWallStrengthenKeel extends ContentBase {
        openDirectionType: FlatWallOpenDirectionTypeEnum;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput" {
    import { FlatWallAntiSkidNail25 } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallAntiSkidNail25";
    import { FlatWallBeamKeelStrgthComponent } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallBeamKeelStrgthComponent";
    import { FlatWallDecorateSurface } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallDecorteSurface";
    import { FlatWallEnclosedComponent } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallEnclosedComponent";
    import { FlatWallHardwareSupportClip } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHardwareSupportClip";
    import { FlatWallHorizontalKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHorizontalKeel";
    import { FlatWallHorizontalStullKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHorizontalStullKeel";
    import { FlatWallLelver } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallleveler";
    import { FlatWallOpeningComponent } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpeningComponent";
    import { FlatWallPierceKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPierceKeel";
    import { FlatWallPlank } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlank";
    import { FlatWallPlatScrewNail } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlatScrewNail";
    import { FlatWallPlugBolt } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlugBolt";
    import { FlatWallRubberPad } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallRubberPad";
    import { FlatWallStrengthenKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallStrengthenKeel";
    import { FlatWallVerticalKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallVerticalKeel";
    export class FlatWallOutput {
        innerPlankLayer: Array<FlatWallPlank>;
        keelLayer: Array<FlatWallPlank>;
        outerPlankLayer: Array<FlatWallPlank>;
        ceilingKeels: Array<FlatWallHorizontalKeel>;
        floorKeels: Array<FlatWallHorizontalKeel>;
        verticalKeels: Array<FlatWallVerticalKeel>;
        pierceKeels: Array<FlatWallPierceKeel>;
        rubberPads: Array<FlatWallRubberPad>;
        openingComponents: Array<FlatWallOpeningComponent>;
        enclosedComponents: Array<FlatWallEnclosedComponent>;
        horizontalKeelComponents: Array<FlatWallHorizontalStullKeel>;
        basePlanksBottom: Array<FlatWallPlank>;
        basePlanksUp: Array<FlatWallPlank>;
        outerPlanksBottom: Array<FlatWallPlank>;
        outerPlanksUp: Array<FlatWallPlank>;
        antiSkidNail25sBaseUp: Array<FlatWallAntiSkidNail25>;
        antiSkidNail25sBaseBottom: Array<FlatWallAntiSkidNail25>;
        antiSkidNail25sOuterUp: Array<FlatWallAntiSkidNail25>;
        antiSkidNail25sOuterBottom: Array<FlatWallAntiSkidNail25>;
        lelvers: Array<FlatWallLelver>;
        platScrewNailForKeels: Array<FlatWallPlatScrewNail>;
        plugBolts: Array<FlatWallPlugBolt>;
        decorateSurfacesUp: Array<FlatWallDecorateSurface>;
        decorateSurfacesBottom: Array<FlatWallDecorateSurface>;
        strengthKeels: Array<FlatWallStrengthenKeel>;
        beamKeelStrgthComponents: Array<FlatWallBeamKeelStrgthComponent>;
        hardWareSupportClips: Array<FlatWallHardwareSupportClip>;
        constructor();
        clearAll(): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CubeHoleStructure } from 'foundation/data/common/structure/CubeHoleStructure';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { FloorplanNode } from 'sk/data/scheme/database/floorplan/model/FloorplanNode';
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    export enum BeamToWallPos {
        BeamToWall_Norelation = 0,
        BeamToWall_Cross_Inner = 1,
        BeamToWall_Cross_Outer = 2,
        BeamToWall_Parale_InnerWall_Inner = 3,
        BeamToWall_Parale_InnerWall_Outer = 4,
        BeamToWall_Parale_InnerBeam = 5,
        BeamToWall_Parale_Outside_InnerBeam = 6,
        BeamToWall_Parale_Outside_OuterBeam = 7,
        BeamToWall_PartParale_InnerWall_Inner = 8,
        BeamToWall_PartParale_InnerWall_Outer = 9,
        BeamToWall_PartParale_InnerBeam = 10,
        BeamToWall_PartParale_Outside_InnerBeam = 11,
        BeamToWall_PartParale_Outside_OuterBeam = 12
    }
    export class BeamArea {
        m_beamPos: BeamToWallPos;
        m_nearEdgeDistance: number;
        m_beamHeight: number;
        m_beamOrigin: Vector2;
        m_beamLengthInWall: number;
        m_beamThick: number;
        constructor();
        clone(): BeamArea;
    }
    export class BeamAreaUtil {
        private m_beamToWallStructs;
        constructor();
        computeBeamPoses(floorplan: FloorplanNode, flatWallArea: FlatWallArea, originalWallMidLine: Line2): void;
        computeBeams(beams: Array<CubeHoleStructure>, flatWallArea: FlatWallArea, originalWallMidLine: Line2): void;
        getResult(): Array<BeamArea>;
        protected paralerBeamHoleWallTest(beam: CubeHoleStructure, beamMiddleLongLine: Line2, flatWallArea: FlatWallArea, midWallLine: Line2): void;
        protected paralerBeamWallTest(beam: BeamNode, beamMiddleLongLine: Line2, flatWallArea: FlatWallArea, midWallLine: Line2): void;
        protected crossBeamHoleWallTest(beam: CubeHoleStructure, beamMiddleShortLine: Line2, flatWallArea: FlatWallArea, midWallLine: Line2): void;
        protected crossBeamWallTest(beam: BeamNode, beamMiddleShortLine: Line2, flatWallArea: FlatWallArea, midWallLine: Line2): void;
        protected posProjectionInWall(beamLine: Line2, wallLine: Line2): Vector2;
        protected isBeamProjectInWall(beamMiddleLongLine: Line2, midWallLine: Line2): Boolean;
        getFlatWallMidLine(flatWallArea: FlatWallArea, originalWallMidLine: Line2): Line2;
        getCrossBeamHoleIntersectData(beam: CubeHoleStructure, beamMiddleShortLine: Line2, flatWallArea: FlatWallArea, midFlatWallLine: Line2): any;
        getCrossBeamIntersectData(beam: BeamNode, beamMiddleShortLine: Line2, flatWallArea: FlatWallArea, midFlatWallLine: Line2): any;
        private isParalerBeamCoverWall;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea" {
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { OpeningTypeEnum } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningTypeEnum";
    export class OpeningArea extends ContentArea {
        type: OpeningTypeEnum;
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    export class FlatWallArea extends ContentArea {
        generateType: string;
        holes: Array<OpeningArea>;
        beamArea: Array<BeamArea>;
        innerBaseEnable: boolean;
        outerBaseEnable: boolean;
        innerSurfaceEnable: boolean;
        outerSurfaceEnable: boolean;
        innerDecorateEnable: boolean;
        outerDecorateEnable: boolean;
        innerEdgeGapEnable: boolean;
        outerEdgeGapEnable: boolean;
        innerBasicLines: Array<Line2>;
        innerSurfaceLines: Array<Line2>;
        innerDecorateLines: Array<Line2>;
        innerPlankHeight: number;
        keelStructureLine: Line2;
        keelStructureHeight: number;
        outerBasicLines: Array<Line2>;
        outerSurfaceLines: Array<Line2>;
        outerDecorateLines: Array<Line2>;
        outerPlankHeight: number;
        flatWallBaseThickness: number;
        flatWallInnerExtension: number;
        flatWallOuterExtension: number;
        keelBeginFlags: number;
        keelEndFlags: number;
        innerEdgeGapThickness: number;
        outerEdgeGapThickness: number;
        constructor();
        setKeelStructAsDoubleKeelLayer(bInner: boolean): void;
        setKeelStructAsSingleKeelLayer(): void;
        isInnerBaseShow(): boolean;
        isOuterBaseShow(): boolean;
    }
    export class FlatWallGenerateType {
        static single: string;
        static inner: string;
        static outer: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    export class FlatWallLayoutArea extends ContentArea {
        from: Vector2;
        to: Vector2;
        depth: number;
        flatWallArea: FlatWallArea;
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/kdtree/KdTreeNode" {
    import { Region } from 'foundation/runtime/math/Region';
    export class KdTreeNode {
        region: Region;
        value: any;
        isLeaf: boolean;
        depth: number;
        leftNode: KdTreeNode;
        rightNode: KdTreeNode;
        constructor(region: Region, depth: number, isLeaf: boolean, value?: any);
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallLelverStructure" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LelverType } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallleveler";
    import { FlatWallLelverTargetEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWalllevelerTargetEnum";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    export class FlatWallLelverStructure extends ContentArea {
        center: Vector2;
        diameter: number;
        target: FlatWallLelverTargetEnum;
        thickness: number;
        type: LelverType;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallEliminateHoleEnum" {
    export class FlatWallEliminateHoleEnum {
        static Any: string;
        static BeamHole: string;
        static HoleUpPlank: string;
        static WindowBottomPlank: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    export class FlatWallVerticalKeelType {
        static NormalStart: string;
        static NormalMiddle: string;
        static NormalEnd: string;
        static HoleStart: string;
        static HoleUp: string;
        static HoleBottom: string;
        static HoleEnd: string;
        static InnerPlankStart: string;
        static InnerPlankEnd: string;
        static OuterPlankStart: string;
        static OuterPlankEnd: string;
        static CrossBeamStart: string;
        static CrossBeamMid: string;
        static CrossBeamEnd: string;
    }
    export class FlatWallVerticalFrameStructure extends ContentArea {
        endPosition: number;
        verticalKeelType: FlatWallVerticalKeelType;
        verticalKeelDirection: FlatWallOpenDirectionTypeEnum;
        width: number;
        length: number;
        tBasicGapLine: Line2;
        tSurfaceGapLine: Line2;
        posHoleStart: Vector2;
        holeLength: number;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    import { FlatWallEliminateHoleEnum } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallEliminateHoleEnum";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    export class FlatWallSurfacePlankType {
        static Normal: string;
        static DoorStart: string;
        static DoorEnd: string;
    }
    export class FlatWallPlankGapPosType {
        static none: string;
        static LeftUp: string;
        static LeftBottom: string;
        static RightUp: string;
        static RightBottom: string;
    }
    export class FlatWallSurfacePlankStructure extends ContentArea {
        holes: Array<OpeningArea>;
        holeCutLines: Array<HoleCutLine>;
        screws: Array<Vector2>;
        constructor();
    }
    export class FlatWallBasicPlankStructure extends FlatWallSurfacePlankStructure {
        frameVerticalKellEnd: Array<FlatWallVerticalFrameStructure>;
        constructor();
    }
    export class HoleCutLine extends ContentArea {
        cutHoleType: FlatWallEliminateHoleEnum;
        lines: Array<Line2>;
        holeType: string;
        constructor();
    }
    export class FlatWallSurfaceColumnStructure {
        origin: Vector2;
        length: number;
        height: number;
        holes: Array<OpeningArea>;
        arranges: Array<number>;
        surfacePlankType: FlatWallSurfacePlankType;
        planks: Array<FlatWallSurfacePlankStructure>;
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure" {
    import { KdTreeNode } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/kdtree/KdTreeNode";
    import { FlatWallLelverStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallLelverStructure";
    import { FlatWallBasicPlankStructure, FlatWallSurfacePlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    export class FlatWallAreaLayoutOutputStructure {
        verticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        holeSideVerticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        innerSurfacePlanks: Array<FlatWallSurfacePlankStructure>;
        outerSurfacePlanks: Array<FlatWallSurfacePlankStructure>;
        innerLelvers: Array<FlatWallLelverStructure>;
        outerLelvers: Array<FlatWallLelverStructure>;
        innerScrewsKdTree: KdTreeNode;
        outerScrewsKdTree: KdTreeNode;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallbasePlankCalculator" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicPlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    export class FlatWallbasePlankCalculator {
        wallArea: FlatWallArea;
        input: FlatWallInput;
        protected verticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        frameStructure: FlatWallAreaLayoutOutputStructure;
        protected innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        protected outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        constructor(input: FlatWallInput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): void;
        protected computeBasicPlank(input: FlatWallInput, wallInfo: FlatWallArea, bInner: boolean): void;
        protected computeInnerBasicPlankInfo(input: FlatWallInput, wallInfo: FlatWallArea, plankStart: Array<number>, plankLength: Array<number>, plankInnerKeels: Array<Array<FlatWallVerticalFrameStructure>>): void;
        protected computeSectionInnerBasicPlankInfo(input: FlatWallInput, wallInfo: FlatWallArea, plankLine: Line2, plankStart: Array<number>, plankLength: Array<number>, plankInnerKeels: Array<Array<FlatWallVerticalFrameStructure>>): void;
        protected standardlizeInnerPlankInfo(input: FlatWallInput, plankStart: Array<number>, plankLength: Array<number>, plankInnerKeels: Array<Array<FlatWallVerticalFrameStructure>>): void;
        protected computeOuterBasicPlankInfo(input: FlatWallInput, wallInfo: FlatWallArea, plankStart: Array<number>, plankLength: Array<number>, plankInnerKeels: Array<Array<FlatWallVerticalFrameStructure>>): void;
        protected computeSectionOuterBasicPlankInfo(input: FlatWallInput, wallInfo: FlatWallArea, outerBasicLine: Line2, plankStart: Array<number>, plankLength: Array<number>, plankInnerKeels: Array<Array<FlatWallVerticalFrameStructure>>): void;
        protected standardlizeOuterPlankInfo(input: FlatWallInput, plankStart: Array<number>, plankLength: Array<number>, plankInnerKeels: Array<Array<FlatWallVerticalFrameStructure>>): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/RegionUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { HoleCutLine } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    export class RegionUtil {
        static regionCollision(region: ContentArea, cutArea: ContentArea): ResultObject;
        static isOverLaped(region: ContentArea, cutArea: ContentArea): boolean;
        static isHoleOnLocation(location: string, hole: HoleCutLine): boolean;
        static isHolesOnLocation(location: string, holes: Array<HoleCutLine>): boolean;
        static computeCutArea(region: ContentArea, cutArea: ContentArea): ResultObject<HoleCutLine>;
        static computeOriginCutArea(region: ContentArea, cutArea: ContentArea): ResultObject<HoleCutLine>;
        static getAdjustedLocation(min: number, max: number, minRate: number, maxRate: number, isHorizontal: boolean): ResultObject;
        static getOriginalLocation(min: number, max: number, minRate: number, maxRate: number, isHorizontal: boolean): ResultObject;
        static isPointInRegion(region: ContentArea, point: Vector2): boolean;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallBasicCalculator" {
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallEliminateHoleEnum } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallEliminateHoleEnum";
    import { FlatWallBasicPlankStructure, HoleCutLine } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    export class FlatWallBasicCalculator {
        wallArea: FlatWallArea;
        input: FlatWallInput;
        output: FlatWallOutput;
        frameStructure: FlatWallAreaLayoutOutputStructure;
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): void;
        protected testPlankCollision(targetPlanks: Array<FlatWallBasicPlankStructure>, cutPlank: FlatWallBasicPlankStructure, cutPlankType: FlatWallEliminateHoleEnum): void;
        protected standardLizeHoles(tarPlank: FlatWallBasicPlankStructure, leftOffset: number, rightOffset: number, bottomOffset: number, topOffset: number): void;
        protected createNewSmallPlank(tarPlank: FlatWallBasicPlankStructure, cutHole: HoleCutLine, cutPlankType: FlatWallEliminateHoleEnum): Array<FlatWallBasicPlankStructure>;
        protected getExtraPlankKeels(plank: FlatWallBasicPlankStructure, appendPlankStartX: number, appendPlankLength: number): Array<FlatWallVerticalFrameStructure>;
        protected calculateNailsArray(posStart: number, posEnd: number, antiSkidNaiVerticalGap: number, minDistanceBetweenNails: number): Array<number>;
        protected getLinesRects(tarPlank: FlatWallBasicPlankStructure): Array<FlatWallBasicPlankStructure>;
        protected isCurrentKeelAffectedByCrossBeam(beam: BeamArea): boolean;
        protected getAffectedSeperatedBeams(beamArea: BeamArea[]): BeamArea[];
        protected getHeavenKeelTopHeight(horitionalPos: number): number;
        getBeamSidePlankConnectedEdges(plankArray: Array<FlatWallBasicPlankStructure>): Array<number>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallbaseScrewCalculator" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallLelverStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallLelverStructure";
    import { FlatWallBasicPlankStructure, HoleCutLine } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallBasicCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallBasicCalculator";
    export class FlatWallbaseScrewCalculator extends FlatWallBasicCalculator {
        protected innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        protected outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        protected innerLelver: Array<FlatWallLelverStructure>;
        protected outerLelver: Array<FlatWallLelverStructure>;
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): void;
        protected calculateBasicPlankNailsOneSide(bInner: boolean): void;
        protected computeAntiSkidNails(basicPlankArray: Array<FlatWallBasicPlankStructure>): void;
        protected getVerticalScrewLines(basicPlank: FlatWallBasicPlankStructure): Array<Line2>;
        protected separateNearScrews(holeScrewLines: Array<Line2>, KeelScrewLines: Array<Line2>): void;
        protected calcluateOneVerticalNailArray(basicPlank: FlatWallBasicPlankStructure, posX: number, verticalLineStart: number, verticalLineEnd: number): Array<Array<number>>;
        protected oupPutNailArrays(basicPlank: FlatWallBasicPlankStructure, posX: number, posYArray: Array<Array<number>>): void;
        protected calcluateArroundHoleVerticalLines(basicPlank: FlatWallBasicPlankStructure): Array<Line2>;
        protected getReallyCutHoleAttributes(basicPlank: FlatWallBasicPlankStructure, hole: HoleCutLine): ContentArea;
        protected calcluateplankVerticalLineByX(basicPlank: FlatWallBasicPlankStructure, posX: number, verticalLineStart: number, verticalLineEnd: number): Array<Line2>;
        protected sepateLineByHole(holeStart: number, holeEnd: number, lineArray: Array<Line2>): Array<Line2>;
        protected calcluateStullKeelNailArray(basicPlankArray: Array<FlatWallBasicPlankStructure>): void;
        protected calcluateLelverNailArray(basicPlankArray: Array<FlatWallBasicPlankStructure>, basicLelvers: Array<FlatWallLelverStructure>, bInner: boolean): void;
        isNailInPlankHole(holes: Array<ContentArea>, nailPos: Vector2): boolean;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/DoorArea" {
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    export class DoorArea extends OpeningArea {
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallHoleStructCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallBasicCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallBasicCalculator";
    export enum CrossBeamToHolePos {
        None = 0,
        LeftEdge = 1,
        Middle = 2,
        RightEdge = 3
    }
    export class HoleRelatedBeams {
        crossBeamToHolePos: CrossBeamToHolePos;
        beam: BeamArea;
        constructor();
    }
    export class FlatWallHoleStructCalculator extends FlatWallBasicCalculator {
        protected crossBeamToHole: Array<CrossBeamToHolePos>;
        compute(): void;
        protected createDoorUpStructs(holeArea: OpeningArea): boolean;
        protected createAllKeelStructs(holeStartPoint: Vector2, holeWidth: number, holeHeight: number, outVerticalKeels: Array<FlatWallVerticalFrameStructure>): boolean;
        protected isBeamRightKeelGenerated(holeUpBeam: HoleRelatedBeams, beams: BeamArea[]): boolean;
        protected isBeamLeftKeelGenerated(holeUpBeam: HoleRelatedBeams, beams: BeamArea[]): boolean;
        protected getDoorUPVerticalLine(holeStartPoint: Vector2, holeWidth: number): Array<number>;
        protected checkDoorSideKeelsCollision(holeStartPoint: Vector2, holeWidth: number, leftBeamVerticalMiddleLinePoses: Array<number>, rightBeamVerticalMiddleLinePoses: Array<number>): boolean;
        private eraseCollisionRightVerticals;
        protected getBeamToHolePos(holeStartPoint: Vector2, holeWidth: number): Array<HoleRelatedBeams>;
        private createHoleUpVerticalKeels;
        createDoorUpStrengthKeel(holeStartPoint: Vector2, holeWidth: number, holeHeight: number, leftToTopHeight: number, rightToTopHeight: number): void;
        createDoorUpBasicPlank(bInner: boolean, holeArea: OpeningArea, doorUPVerticalKeels: Array<FlatWallVerticalFrameStructure>): void;
        protected getHoleSideVerticalKeels(holeStartPoint: Vector2, holeWidth: number): Array<FlatWallVerticalFrameStructure>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallDoorStructCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicPlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallHoleStructCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallHoleStructCalculator";
    export class FlatWallDoorStructCalculator extends FlatWallHoleStructCalculator {
        protected verticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        protected innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        protected outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): boolean;
        createDoorUpsideKeelStruct(input: FlatWallInput, output: FlatWallOutput, keelHeight: number, holeStartPoint: Vector2, holeWidth: number, holeHeight: number): void;
        createDoorStrengthKeel(input: FlatWallInput, output: FlatWallOutput, keelHeight: number, holeStartPoint: Vector2, holeWidth: number, holeHeight: number): boolean;
        createDoorUpStrengthKeel(holeStartPoint: Vector2, holeWidth: number, holeHeight: number, leftToTopHeight: number, rightToTopHeight: number): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallEliminatePlankHoleCalculator" {
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallBasicCalculator";
    export class FlatWallEliminatePlankHoleCalculator extends FlatWallBasicCalculator {
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): void;
        protected eraseVerticalBeamHole(): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallHoritionalKeelCalculator" {
    import { FlatWallHorizontalKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHorizontalKeel";
    import { FlatWallPlugBolt } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlugBolt";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicPlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallBasicCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallBasicCalculator";
    export class FlatWallHoritionalKeelCalculator extends FlatWallBasicCalculator {
        verticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        constructor(input: FlatWallInput, output: FlatWallOutput, wallArea: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): void;
        createHeaveKeels(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, wallArea: FlatWallArea): void;
        createBeamHeaveKeels(input: FlatWallInput, output: FlatWallOutput, wallArea: FlatWallArea, crossBeam: BeamArea): void;
        createSectionHeaveKeels(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, sectionStartX: number, sectionLength: number): void;
        createHeavenKeelUpComponents(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, sectionKeelStart: number, sectionKeelsLength: number): void;
        protected computeSectionKeelMiddleStruct(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): void;
        createVerticalPlugBolt(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, wallArea: FlatWallArea): void;
        calculatePlugBoltPoses(input: FlatWallInput, posStart: number, posEnd: number, plugBoltArray: Array<number>): void;
        protected computeSectionVerticalKeelsWithDoors(verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): Array<Array<FlatWallVerticalFrameStructure>>;
        protected computeSectionVerticalKeelsWithHoles(verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): Array<Array<FlatWallVerticalFrameStructure>>;
        createRubbberPad(input: FlatWallInput, output: FlatWallOutput, sectionKeels: Array<FlatWallVerticalFrameStructure>): void;
        createEarthKeels(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, sectionKeels: Array<FlatWallVerticalFrameStructure>): void;
        createPierceKeels(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, sectionKeels: Array<FlatWallVerticalFrameStructure>): void;
        getTwoPiereceKeelJoinner(input: FlatWallInput, keelStart: number, keelEnd: number, posOverLapCenter: number, posOverLapCenterLeft: number, posOverLapCenterRight: number): {
            pos1: number;
            pos2: number;
        };
        getThreePiereceKeelJoinner(input: FlatWallInput, keelStart: number, keelEnd: number, centerleftPoses: Array<number>, centerRightPoses: Array<number>): {
            posBottomLeft: number;
            posBottomRight: number;
            posUpLeft: number;
            posUpRight: number;
        };
        createOnePierceKeel(input: FlatWallInput, output: FlatWallOutput, startPosX: number, endPosX: number, pierceKeelToEarthKeelDis: number): void;
        createHardwareSupportClips(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, sectionKeels: Array<FlatWallVerticalFrameStructure>): void;
        createStullKeels(input: FlatWallInput, output: FlatWallOutput, sectionKeels: Array<FlatWallVerticalFrameStructure>): void;
        isCurPlankHeavenKeelExist(curPlank: FlatWallBasicPlankStructure): boolean;
        getCurPlankKeelLayerHeight(curPlank: FlatWallBasicPlankStructure): number;
        protected createOneStullKeel(input: FlatWallInput, output: FlatWallOutput, preVerticalKeelStruct: FlatWallVerticalFrameStructure, nextVertcialKeelStruct: FlatWallVerticalFrameStructure, midStullKeelHeight: number): void;
        createVerticalKeelPlugBoltOneSide(input: FlatWallInput, output: FlatWallOutput, bStart: Boolean, keelStructureHeight: number, wallArea: FlatWallArea): void;
        createEarthPlugBolt(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, sectionKeelStart: number, sectionKeelsLength: number): void;
        protected isDoorEndKeels(verticalFrameStructure: FlatWallVerticalFrameStructure): Boolean;
        protected createKeelUpComponentArray(keelUpComponentXArray: Array<number>, keelStructureHeight: number): void;
        protected createSingleKeelUpComponent(keelStructureHeight: number, keelUpPlugBoltX: number, bGeneratePlugBolt: boolean, bDireOut: boolean): void;
        protected getKeelLayerHeight(): number;
        protected getEdgeWallHeight(bStart: Boolean): number;
        protected getCrossBeamLeftHeavenKeel(input: FlatWallInput, crossBeam: BeamArea): {
            ceilingKeelLeft: FlatWallHorizontalKeel;
            plugBolts: FlatWallPlugBolt[];
        };
        protected getCrossBeamBottomHeavenKeel(input: FlatWallInput, crossBeam: BeamArea): void;
        protected getCrossBeamRightHeavenKeel(input: FlatWallInput, crossBeam: BeamArea): {
            ceilingKeelRight: FlatWallHorizontalKeel;
            plugBolts: FlatWallPlugBolt[];
        };
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallLeversCalculator" {
    import { Bound2 } from 'foundation/runtime/math/Bound2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LelverType } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallleveler";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallLelverStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallLelverStructure";
    import { FlatWallBasicPlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallBasicCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallBasicCalculator";
    export class FlatWallLeversCalculator extends FlatWallBasicCalculator {
        protected innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        protected outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        innerLelvers: Array<FlatWallLelverStructure>;
        outerLelvers: Array<FlatWallLelverStructure>;
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): void;
        protected createLelvers(): void;
        protected createBeamLelvers(horitionalBeam: BeamArea): void;
        protected createInnerLelvers(horitionalBeam: BeamArea): void;
        protected createOuterLelvers(horitionalBeam: BeamArea): void;
        protected eraseLelversByPlankHoles(bInner: boolean, planks: Array<FlatWallBasicPlankStructure>, lelvers: Array<FlatWallLelverStructure>, holeOffset: number): void;
        protected getHoleBesideLelvers(bInner: boolean, planks: Array<FlatWallBasicPlankStructure>, lelverSize: Vector3, lelverType: LelverType, lelverDepth: number, horitionalBeam: BeamArea): Array<FlatWallLelverStructure>;
        protected appendEdgeLevelers(basicLines: Line2[], vPoses: number[], levelers: FlatWallLelverStructure[]): void;
        protected getHoleBottomLelverHPos(holeStartX: number, holeEndX: number, edgeOffset: number, planks: Array<FlatWallBasicPlankStructure>, lelverSize: Vector3, horitionalBeam: BeamArea): Array<number>;
        protected eraseLelversByBeamLine(lelvers: FlatWallLelverStructure[], beamLineStart: number, beamLineEnd: number): void;
        protected outputLelvers(bInner: boolean, resultLelvers: Array<FlatWallLelverStructure>): void;
        protected isPosValid(lelverVerticalPos: number, plankLineArray: Array<Line2>, lelverDiameter: number): boolean;
        protected getBeamAndPlankHoles(bInner: boolean, planks: Array<FlatWallBasicPlankStructure>): Array<Bound2>;
        protected getBeamHoles(bInner: boolean): Array<Bound2>;
        protected getPlanksHoles(planks: Array<FlatWallBasicPlankStructure>): Array<Bound2>;
        protected getLelverType(gapDepth: number): LelverType;
        protected getLelverPos(bInner: boolean, lelverSize: Vector3, hBeam: BeamArea): any;
        protected getLelverHorizonalPos(lelverSize: Vector3, planks: Array<FlatWallBasicPlankStructure>, plankLines: Array<Line2>, hBeam: BeamArea): Array<number>;
        protected getLelverVerticalPos(topPos: number, bottomPos: number, minDistance: number): Array<number>;
        protected getSectionPos(start: number, end: number, edgeOffset: number, planks: Array<FlatWallBasicPlankStructure>, lelverSize: Vector3, hBeam: BeamArea): Array<number>;
        protected getLinkedPlankEdges(start: number, end: number, planks: Array<FlatWallBasicPlankStructure>, hBeam: BeamArea): Array<number>;
        protected earseSamePlankEdge(plankInnerEdge: Array<number>): void;
        protected getCurLelverPos(posX: number, start: number, end: number, linkedPlankEdges: Array<number>, lelverSize: Vector3): any;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallVerticalKeelCalculator" {
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallVerticalFrameStructure, FlatWallVerticalKeelType } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallBasicCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallBasicCalculator";
    export class FlatWallVerticalKeelCalculator extends FlatWallBasicCalculator {
        wallArea: FlatWallArea;
        input: FlatWallInput;
        protected verticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): boolean;
        protected constructFrameVertical(): boolean;
        protected constructBasicFrameVertical(input: FlatWallInput, wallInfo: FlatWallArea): void;
        protected isKeelCollision(verticalFrameStructure: FlatWallVerticalFrameStructure[], verticalCrossBeamStart: FlatWallVerticalFrameStructure): boolean;
        protected appendPlankEdgeKeels(input: FlatWallInput, verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): void;
        protected appendOnePlankEdgeKeel(verticalFrameStructure: Array<FlatWallVerticalFrameStructure>, keelEndPos: number, keelLength: number, keelType: FlatWallVerticalKeelType): void;
        protected constructExtraFrameVertical(input: FlatWallInput): void;
        protected standardlizeFrameVertical(): boolean;
        protected eraseRepeated(totalVerticalFrame: Array<FlatWallVerticalFrameStructure>, tolerance: number): Array<FlatWallVerticalFrameStructure>;
        protected eraseInsideHoleKeels(totalVerticalFrame: Array<FlatWallVerticalFrameStructure>): boolean;
        protected canKeelErase(flatWallVerticalFrameStructure: FlatWallVerticalFrameStructure): boolean;
        protected addBeamCenterVerticals(verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): Array<FlatWallVerticalFrameStructure>;
        protected isCrossBeamRelateKeel(curKeel: FlatWallVerticalFrameStructure): boolean;
        protected eraseOutsideWallVerticals(verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): Array<FlatWallVerticalFrameStructure>;
        protected reCalVerticalHeightByBeamAndHoles(verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): Array<FlatWallVerticalFrameStructure>;
        protected reCalVerticalTarget(verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): Array<FlatWallVerticalFrameStructure>;
        protected testValid(totalVerticalKeels: Array<FlatWallVerticalFrameStructure>, resultVerticalStart: FlatWallVerticalFrameStructure, resultVerticalEnd: FlatWallVerticalFrameStructure): boolean;
        protected getSectionExtraVerticalFrame(input: FlatWallInput, verticalStart: FlatWallVerticalFrameStructure, verticalEnd: FlatWallVerticalFrameStructure): Array<FlatWallVerticalFrameStructure>;
        protected getBeam(curVerticalFrameStructure: FlatWallVerticalFrameStructure): BeamArea;
        protected getHole(curVerticalFrameStructure: FlatWallVerticalFrameStructure): OpeningArea;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallWindowStructCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicPlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallHoleStructCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallHoleStructCalculator";
    export class FlatWallWindowStructCalculator extends FlatWallHoleStructCalculator {
        protected verticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        protected innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        protected outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): boolean;
        private createWindowUpsideKeelStruct;
        private createWindowDownsideKeelStruct;
        protected getDoorUPVerticalLine(holeStartPoint: Vector2, holeWidth: number): Array<number>;
        createWindowStrengthKeel(input: FlatWallInput, output: FlatWallOutput, keelHeight: number, holeStartPoint: Vector2, holeWidth: number, holeHeight: number): void;
        createHoleBottomBasicPlank(bInner: boolean, holeArea: OpeningArea, doorBottomVerticalKeels: Array<FlatWallVerticalFrameStructure>): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallStructuresManager" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallHardwareHorizontalKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHardwareHorizontalKeel";
    import { FlatWallOpenDirectionTypeEnum } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallOpenDirectionTypeEnum";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicPlankStructure, FlatWallSurfacePlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    export class VerticalLinkKeelData {
        verticalLinkePosX: number;
        verticalDirectionType: FlatWallOpenDirectionTypeEnum;
        constructor(verticalLinkePosX: number, verticalDirectionType: FlatWallOpenDirectionTypeEnum);
    }
    export class FlatWallStructuresManager {
        layoutAreaArea: FlatWallLayoutArea;
        input: FlatWallInput;
        output: FlatWallOutput;
        protected outputLayoutStruct: FlatWallAreaLayoutOutputStructure;
        constructor(input: FlatWallInput, output: FlatWallOutput, layoutAreaArea: FlatWallLayoutArea);
        calculate(): boolean;
        getHarewareHorizontalKeels(): Array<FlatWallHardwareHorizontalKeel>;
        protected preCalculate(): boolean;
        getScrews(planks: Array<FlatWallBasicPlankStructure>): Array<Vector2>;
        protected midCalculate(): void;
        protected lastCalculate(): void;
        protected outPutStruct(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): boolean;
        protected outputVerticalKeelsStructures(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): Promise<ResultObject>;
        protected outputBasicPlanks(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): void;
        protected outputBasicPlanksScrews(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): void;
        protected outputSurfacePlanks(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): void;
        protected outputSurfaceScrewPlanks(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): void;
        protected outputBasicPlanksOneSide(basicLineStructure: Array<FlatWallBasicPlankStructure>, bInner: boolean): void;
        protected outputBasicPlanksScrewsOneSide(basicLineStructure: Array<FlatWallBasicPlankStructure>, bInner: boolean): void;
        protected outputSurfaceScrewsOneSide(surfaceLineStructures: Array<FlatWallSurfacePlankStructure>, bInner: Boolean): void;
        protected outputSurfacePlanksInnerSide(surfaceLineStructures: Array<FlatWallSurfacePlankStructure>): void;
        private getCutHoleLines;
        protected outputSurfacePlanksOuterSide(surfaceLineStructures: Array<FlatWallSurfacePlankStructure>): void;
        private mirroPlank;
        private getMirroCutHoleLines;
        protected isKeelCuttedByHole(input: FlatWallInput, curVertical: FlatWallVerticalFrameStructure, holes: Array<OpeningArea>): boolean;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallVirtualStructuresManager" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FlatWallPlank } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlank";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    export class FlatWallLayerType {
        static innerPlank: string;
        static keel: string;
        static outerPlank: string;
    }
    export class FlatWallVirtualStructuresManager {
        layoutArea: FlatWallArea;
        input: FlatWallInput;
        output: FlatWallOutput;
        constructor(input: FlatWallInput, output: FlatWallOutput, layoutAreaArea: FlatWallLayoutArea);
        calculate(): ResultObject<any>;
        appendLayer(layerType: FlatWallLayerType, outputArray: Array<FlatWallPlank>, plankPosX: number, plankPosY: number, plankPosZ: number, plankLengthX: number, plankLengthY: number, plankLengthZ: number): void;
        private getCutHoleLines;
        private bCorssBeamHoleExist;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallTranformUtil" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class FlatWallTranformType {
        static RotateX90: string;
        static RotateX90_Reverse: string;
        static RotateY90: string;
        static RotateY90_Reverse: string;
        static RotateZ90: string;
        static RotateZ90_Reverse: string;
        static RotateX180: string;
        static RotateY180: string;
        static RotateZ180: string;
    }
    export class FlatWallTranformUtil {
        private static xLength;
        private static yLength;
        private static zLength;
        static adjustComponentGesture(originComponentStruct: ContentBase, transformType1: FlatWallTranformType, transformType2?: FlatWallTranformType, transformType3?: FlatWallTranformType): ContentBase;
        private static initLengthData;
        private static parseTransformEnum;
        private static rotateX90;
        private static rotateX90_reverse;
        private static rotateY90;
        private static rotateY90_reverse;
        private static rotateZ90;
        private static rotateZ90_reverse;
        private static rotateX180;
        private static rotateY180;
        private static rotateZ180;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallConnectedStructsInfo" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { ConnectedWallPlankParas } from "sk/rule/data/rule/assemble/FlatWallElementUtil";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    export class FlatWallConnectedStructsInfo {
        protected walllNodes: Array<WallNode>;
        protected assembleFlatWall: AssembleFlatWallElement;
        protected input: FlatWallInput;
        protected plankPara: ConnectedWallPlankParas;
        protected wallLine: Line2;
        constructor(assembleFlatWall: AssembleFlatWallElement, walllNodes: Array<WallNode>, plankPara: ConnectedWallPlankParas);
        getlayoutArea(): FlatWallLayoutArea;
        protected reComputeWallLineByPara(bReverse: boolean, keelBeginDistance: number, keelEndDistance: number): void;
        protected computeWallLineByWalls(bReverse: boolean): void;
        protected computeFlatWallLines(layoutArea: FlatWallLayoutArea, plankPara: ConnectedWallPlankParas): void;
        protected addWallOffset(originLine: Line2, offset: number): Line2;
        protected wallLineSort(wallLines: Array<Line2>): Line2;
        protected getHolePos(wallNodes: Array<WallNode>, wallLine: Line2): Array<OpeningArea>;
        protected standlizeLine(line: Line2): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallSingleStructInfo" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { CowallNode } from 'sk/data/scheme/database/floorplan/model/CowallNode';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    export class FlatWallLineInfo {
        wallMiddleLine: Line2;
        offsetDistance: number;
        constructor(cowall: CowallNode, sameDir: boolean);
    }
    export class FlatWallSingleStructInfo {
        protected walllNode: WallNode;
        protected assembleFlatWall: AssembleFlatWallElement;
        protected wallLine: Line2;
        constructor(assembleFlatWall: AssembleFlatWallElement, walllNode?: WallNode);
        getlayoutArea(): FlatWallLayoutArea;
        protected reComputeWallLineByPara(bReverse: boolean, keelBeginDistance: number, keelEndDistance: number): void;
        protected computeWallLineByWall(bReverse: boolean, walllNode: WallNode): void;
        protected getCowallNodeByConnectedFlatwall(flatWallElement: FlatWallElement, curWallNode: WallNode): FlatWallLineInfo;
        protected computeFlatWallLines(layoutArea: FlatWallLayoutArea, innerStartExtend: number, innerEndExtend: number, outStartExtend: number, outerEndExtend: number): void;
        protected addWallOffset(originLine: Line2, offset: number): Line2;
        protected getHolePos(wallNode: WallNode, wallLine: Line2): Array<OpeningArea>;
        protected standlizeLine(line: Line2): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallSingleStructsInfo2" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { ConnectedWallPlankParas } from "sk/rule/data/rule/assemble/FlatWallElementUtil";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    export class FlatWallSingleStructInfo2 {
        protected assembleFlatWall: AssembleFlatWallElement;
        protected flatWall: FlatWallElement;
        protected plankPara: ConnectedWallPlankParas;
        protected bReverse: boolean;
        protected wallLine: Line2;
        constructor(assembleFlatWall: AssembleFlatWallElement, plankPara?: ConnectedWallPlankParas);
        protected computeWallLineByWall(): void;
        protected reComputeWallLineByPara(keelBeginDistance: number, keelEndDistance: number): void;
        getlayoutArea(): FlatWallLayoutArea;
        protected computeFlatWallLinesByPlankParas(layoutArea: FlatWallLayoutArea, plankPara: ConnectedWallPlankParas): void;
        protected wallLineSort(wallLines: Array<Line2>): Line2;
        protected computeFlatWallLines(layoutArea: FlatWallLayoutArea, assembleFlatWall: AssembleFlatWallElement): void;
        protected calculateInnerOutterLines(keelStructureLine: Line2, innerLines: Line2[], outerLines: Line2[], innerStartExtend: number, innerEndExtend: number, outStartExtend: number, outerEndExtend: number): void;
        protected getHolePos(wallLine: Line2): Array<OpeningArea>;
        protected addWallOffset(originLine: Line2, offset: number): Line2;
        protected standlizeLine(line: Line2): void;
        isSameDirection(vec1: Vector2, vec2: Vector2): Boolean;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { CowallNode } from 'sk/data/scheme/database/floorplan/model/CowallNode';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { ConnectedWallPlankParas } from "sk/rule/data/rule/assemble/FlatWallElementUtil";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallAntiSkidNail25 } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallAntiSkidNail25";
    import { FlatWallHardwareHorizontalKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHardwareHorizontalKeel";
    import { FlatWallPlank } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlank";
    export class FlatwallBuilder {
        tarAssembleElement: AssembleFlatWallElement;
        bSingle: boolean;
        keelLayerThickness: number;
        keelGapSize: number;
        protected edgeGapContainerBottom: ContainerElement;
        protected decorateContainerBottom: ContainerElement;
        protected surfacePlankContainerBottom: ContainerElement;
        protected basePlankContainerBottom: ContainerElement;
        protected innerKeelContainer: ContainerElement;
        protected keelJointContainer: ContainerElement;
        protected outerKeelContainer: ContainerElement;
        protected basePlankContainerUp: ContainerElement;
        protected surfacePlankContainerUp: ContainerElement;
        protected decorateContainerUp: ContainerElement;
        protected edgeGapContainerUp: ContainerElement;
        private posEdgeGapContainerZBottom;
        private posDecorateContainerZBottom;
        private posSurfacePlankContainerZBottom;
        private posBasePlankContainerZBottom;
        private posKeelInnerContainerZ;
        private posKeelJoinerContainerZ;
        private posKeelOuterContainerZ;
        private posBasePlankContainerZUp;
        private posSurfacePlankContainerZUp;
        private posDecorateContainerZUp;
        private posEdgeGapContainerZUp;
        context: RuleProcessContext;
        flatWall: AssembleFlatWallElement;
        rectModelInput: FlatWallInput;
        rectModelOutput: FlatWallOutput;
        layoutArea: FlatWallLayoutArea;
        constructor();
        buildFromElement(context: RuleProcessContext, curWall: CowallNode, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        buildFromCowallNode(context: RuleProcessContext, curWall: CowallNode, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        buildFromFlatWallElement(context: RuleProcessContext, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        buildFromWallNodes(context: RuleProcessContext, walllNodes: Array<WallNode>, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput, plankPara: ConnectedWallPlankParas): void;
        buildFromConnectFlatWalls(context: RuleProcessContext, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput, plankPara: ConnectedWallPlankParas): void;
        processFlatWallAsync(buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        checkData(): boolean;
        construWallInfoFromSingleWallNodeAsync(resultElement: AssembleFlatWallElement, walllNode: WallNode): Promise<void>;
        construWallInfoFromSingleWallAsync(resultElement: AssembleFlatWallElement): Promise<void>;
        construWallInfoFromWallNodesAsync(resultElement: AssembleFlatWallElement, walllNodes: Array<WallNode>, plankPara: ConnectedWallPlankParas): Promise<void>;
        virtualObjectShowingManagerAsync(element: ContentElement): Promise<ResultObject>;
        fillVirtualPlankLayerAsync(basePlanks: Array<FlatWallPlank>, plankContainer: ContainerElement): Promise<ResultObject<any>>;
        realObjectShowingManagerAsync(element: ContentElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject>;
        createHoleElementsAsync(parentElement: FlatWallElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        createContainers(element: ContentElement, bSingleWall: boolean): void;
        computeContianerPos(): boolean;
        fillContainersAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        processSingleKeelFlatwallAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        setSingleFlatwallHeighs(): void;
        processDoubleKeelFlatwallAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        getDoubleFlatwallHeighs(keelLayerHeights: Array<number>, basePlankLayerHeights: Array<number>): void;
        calculateFlatWallComponentResultAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        fillContainerKeelsAsync(layer: number, rectModelInput: FlatWallInput, keelContainer: ContainerElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        fillBasePlanksOneSideAsync(layer: number, basePlanks: Array<FlatWallPlank>, baseNails: Array<FlatWallAntiSkidNail25>, plankContainer: ContainerElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        showKeels(): void;
        findElementChildByName(element: InstanceElement, name: string): InstanceElement;
        generateVerticalKeelLinkerAsync(rectModelInput: FlatWallInput, hardwareHorizontalKeels: Array<Array<FlatWallHardwareHorizontalKeel>>): Promise<ResultObject<any>>;
        processHoleCutLines(plankPara: FlatWallPlank): void;
        plankGapProcess(plankElement: FamilyInstanceElement, parent: ContentElement, plankPara: FlatWallPlank): void;
        prefixInteger(num: number, length: number): string;
        setResultValid(): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallBuilderInDesign" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { CowallNode } from 'sk/data/scheme/database/floorplan/model/CowallNode';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { ConnectedWallPlankParas } from "sk/rule/data/rule/assemble/FlatWallElementUtil";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallAntiSkidNail25 } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallAntiSkidNail25";
    import { FlatWallHardwareHorizontalKeel } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallHardwareHorizontalKeel";
    import { FlatWallPlank } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallPlank";
    export class FlatwallBuilderInDesign {
        tarAssembleElement: AssembleFlatWallElement;
        bSingle: boolean;
        keelLayerThickness: number;
        keelGapSize: number;
        protected edgeGapContainerBottom: ContainerElement;
        protected decorateContainerBottom: ContainerElement;
        protected surfacePlankContainerBottom: ContainerElement;
        protected basePlankContainerBottom: ContainerElement;
        protected innerKeelContainer: ContainerElement;
        protected keelJointContainer: ContainerElement;
        protected outerKeelContainer: ContainerElement;
        protected basePlankContainerUp: ContainerElement;
        protected surfacePlankContainerUp: ContainerElement;
        protected decorateContainerUp: ContainerElement;
        protected edgeGapContainerUp: ContainerElement;
        private posEdgeGapContainerZBottom;
        private posDecorateContainerZBottom;
        private posSurfacePlankContainerZBottom;
        private posBasePlankContainerZBottom;
        private posKeelInnerContainerZ;
        private posKeelJoinerContainerZ;
        private posKeelOuterContainerZ;
        private posBasePlankContainerZUp;
        private posSurfacePlankContainerZUp;
        private posDecorateContainerZUp;
        private posEdgeGapContainerZUp;
        context: RuleProcessContext;
        flatWall: AssembleFlatWallElement;
        rectModelInput: FlatWallInput;
        rectModelOutput: FlatWallOutput;
        layoutArea: FlatWallLayoutArea;
        constructor();
        buildFromElement(context: RuleProcessContext, curWall: CowallNode, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        buildFromCowallNode(context: RuleProcessContext, curWall: CowallNode, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        buildFromFlatWallElement(context: RuleProcessContext, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        buildFromWallNodes(context: RuleProcessContext, walllNodes: Array<WallNode>, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput, plankPara: ConnectedWallPlankParas): void;
        buildFromConnectFlatWalls(context: RuleProcessContext, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput, plankPara: ConnectedWallPlankParas): void;
        processFlatWallAsync(buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        construWallInfoFromSingleWallNodeAsync(resultElement: AssembleFlatWallElement, walllNode: WallNode): Promise<void>;
        construWallInfoFromSingleWallAsync(resultElement: AssembleFlatWallElement): Promise<void>;
        construWallInfoFromWallNodesAsync(resultElement: AssembleFlatWallElement, walllNodes: Array<WallNode>, plankPara: ConnectedWallPlankParas): Promise<void>;
        virtualObjectShowingManagerAsync(element: ContentElement): Promise<ResultObject>;
        fillVirtualPlankLayerAsync(basePlanks: Array<FlatWallPlank>, plankContainer: ContainerElement): Promise<ResultObject<any>>;
        realObjectShowingManagerAsync(element: ContentElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject>;
        createHoleElementsAsync(parentElement: FlatWallElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        createContainers(element: ContentElement, bSingleWall: boolean): void;
        computeContianerPos(): boolean;
        fillContainersAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        processSingleKeelFlatwallAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        setSingleFlatwallHeighs(): void;
        getDoubleFlatwallHeighs(keelLayerHeights: Array<number>, basePlankLayerHeights: Array<number>): void;
        calculateFlatWallComponentResultAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        fillContainerKeelsAsync(parent: any, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        fillBasePlanksOneSideAsync(layer: number, basePlanks: Array<FlatWallPlank>, baseNails: Array<FlatWallAntiSkidNail25>, plankContainer: ContainerElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        showKeels(): void;
        findElementChildByName(element: InstanceElement, name: string): InstanceElement;
        generateVerticalKeelLinkerAsync(rectModelInput: FlatWallInput, hardwareHorizontalKeels: Array<Array<FlatWallHardwareHorizontalKeel>>): Promise<ResultObject<any>>;
        processHoleCutLines(plankPara: FlatWallPlank): void;
        plankGapProcess(plankElement: FamilyInstanceElement, parent: ContentElement, plankPara: FlatWallPlank): void;
        prefixInteger(num: number, length: number): string;
        setResultValid(): void;
    }
}
declare module "sk/rule/data/rule/assemble/FlatWallElementUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CubeHoleStructure } from 'foundation/data/common/structure/CubeHoleStructure';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { WallElement } from 'sk/data/scheme/database/floorplan/element/WallElement';
    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 { WallJoinnerNode } from 'sk/data/scheme/database/floorplan/model/WallJoinnerNode';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { FlatWallGroupElement } from 'sk/data/scheme/database/pattern/element/FlatWallGroupElement';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { FlatWallExpandTypeEnum } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallExpandTypeEnum";
    import { FlatwallBuilder } from "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallBuilder";
    export type FlatWallExpandParameter = {
        expandCd: FlatWallExpandTypeEnum;
        wall: WallNode;
    };
    export class FlatWallLinePara {
        flatWallInnerLine: Line2;
        flatWallMidLine: Line2;
        flatWallOuterLine: Line2;
        flatWallElement: FlatWallElement;
        constructor(innerLine: Line2, midLine: Line2, outerLine: Line2, flatWallElement: FlatWallElement);
    }
    export class ConnectedWallPlankParas {
        bInnerBaseLinesShow: boolean;
        bOuterBaseLinesShow: boolean;
        wallInnerBaseLines: Array<Line2>;
        wallOuterBaseLines: Array<Line2>;
        bInnerSurfaceLinesShow: boolean;
        bOuterSurfaceLinesShow: boolean;
        wallInnerSurfaceLines: Array<Line2>;
        wallOuterSurfaceLines: Array<Line2>;
        bInnerDecorateLinesShow: boolean;
        bOuterDecorateLinesShow: boolean;
        wallInnerDecorateLines: Array<Line2>;
        wallOuterDecorateLines: Array<Line2>;
        wallLine: Line2;
        constructor();
    }
    export class FlatWallElementUtil {
        static createFlatWallElement(coWallNode: CowallNode, element?: FlatWallElement): any;
        static createFlatWallElementFromWallsAsync(context: ContextObject, wallNode: WallNode, element?: FlatWallElement, reverse?: boolean): Promise<ResultObject<FlatWallElement>>;
        static createFlatWallElementFromWallSurfaceAsync(context: ContextObject, wallSurfaceNode: WallSurfaceNode, element?: FlatWallElement, reverse?: boolean): Promise<ResultObject<FlatWallElement>>;
        static createFlatWallElementByHoleAsync(context: ContextObject, holeNode: HoleNode, element?: FlatWallElement, reverse?: boolean): Promise<ResultObject<FlatWallElement>>;
        static initFlatWallByHole(flatwall: FlatWallElement, hole: HoleNode, reverse?: boolean): void;
        static initAssembleWallByHole(assembleFlatWall: AssembleFlatWallElement, hole: HoleNode): void;
        static createFlatWallElementFreelyAsync(context: ContextObject, element: FlatWallElement, params: any, reverse?: boolean): Promise<ResultObject<FlatWallElement>>;
        static initFlatWallByParams(flatwall: FlatWallElement, params: any, reverse?: boolean): void;
        static initFlatWallByWallSurface(flatwall: FlatWallElement, wallSurfaceNode: WallSurfaceNode, reverse?: boolean): void;
        static initFlatWall(flatwall: FlatWallElement, wall: WallNode, reverse?: boolean): void;
        static updateFlatWallProperty(flatwall: FlatWallElement): void;
        static updateExtendFlatWallProperty(wall: FlatWallElement): void;
        protected static getBeamsPos(wallNode: WallNode, holes: Types<CubeHoleStructure>): Types<CubeHoleStructure>;
        protected static getHolePos(wallNode: WallNode): Types<CubeHoleStructure>;
        static expandFlatWallFromWallsAsync(context: ContextObject, parameters: Array<FlatWallExpandParameter>, originalElement: FlatWallElement): Promise<ResultObject>;
        static updateFlatWallAsync(context: ContextObject, element: FlatWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static getFrontSideBuildType(element: FlatWallElement): BuildStructureTypeEnum;
        static getBackSideBuildType(element: FlatWallElement): BuildStructureTypeEnum;
        static updateConnectedFlatWallsAsync(context: ContextObject, element: FlatWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateConnectedFlatWallFromWallsAsync(context: ContextObject, element: FlatWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static findFlatWallGroup(element: FlatWallElement, finMain?: boolean): FlatWallGroupElement;
        static groupRelationUpdate(group: FlatWallGroupElement): void;
        static createFlatWallGroup(elements: FlatWallElement[]): FlatWallGroupElement;
        static resetRelation(group: FlatWallGroupElement): void;
        static deleteFlatWallGroup(element: FlatWallElement): void;
        static resetFlatWallGroup(group: FlatWallGroupElement, ignoreFlatWall: FlatWallElement): void;
        static findFlatWallGroups(element: FlatWallElement): Types<FlatWallGroupElement>;
        static updateConnectedFlatWallAsync(context: ContextObject, element: FlatWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static getFlatWallParaLines(wallElement: WallElement): FlatWallLinePara;
        static loadDocumentParametersAsync(context: ContextObject, element: FlatWallElement): Promise<ResultObject<any>>;
        static expandFlatWallFromWallAsync(context: ContextObject, wallNode: WallNode, originalElement: FlatWallElement, expandCd: FlatWallExpandTypeEnum): Promise<ResultObject<FlatWallElement>>;
        static getRoomsOfFlatWall(flatwall: FlatWallElement): Array<RoomNode>;
        static deleteFlatWall(flatWall: FlatWallElement): void;
        static clearGroupMembers(group: FlatWallGroupElement): void;
        static clearFlatWall(element: FlatWallElement): void;
        static clearLinkedFlatWalls(element: FlatWallElement): void;
        static findPreFlatWall(element: FlatWallElement): any;
        static findLastFlatWall(element: FlatWallElement): any;
        static buildFlatWallAsync(context: ContextObject, element: AssembleFlatWallElement, buildType: BuildStructureTypeEnum, cowallNode?: CowallNode): Promise<ResultObject>;
        static buildFlatWall2Async(context: ContextObject, element: AssembleFlatWallElement, cowallNode: CowallNode, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static initAssembleWall(assembleFlatWall: AssembleFlatWallElement, wall: WallNode): void;
        static initGroupAssembleWall(groupAssembleFlatWall: AssembleFlatWallElement, assembleFlatWall: AssembleFlatWallElement): void;
        static initAssembleWallBySurface(assembleFlatWall: AssembleFlatWallElement, wallSurface: WallSurfaceNode): void;
        static initAssembleWallByParams(assembleFlatWall: AssembleFlatWallElement, params: any): void;
        static initGroupFlatWall(groupFlatWall: FlatWallElement, flatWall: FlatWallElement): void;
        protected static copyAssembleFlatWallParameter(bCommonCopy: boolean, target: AssembleFlatWallElement, sourceBegin: AssembleFlatWallElement, sourceEnd?: AssembleFlatWallElement): void;
        static connectSeperateFlatWallsAsync(context: ContextObject, element: FlatWallElement, expandCd: FlatWallExpandTypeEnum): Promise<ResultObject<any>>;
        static mergeLines(line1From: Vector2, line1To: Vector2, line2From: Vector2, line2To: Vector2): Line2;
        static buildFlatWallFromWallsAsync(context: ContextObject, element: AssembleFlatWallElement, plankPara: ConnectedWallPlankParas, buildType: BuildStructureTypeEnum, wallNodes?: Array<WallNode>): Promise<ResultObject>;
        static initFlatWallElementWithBuilder(builder: FlatwallBuilder): void;
        static findLinkWalls(element: FlatWallElement): Array<WallNode>;
        static findConnectedWalls(element: FlatWallElement, group?: FlatWallGroupElement): Array<WallNode>;
        static resetConnectFlatWallName(firstFlatwall: FlatWallElement): void;
        static getArea(flatwall: FlatWallElement): number;
        static computeLineByPara(startPoint: Vector2, endPoint: Vector2, beginDistance: number, endDistance: number, offset: number): Line2;
        static computeConnectedFlatwallsAttr(connectedFlatwall: FlatWallElement, group?: FlatWallGroupElement): ConnectedWallPlankParas;
        static reverseLines(wallLines: Line2[], totalWallLength: number): Line2[];
        static getUnionLineLength(line1: Line2, line2: Line2): number;
        static mergePlankLines(wallLines: Array<Line2>): Array<Line2>;
        static findLinkWallElements(element: FlatWallElement): Array<WallElement>;
        static findNeighborWalls(node: FlatWallNode): any;
        protected static findParallelWallByJoinner(joinner: WallJoinnerNode, linkWalls: WallNode[]): WallNode;
        static getLinkedFlatWalls(flatWall: FlatWallElement): Array<FlatWallElement>;
        static updateFloorplanFaltwallNameIdentifier(floorplan: FloorplanNode): void;
        static updateFloorplanFaltwallGroupNameIdentifier(floorplan: FloorplanNode): void;
        static isType(info: ISpecificationFamilyInfo, linkerPatternElement: LinkerPatternElement): boolean;
        static isTypeAsync(info: ISpecificationFamilyInfo, linkerPatternElement: LinkerPatternElement): Promise<boolean>;
        static getLineMidPoint(line1: Line2): Vector2;
        static isSameTarget(line1: Line2, line2: Line2): boolean;
        static getFlatWallBaseLine(flatWall: FlatWallElement): {
            line1: Line2;
            line2: Line2;
        };
    }
}
declare module "sk/rule/data/rule/assemble/LevelingWallElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    import { AssembleLevelingWallPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingWallPatternElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { LayerComponentElement } from 'sk/data/family/element/component/LayerComponentElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BeamWallIntersectInfo } from 'sk/data/scheme/database/floorplan/model/util/BeamNodeUtil';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { WallElement } from 'sk/data/scheme/database/floorplan/element/WallElement';
    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 { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { HoleData, LevelingLayoutData, LevelingLayoutParamers } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class LevelingWallElementUtil {
        static createLevelingWallsByDefaultAsync(outline: Array<Vector2>, wallElement: LevelingWallElement, holes?: Array<Array<Vector2>>): Promise<ResultObject>;
        static createLevelingWallByOutlineAsync(infoId: string, document: SchemeDocument, outline: Array<Vector2>, element: LevelingWallElement, holes?: Array<Array<Vector2>>): Promise<ResultObject>;
        static updateLevelingWallLinkedPatternAsync(assembleRoom: AssembleRoomElement, levelingWall: LevelingWallElement, newPatternInfoId: string): Promise<ResultObject>;
        static isOnFlatWall(levelingWall: LevelingWallElement): boolean;
        static caculateHolesByOutline(outline: Array<Vector2>, bound: any): Array<Array<Vector2>>;
        static loadLeveingWallPatternParamsAsync(element: LevelingWallElement): Promise<ResultObject>;
        static createLevelingWallsByRoomAsync(assembleContext: AssembleRoomContext, room: RoomNode): Promise<ResultObject>;
        static createSplitLevelingWallsAsync(assembleContext: AssembleRoomContext, wallSurfaceNode: WallSurfaceNode, room: RoomNode): Promise<ResultObject>;
        private static createLevelingWallByLineInfos;
        private static processFlatwallOnWall;
        private static processDoorAndWindowOnWall;
        private static processDoorAndWindowOnFlatWall;
        static getLineOpengingsHoleDatas(wallSurface: WallSurfaceNode, line: Line2): Array<HoleData>;
        private static processBeamsOnWall;
        static getLineBeamHoleDatas(levelingWall: LevelingWallElement, wallSurface: WallSurfaceNode): Array<HoleData>;
        private static processCeilingOnWall;
        private static createLevelingWallsByLineInfosAsync;
        static getLineCeilingHoleDatas(levelingWall: LevelingWallElement, wallSurface: WallSurfaceNode, line: Line2): Array<HoleData>;
        private static setFlatWallInfo;
        static createOpeningElementOnSurfaceAsync(assembleContext: AssembleRoomContext, wallSurfaceNode: WallSurfaceNode): Promise<ResultObject>;
        static createLevelingWallElement(assembleContext: AssembleRoomContext, from: Vector2, to: Vector2): LevelingWallElement;
        static createAssebmleWallAndDecorateLayer(element: LevelingWallElement): void;
        static createLevelingWallElement2(assembleContext: AssembleRoomContext, position: Vector3, size: Vector3, rotation: Vector3, placeCd: ContentPlaceTypeEnum): LevelingWallElement;
        static loadWallPatternParametersAsync(assembleWallPattern: AssembleLevelingWallPatternElement, assembleWallElementInfoId: string, wallDecorateLinkPattern: LinkerPatternElement, element: LevelingWallElement): Promise<ResultObject>;
        static updateLevelingWallDecorateAsync(element: LevelingWallElement): Promise<ResultObject>;
        private static updateLevelingWallByDecorate;
        static updateLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        private static calculateLevelingWallScrewsAsync;
        static updateMonoLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateLevelingWallPlankScrewsAsync(context: ElementPerformerContext, element: ContentElement, calcualteType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateLevelingFloorByArea(element: LevelingWallElement): LevelingWallElement;
        static getLevelingWallFamilyInfoIdsAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject<{
            levelerId: string[];
            boltId: string;
            baseId: string;
            surfaceId: string;
            screwId: string;
            surfaceScrewId: string;
            quadratePipeId: string;
        }>>;
        static getReferenceElementAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject<AssembleLevelingWallPatternElement>>;
        static getParamsFromLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject<LevelingLayoutParamers>>;
        static setLevelingWallType(levelingWall: LevelingWallElement, assemblePatternWall: AssembleLevelingWallPatternElement): void;
        static updateLevelingLayers(element: LevelingWallElement, layoutData: LevelingLayoutData): void;
        static getLayerComponentByName(element: AssembleLevelingWallPatternElement, name: string): LayerComponentElement;
        static setLeveilingWallParamAsync(context: ElementPerformerContext, element: AssembleLevelingWallPatternElement, params: LevelingLayoutParamers): Promise<ResultObject>;
        static buildLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static buildMonoLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static buildLevelingLayerWallAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static getConnectBeamInfosOfLevelingWall(levelingWall: LevelingWallElement): Array<BeamWallIntersectInfo>;
        static getConnectAssembleBeamInfosOfLevelingWall(levelingWall: LevelingWallElement): Array<any>;
        static getBeamInfoOnLine(beam: AssembleBeamElement, line: Line2): any;
        static getThicknessWithSpace(assembleWallElement: AssembleLevelingWallElement, spaceThickness: number): number;
        static getThicknessWithDecorate(assembleWallElement: AssembleLevelingWallElement, thicknessWithDecorate: number): number;
        static getSpaceThickness(assembleWallElement: AssembleLevelingWallElement): number;
        static getDecorateThickness(assembleWallElement: AssembleLevelingWallElement): number;
        static updatePlankPressRelationAsync(assembleRoom: AssembleRoomElement): Promise<ResultObject>;
        static processFlatwallAsync(curLevelingWall: LevelingWallElement): Promise<ResultObject>;
        static getAllSameLineWalls(curWall: WallElement, room: RoomElement): Array<WallElement>;
        static minWallToLineDistance(curWall: WallElement, line: Line2): number;
        static isWallCloseWiseOrder(curWall: WallElement, preLine: Line2): boolean;
        static isMatchedOnBaseLine(levelingWall: LevelingWallElement, baseLine: Line2): boolean;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleColumnElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ColumnNode } from 'sk/data/scheme/database/floorplan/model/ColumnNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleColumnElement } from 'sk/data/scheme/database/pattern/element/AssembleColumnElement';
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class AssembleColumnElementUtil {
        static createAssembleColumnElementsAsync(assembleContext: AssembleRoomContext, room: RoomNode): Promise<ResultObject>;
        static createAssembleColumnElementAsync(assembleContext: AssembleRoomContext, room: RoomNode, columnNode: ColumnNode): Promise<ResultObject>;
        private static createLevelingWallsAsync;
        static convertPolygonByLevelingWall(columnNode: ColumnNode): any;
        static updateAssembleColumnAsync(context: ElementPerformerContext, element: AssembleColumnElement, simplify?: boolean): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/PolygonLayoutDataUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleLevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingCeilingElement';
    import { LevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/LevelingCeilingElement';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { PolygonKeelLayoutData } from "sk/rule/data/rule/levelinglayout/keellayout/PolygonKeelLayoutData";
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class PolygonLayoutDataUtil {
        static getLayoutDatasFromRoom(room: RoomNode): Array<PolygonLayoutData>;
        static getLayoutDataFromLevelingFloor(levelingFloor: LevelingFloorElement): PolygonLayoutData;
        private static computeDecorateWithHole;
        private static computeDecorate;
        static getLayoutDataFromLevelinCeiling(levelingCeiling: LevelingCeilingElement): PolygonKeelLayoutData;
        static setEmptyLayoutData(data: PolygonLayoutData): void;
        static getLayoutDataFromLevelinCeilingElement(levelingCeiling: any, plankTileRotation?: number): PolygonLayoutData;
        static getLayoutDataFromAssLevelinCeiling(assLevelingCeiling: AssembleLevelingCeilingElement): PolygonKeelLayoutData;
        static convertPolygonByReginAndDir(polygon: Array<Vector2>, region: any[], dir: string): Array<Vector2>;
        static getRoomRegion(room: RoomNode): void;
        static dirCount: number;
        private static getRoomFloorWorkHeight;
        static getSingleLayoutDataFromRoom(room: RoomNode, isAssembled?: boolean): PolygonLayoutData;
        private static getLayoutDataFromPoints;
        private static getLayoutDataFromPolygon;
        static getLayoutDataFromLevelingFloorElement(levelingFloor: LevelingFloorElement): PolygonLayoutData;
        static getLayoutDataFromAreaPolygon(areaPolygon: Array<Vector2>): PolygonLayoutData;
    }
}
declare module "sk/rule/data/molding/LevelingFloorGraphic2dConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { PathSolidMoldingOptions } from 'foundation/runtime/graphics/molding/path/PathSolidMoldingOptions';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { LevelingFloorGraphic3dStructure } from 'sk/data/family/molding/instance/LevelingFloorGraphic3dStructure';
    import { LevelingFloorNode } from 'sk/data/scheme/database/pattern/node/LevelingFloorNode';
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class LevelingFloorGraphic2dConverter extends MoldingGraphics3dConverter {
        constructor();
        createStructure(): LevelingFloorGraphic3dStructure;
        protected computeSurfaceUV(node: LevelingFloorNode): UVOptions;
        protected computeSideSurfaceUV(surface: EdgeSurfaceNode): PathSolidMoldingOptions;
        protected computeDecorate(layoutData: PolygonLayoutData): void;
        private toVector3Array;
        computeStructure(context: MoldingDataContext, node: LevelingFloorNode, target?: LevelingFloorGraphic3dStructure, options?: MoldingGeometricOptions): LevelingFloorGraphic3dStructure;
        protected computeSectionWithArc(section: PathCurve2d, radius: number): PathCurve2d;
        protected interLineAndLine(beg1: Vector3, k1: Vector3, beg2: Vector3, k2: Vector3): Vector3;
        protected interSegAndCircle(lineBegin: Vector3, lineEnd: Vector3, circleCenter: Vector3, circleRadius: number): Vector3;
    }
}
declare module "sk/rule/data/molding/LevelingFloorGraphic3dConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { PathSolidMoldingOptions } from 'foundation/runtime/graphics/molding/path/PathSolidMoldingOptions';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { LevelingFloorGraphic3dStructure } from 'sk/data/family/molding/instance/LevelingFloorGraphic3dStructure';
    import { LevelingFloorNode } from 'sk/data/scheme/database/pattern/node/LevelingFloorNode';
    export class LevelingFloorGraphic3dConverter extends MoldingGraphics3dConverter {
        constructor();
        createStructure(): LevelingFloorGraphic3dStructure;
        protected computeSurfaceUV(node: LevelingFloorNode): UVOptions;
        protected computeSideSurfaceUV(surface: EdgeSurfaceNode): PathSolidMoldingOptions;
        private computeDecorate;
        private toVector3Array;
        computeStructure(context: MoldingDataContext, node: LevelingFloorNode, target?: LevelingFloorGraphic3dStructure, options?: MoldingGeometricOptions): LevelingFloorGraphic3dStructure;
        protected computeSectionWithArc(section: PathCurve2d, radius: number): PathCurve2d;
        protected interLineAndLine(beg1: Vector3, k1: Vector3, beg2: Vector3, k2: Vector3): Vector3;
        protected interSegAndCircle(lineBegin: Vector3, lineEnd: Vector3, circleCenter: Vector3, circleRadius: number): Vector3;
    }
}
declare module "sk/rule/data/molding/LightGraphic3dOptions" {
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGradualColor } from 'foundation/data/common/model/molding/MoldingGradualColor';
    export class LightGraphic3dOptions extends MoldingGeometricOptions {
        gradua: MoldingGradualColor;
        constructor(gradua?: MoldingGradualColor);
        isOptionOkey(other: LightGraphic3dOptions): boolean;
    }
}
declare module "sk/rule/data/molding/LightGraphic3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingConverter } from 'foundation/core/module/molding/MoldingConverter';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    import { LightGraphic3dOptions } from "sk/rule/data/molding/LightGraphic3dOptions";
    export class LightGraphic3dConverter extends MoldingConverter {
        protected structure: MoldingGeometryStructure;
        constructor();
        createStructure(): MoldingGeometryStructure;
        process(context: MoldingContext, node: LightNode, target?: MoldingGeometryStructure, options?: LightGraphic3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/LightOutline3dOptions" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { MoldingGradualColor } from 'foundation/data/common/model/molding/MoldingGradualColor';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    export class LightOutline3dOptions extends MoldingOutline3dOptions {
        gradua: MoldingGradualColor;
        constructor(proj?: Matrix4, isOnlyLocal?: boolean, isOnlyCurve?: boolean, gradua?: MoldingGradualColor);
    }
}
declare module "sk/rule/data/molding/LightOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    import { LightOutline3dOptions } from "sk/rule/data/molding/LightOutline3dOptions";
    export class LightOutline3dConverter extends MoldingOutline3dConverter {
        protected structure: MoldingOutline3dConverter;
        constructor();
        process(context: MoldingContext, node: LightNode, target?: MoldingOutline3dStructure, options?: LightOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/LightPointOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { PointLightNode } from 'sk/data/scheme/database/light/model/PointLightNode';
    import { LightOutline3dOptions } from "sk/rule/data/molding/LightOutline3dOptions";
    export class LightPointOutline3dConverter extends MoldingOutline3dConverter {
        protected structure: MoldingOutline3dStructure;
        constructor();
        process(context: MoldingContext, node: PointLightNode, target?: MoldingOutline3dStructure, options?: LightOutline3dOptions): ResultEnum;
        private generateLines;
    }
}
declare module "sk/rule/data/molding/LinearBrepConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingBrepConverter } from 'foundation/data/common/model/molding/MoldingBrepConverter';
    import { MoldingBrepOptions } from 'foundation/data/common/model/molding/MoldingBrepOptions';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { LinearBrepStructure } from 'sk/data/family/molding/instance/LinearBrepStructure';
    export class LinearBrepConverter extends MoldingBrepConverter {
        constructor();
        createStructure(): LinearBrepStructure;
        process(context: MoldingDataContext, node: LinearNode, target?: LinearBrepStructure, options?: MoldingBrepOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/LinearCollisionTechConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingTechCollisionConverter } from 'foundation/data/common/model/molding/MoldingTechCollisionConverter';
    import { MoldingTechCollisionStructure } from 'foundation/data/common/model/molding/MoldingTechCollisionStructure';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    export class LinearCollisionTechConverter extends MoldingTechCollisionConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: LinearNode, target?: MoldingTechCollisionStructure): MoldingTechCollisionStructure;
    }
}
declare module "sk/rule/data/molding/LinearGraphic3dConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PolygonPathGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonPathGeometry';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { LinearGraphic3dStructure } from 'sk/data/family/molding/instance/LinearGraphic3dStructure';
    export class LinearGraphic3dConverter extends MoldingGraphics3dConverter {
        protected structure: LinearGraphic3dStructure;
        constructor();
        createStructure(): LinearGraphic3dStructure;
        getSurface(liner: any): PolygonPathGeometry;
        calculatePoints(liner: any): Array<Vector3>;
        computeStructure(context: MoldingDataContext, node: LinearNode, target?: LinearGraphic3dStructure): LinearGraphic3dStructure;
    }
}
declare module "sk/rule/data/molding/LinearOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { FamilyInstanceOutline2dConverter } from "sk/rule/data/molding/FamilyInstanceOutline2dConverter";
    export class LinearOutline2dConverter extends FamilyInstanceOutline2dConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: PlaneNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/LinearOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { FamilyInstanceOutline3dConverter } from "sk/rule/data/molding/FamilyInstanceOutline3dConverter";
    export class LinearOutline3dConverter extends FamilyInstanceOutline3dConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: PlaneNode, target?: MoldingOutline3dStructure, options?: MoldingOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/ModelsMoldingExtraDataUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ModelMoldingExtraData, ModelsMoldingExtraData } from 'foundation/data/common/model/molding/ModelsMoldingExtraData';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    export class ModelsMoldingExtraDataUtil {
        protected static _modelDocumentService: ModelDocumentService;
        static getModelExtraDataInfoAsync(modelId: string, backend: boolean): Promise<ResultObject<ModelMoldingExtraData>>;
        static getMultiModelExtraDataInfoAsync(modelIds: Array<string>): Promise<ResultObject<ModelsMoldingExtraData>>;
    }
}
declare module "sk/rule/data/molding/PatternInstanceCollision3dConverter" {
    import { MoldingCollision3dConverter } from 'foundation/data/common/model/molding/MoldingCollision3dConverter';
    import { MoldingCollision3dOptions } from 'foundation/data/common/model/molding/MoldingCollision3dOptions';
    import { MoldingCollision3dStructure } from 'foundation/data/common/model/molding/MoldingCollision3dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class PatternInstanceCollision3dConverter extends MoldingCollision3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: PatternInstanceNode, target?: MoldingCollision3dStructure, options?: MoldingCollision3dOptions): MoldingCollision3dStructure;
        private mergeMoldingGeometryStructures;
    }
}
declare module "sk/rule/data/molding/PatternInstanceOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline2dConverter } from 'foundation/data/common/model/molding/MoldingOutline2dConverter';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class PatternInstanceOutline2dConverter extends MoldingOutline2dConverter {
        constructor();
        process(context: MoldingDataContext, node: PatternInstanceNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
        private buildSingleStructureBySolid;
        private mergeMoldingGeometryStructures;
    }
}
declare module "sk/rule/data/molding/PatternInstanceOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    export class PatternInstanceOutline3dConverter extends MoldingOutline3dConverter {
        constructor();
        process(context: MoldingDataContext, node: PatternInstanceNode, target?: MoldingOutline3dStructure, options?: MoldingOutline3dOptions): ResultEnum;
        private buildSingleStructureBySolid;
        private mergeMoldingGeometryStructures;
    }
}
declare module "sk/rule/data/molding/Pipe3dConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PolygonPathGeometry } from 'foundation/runtime/graphics/shape/geometry/PolygonPathGeometry';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { LinearGraphic3dStructure } from 'sk/data/family/molding/instance/LinearGraphic3dStructure';
    import { LinearGraphic3dConverter } from "sk/rule/data/molding/LinearGraphic3dConverter";
    export class Pipe3dConverter extends LinearGraphic3dConverter {
        constructor();
    }
    export class Pipe3dConverter2 extends MoldingGraphics3dConverter {
        protected structure: LinearGraphic3dStructure;
        constructor();
        createStructure(): LinearGraphic3dStructure;
        getSurface(liner: any): PolygonPathGeometry;
        calculatePoints(liner: any): Array<Vector3>;
        computeStructure(context: MoldingDataContext, node: LinearNode, target?: LinearGraphic3dStructure): LinearGraphic3dStructure;
    }
}
declare module "sk/rule/data/molding/PlaneBrepConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingBrepConverter } from 'foundation/data/common/model/molding/MoldingBrepConverter';
    import { MoldingBrepOptions } from 'foundation/data/common/model/molding/MoldingBrepOptions';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneBrepStructure } from 'sk/data/family/molding/instance/PlaneBrepStructure';
    export class PlaneBrepConverter extends MoldingBrepConverter {
        constructor();
        createStructure(): PlaneBrepStructure;
        process(context: MoldingDataContext, node: PlaneNode, target?: PlaneBrepStructure, options?: MoldingBrepOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/PlaneCadStructure" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PathCurve2dStructure } from 'foundation/data/common/structure/geometric/curve2d/PathCurve2dStructure';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneCadStructure extends MoldingGeometryStructure {
        node: PlaneNode;
        origin: Vector3;
        xAxis: Vector3;
        yAxis: Vector3;
        zAxis: Vector3;
        xSize: number;
        ySize: number;
        zSize: number;
        polygon: PathCurve2dStructure;
    }
}
declare module "sk/rule/data/molding/PlaneCadConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneCadStructure } from "sk/rule/data/molding/PlaneCadStructure";
    export class PlaneCadConverter extends MoldingGraphics3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneCadStructure): PlaneCadStructure;
    }
}
declare module "sk/rule/data/molding/PlaneCollision2dConverter" {
    import { MoldingCollision2dConverter } from 'foundation/data/common/model/molding/MoldingCollision2dConverter';
    import { MoldingCollision2dOptions } from 'foundation/data/common/model/molding/MoldingCollision2dOptions';
    import { MoldingCollision2dStructure } from 'foundation/data/common/model/molding/MoldingCollision2dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneCollision2dConverter extends MoldingCollision2dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: MoldingCollision2dStructure, options?: MoldingCollision2dOptions): MoldingCollision2dStructure;
    }
}
declare module "sk/rule/data/molding/PlaneCollision3dConverter" {
    import { MoldingCollision3dConverter } from 'foundation/data/common/model/molding/MoldingCollision3dConverter';
    import { MoldingCollision3dOptions } from 'foundation/data/common/model/molding/MoldingCollision3dOptions';
    import { MoldingCollision3dStructure } from 'foundation/data/common/model/molding/MoldingCollision3dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneCollision3dConverter extends MoldingCollision3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: MoldingCollision3dStructure, options?: MoldingCollision3dOptions): MoldingCollision3dStructure;
    }
}
declare module "sk/rule/data/molding/PlaneGraphic2dConverter" {
    import { MoldingConverter } from 'foundation/core/module/molding/MoldingConverter';
    import { MoldingCollision2dOptions } from 'foundation/data/common/model/molding/MoldingCollision2dOptions';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneGraphic2dStructure } from 'sk/data/family/molding/instance/PlaneGraphic2dStructure';
    export class PlaneGraphic2dConverter extends MoldingConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneGraphic2dStructure, options?: MoldingCollision2dOptions): PlaneGraphic2dStructure;
    }
}
declare module "sk/rule/data/molding/PlaneGraphic3dConverter" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PathCurve2d } from 'foundation/runtime/geometry/curve2d/PathCurve2d';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { PathSolidMoldingOptions } from 'foundation/runtime/graphics/molding/path/PathSolidMoldingOptions';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    import { PlaneGraphic3dStructure } from 'sk/data/family/molding/instance/PlaneGraphic3dStructure';
    export class PlaneGraphic3dConverter extends MoldingGraphics3dConverter {
        constructor();
        createStructure(): PlaneGraphic3dStructure;
        computeSolid(node: PlaneNode): BufferGeometry;
        computeOutline(node: PlaneNode): BufferGeometry;
        protected computeSurfaceUV(surface: PlaneSurfaceNode): UVOptions;
        protected computeSideSurfaceUV(surface: EdgeSurfaceNode): PathSolidMoldingOptions;
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneGraphic3dStructure, options?: MoldingGeometricOptions): PlaneGraphic3dStructure;
        protected computeSectionWithArc(section: PathCurve2d, radius: number): PathCurve2d;
        protected interLineAndLine(beg1: Vector3, k1: Vector3, beg2: Vector3, k2: Vector3): Vector3;
        protected interSegAndCircle(lineBegin: Vector3, lineEnd: Vector3, circleCenter: Vector3, circleRadius: number): Vector3;
    }
}
declare module "sk/rule/data/molding/PlaneIpdStructure" {
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneIpdStructure extends MoldingGeometryStructure {
        node: PlaneNode;
    }
}
declare module "sk/rule/data/molding/PlaneIpdConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneCadStructure } from "sk/rule/data/molding/PlaneCadStructure";
    import { PlaneIpdStructure } from "sk/rule/data/molding/PlaneIpdStructure";
    export class PlaneIpdConverter extends MoldingGraphics3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneCadStructure): PlaneIpdStructure;
    }
}
declare module "sk/rule/data/molding/PlaneOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline2dConverter } from 'foundation/data/common/model/molding/MoldingOutline2dConverter';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneOutline2dConverter extends MoldingOutline2dConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: PlaneNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/PlaneOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneOutline3dConverter extends MoldingOutline3dConverter {
        static BORDER: number;
        constructor();
        process(context: MoldingDataContext, node: PlaneNode, target?: MoldingOutline3dStructure, options?: MoldingOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/PlaneRenderConverter" {
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneRenderStructure } from 'sk/data/family/molding/instance/PlaneRenderStructure';
    export class PlaneRenderConverter extends MoldingGraphics3dConverter {
        static BORDER: number;
        constructor();
        createStructure(): PlaneRenderStructure;
        computeSolid(node: PlaneNode): BufferGeometry;
        private computeSurfaceUV;
        private computeSideSurfaceUV;
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneRenderStructure, options?: MoldingGeometricOptions): PlaneRenderStructure;
    }
}
declare module "sk/rule/data/molding/PlaneTechCollisionConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneTechCalStructure } from 'sk/data/family/molding/instance/PlaneTechCalStructure';
    import { PlaneGraphic3dConverter } from "sk/rule/data/molding/PlaneGraphic3dConverter";
    export class PlaneTechCollisionConverter extends PlaneGraphic3dConverter {
        constructor();
        createStructure(): PlaneTechCalStructure;
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneTechCalStructure): PlaneTechCalStructure;
    }
}
declare module "sk/rule/data/molding/PlaneTechCoreConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneTechCalStructure } from 'sk/data/family/molding/instance/PlaneTechCalStructure';
    import { PlaneGraphic3dConverter } from "sk/rule/data/molding/PlaneGraphic3dConverter";
    export class PlaneTechCoreConverter extends PlaneGraphic3dConverter {
        constructor();
        createStructure(): PlaneTechCalStructure;
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneTechCalStructure): PlaneTechCalStructure;
    }
}
declare module "sk/rule/data/molding/PlaneTechCuttingConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneTechCalStructure } from 'sk/data/family/molding/instance/PlaneTechCalStructure';
    import { PlaneGraphic3dConverter } from "sk/rule/data/molding/PlaneGraphic3dConverter";
    export class PlaneTechCuttingConverter extends PlaneGraphic3dConverter {
        constructor();
        createStructure(): PlaneTechCalStructure;
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneTechCalStructure): PlaneTechCalStructure;
    }
}
declare module "sk/rule/data/molding/PlaneTechNominalConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneTechCalStructure } from 'sk/data/family/molding/instance/PlaneTechCalStructure';
    import { PlaneGraphic3dConverter } from "sk/rule/data/molding/PlaneGraphic3dConverter";
    export class PlaneTechNominalConverter extends PlaneGraphic3dConverter {
        constructor();
        createStructure(): PlaneTechCalStructure;
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneTechCalStructure): PlaneTechCalStructure;
    }
}
declare module "sk/rule/data/molding/PlaneTechRealConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneTechCalStructure } from 'sk/data/family/molding/instance/PlaneTechCalStructure';
    import { PlaneGraphic3dConverter } from "sk/rule/data/molding/PlaneGraphic3dConverter";
    export class PlaneTechRealConverter extends PlaneGraphic3dConverter {
        constructor();
        createStructure(): PlaneTechCalStructure;
        computeStructure(context: MoldingDataContext, node: PlaneNode, target?: PlaneTechCalStructure): PlaneTechCalStructure;
    }
}
declare module "sk/rule/data/molding/TechnologyCollision3dConverter" {
    import { MoldingCollision3dConverter } from 'foundation/data/common/model/molding/MoldingCollision3dConverter';
    import { MoldingCollision3dStructure } from 'foundation/data/common/model/molding/MoldingCollision3dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    export class TechnologyCollision3dConverter extends MoldingCollision3dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: TechnologyNode, target?: MoldingCollision3dStructure): MoldingCollision3dStructure;
    }
}
declare module "sk/rule/data/molding/technology/TechnologyCavityCollision3dConverter" {
    import { TechnologyCollision3dConverter } from "sk/rule/data/molding/TechnologyCollision3dConverter";
    export class TechnologyCavityCollision3dConverter extends TechnologyCollision3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/TechnologyGraphic3dOptions" {
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGradualColor } from 'foundation/data/common/model/molding/MoldingGradualColor';
    export class TechnologyGraphic3dOptions extends MoldingGeometricOptions {
        gradua: MoldingGradualColor;
        constructor(gradua?: MoldingGradualColor);
        isOptionOkey(other: TechnologyGraphic3dOptions): boolean;
    }
}
declare module "sk/rule/data/molding/TechnologyGraphic3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingConverter } from 'foundation/core/module/molding/MoldingConverter';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { TechnologyGraphic3dOptions } from "sk/rule/data/molding/TechnologyGraphic3dOptions";
    export class TechnologyGraphic3dConverter extends MoldingConverter {
        protected structure: MoldingGeometryStructure;
        createStructure(): MoldingGeometryStructure;
        constructor();
        process(context: MoldingContext, node: TechnologyNode, target?: MoldingGeometryStructure, options?: TechnologyGraphic3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/technology/TechnologyCavityGraphic3dConverter" {
    import { TechnologyGraphic3dConverter } from "sk/rule/data/molding/TechnologyGraphic3dConverter";
    export class TechnologyCavityGraphic3dConverter extends TechnologyGraphic3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/technology/TechnologyGrooveCollision3dConverter" {
    import { TechnologyCollision3dConverter } from "sk/rule/data/molding/TechnologyCollision3dConverter";
    export class TechnologyGrooveCollision3dConverter extends TechnologyCollision3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/technology/TechnologyGrooveGraphic3dConverter" {
    import { TechnologyGraphic3dConverter } from "sk/rule/data/molding/TechnologyGraphic3dConverter";
    export class TechnologyGrooveGraphic3dConverter extends TechnologyGraphic3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/technology/TechnologyHoleCollision3dConverter" {
    import { TechnologyCollision3dConverter } from "sk/rule/data/molding/TechnologyCollision3dConverter";
    export class TechnologyHoleCollision3dConverter extends TechnologyCollision3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/technology/TechnologyHoleGraphic3dConverter" {
    import { TechnologyGraphic3dConverter } from "sk/rule/data/molding/TechnologyGraphic3dConverter";
    export class TechnologyHoleGraphic3dConverter extends TechnologyGraphic3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/technology/TechnologyMillingCollision3dConverter" {
    import { TechnologyCollision3dConverter } from "sk/rule/data/molding/TechnologyCollision3dConverter";
    export class TechnologyMillingCollision3dConverter extends TechnologyCollision3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/technology/TechnologyMillingGraphic3dConverter" {
    import { TechnologyGraphic3dConverter } from "sk/rule/data/molding/TechnologyGraphic3dConverter";
    export class TechnologyMillingGraphic3dConverter extends TechnologyGraphic3dConverter {
        constructor();
    }
}
declare module "sk/rule/data/molding/TechnologyCollision2dConverter" {
    import { MoldingCollision2dConverter } from 'foundation/data/common/model/molding/MoldingCollision2dConverter';
    import { MoldingCollision2dOptions } from 'foundation/data/common/model/molding/MoldingCollision2dOptions';
    import { MoldingCollision2dStructure } from 'foundation/data/common/model/molding/MoldingCollision2dStructure';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    export class TechnologyCollision2dConverter extends MoldingCollision2dConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: TechnologyNode, target?: MoldingCollision2dStructure, options?: MoldingCollision2dOptions): MoldingCollision2dStructure;
    }
}
declare module "sk/rule/data/molding/TechnologyCollisionTechConverter" {
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingTechCollisionConverter } from 'foundation/data/common/model/molding/MoldingTechCollisionConverter';
    import { MoldingTechCollisionStructure } from 'foundation/data/common/model/molding/MoldingTechCollisionStructure';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    export class TechnologyCollisionTechConverter extends MoldingTechCollisionConverter {
        constructor();
        computeStructure(context: MoldingDataContext, node: TechnologyNode, target?: MoldingTechCollisionStructure): MoldingTechCollisionStructure;
    }
}
declare module "sk/rule/data/molding/TechnologyOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline2dConverter } from 'foundation/data/common/model/molding/MoldingOutline2dConverter';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    export class TechnologyOutline2dConverter extends MoldingOutline2dConverter {
        constructor();
        process(context: MoldingContext, node: TechnologyNode, target?: MoldingOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/TechnologyOutline3dOptions" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { MoldingGradualColor } from 'foundation/data/common/model/molding/MoldingGradualColor';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    export class TechnologyOutline3dOptions extends MoldingOutline3dOptions {
        gradua: MoldingGradualColor;
        constructor(proj?: Matrix4, isOnlyLocal?: boolean, isOnlyCurve?: boolean, gradua?: MoldingGradualColor);
    }
}
declare module "sk/rule/data/molding/TechnologyOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { TechnologyOutline3dOptions } from "sk/rule/data/molding/TechnologyOutline3dOptions";
    export class TechnologyOutline3dConverter extends MoldingOutline3dConverter {
        constructor();
        process(context: MoldingContext, node: TechnologyNode, target?: MoldingOutline3dStructure, options?: TechnologyOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/VisionGridModelGraphic3dConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'cross/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingExtraData } from 'foundation/core/module/molding/MoldingExtraData';
    import { VisionGridModelNode } from 'foundation/data/common/model/brep/vision/VisionGridModelNode';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { VisionGridModelGraphic3dOptions } from 'foundation/data/common/model/molding/VisionGridModelGraphic3dOptions';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    enum UVType {
        Default = 0,
        SampleUVTiling = 1,
        AUVTiles = 2
    }
    export class VisionGridModelGraphic3dConverter extends MoldingGraphics3dConverter {
        protected entity: VisionGridModelNode;
        protected originModelBufferGeometry: BufferGeometry;
        protected originModelId: string;
        protected uvlayoutType: UVType;
        private _bufferGeometryList;
        protected _modelDocumentService: ModelDocumentService;
        constructor();
        createStructure(): MoldingGeometryStructure;
        protected prepareProcessAsyncImplAsync(context: MoldingDataContext, content: any, options?: VisionGridModelGraphic3dOptions): Promise<ResultObject<MoldingExtraData>>;
        computeStructure(context: MoldingDataContext, node: VisionGridModelNode, target?: MoldingGeometryStructure, options?: VisionGridModelGraphic3dOptions): MoldingGeometryStructure;
        protected postProcessMesh(mesh: BufferGeometry): BufferGeometry;
        protected reclipMesh(): void;
        private isClipParameterOK;
        protected updateMeshSize(): BufferGeometry;
        protected generateTriPlanarUVs(mesh: BufferGeometry, u_offset?: number, v_offset?: number, u_scale?: number, v_scale?: number, angleRadians?: number): void;
        protected calculateUVs(postion: Vector3, normal: Vector3): Vector2;
        protected flipX(mesh: BufferGeometry): BufferGeometry;
        protected flipY(mesh: BufferGeometry): BufferGeometry;
        protected flipZ(mesh: BufferGeometry): BufferGeometry;
    }
}
declare module "sk/rule/data/molding/VisionLinearLineModelGraphic3dConverter" {
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingOutline3dConverter } from 'foundation/data/common/model/molding/MoldingOutline3dConverter';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    import { LinearLineCurve3dNode } from 'sk/data/family/model/instance/LinearLineCurve3dNode';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    export class VisionLinearLineModelGraphic3dConverter extends MoldingOutline3dConverter {
        protected entity: LinearLineCurve3dNode;
        protected originModelBufferGeometry: BufferGeometry;
        protected originModelId: string;
        private _bufferGeometryList;
        protected _modelDocumentService: ModelDocumentService;
        protected _beginModel: BufferGeometry;
        protected _middleModel: BufferGeometry;
        protected _endModel: BufferGeometry;
        protected _beginModelBox: BoxSolid;
        protected _middleModelBox: BoxSolid;
        protected _endModelBox: BoxSolid;
        constructor();
        computeStructure(context: MoldingDataContext, node: LinearLineCurve3dNode, target?: MoldingOutline3dStructure, options?: MoldingOutline3dOptions): MoldingOutline3dStructure;
    }
}
declare module "sk/rule/data/molding/VisionLineModelGraphic3dConverter" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingExtraData } from 'foundation/core/module/molding/MoldingExtraData';
    import { VisionLineModelNode } from 'foundation/data/common/model/brep/vision/VisionLineModelNode';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometricOptions } from 'foundation/data/common/model/molding/MoldingGeometricOptions';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { MoldingGraphics3dConverter } from 'foundation/data/common/model/molding/MoldingGraphics3dConverter';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    export class VisionLineModelGraphic3dConverter extends MoldingGraphics3dConverter {
        protected entity: VisionLineModelNode;
        protected originModelBufferGeometry: BufferGeometry;
        protected originModelId: string;
        private _bufferGeometryList;
        protected _modelDocumentService: ModelDocumentService;
        protected _beginModel: BufferGeometry;
        protected _middleModel: BufferGeometry;
        protected _endModel: BufferGeometry;
        protected _beginModelBox: BoxSolid;
        protected _middleModelBox: BoxSolid;
        protected _endModelBox: BoxSolid;
        constructor();
        createStructure(): MoldingGeometryStructure;
        protected prepareProcessAsyncImplAsync(context: MoldingDataContext, content: any, options?: MoldingGeometricOptions): Promise<ResultObject<MoldingExtraData>>;
        computeStructure(context: MoldingDataContext, node: VisionLineModelNode, target?: MoldingGeometryStructure, options?: MoldingGeometricOptions): MoldingGeometryStructure;
        protected checkShapeParameters(paraType: string, logout?: boolean): boolean;
        computeNewBufferGeometryByBBox(bg: BufferGeometry, bgLocalBox: BoxSolid, destBox: BoxSolid, clipRatio?: number): BufferGeometry;
        private validateBoxSize;
        splitBoxes(originBox: BoxSolid, lengthBegin: number, lengthMiddle: number, lengthEnd: number): {
            beginBox: BoxSolid;
            endBox: BoxSolid;
            middleBoxes: BoxSolid[];
        };
        sliceGeometryByRatio(bg: BufferGeometry, bgBox: BoxSolid, ratio: number): BufferGeometry;
    }
}
declare module "sk/rule/data/molding/WareNodeCollisionTechConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingConverter } from 'foundation/core/module/molding/MoldingConverter';
    import { MoldingDataContext } from 'foundation/data/common/model/molding/MoldingDataContext';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    export class WareNodeCollisionTechConverter extends MoldingConverter {
        constructor();
        createStructure(): MoldingGeometryStructure;
        computeStructure(context: MoldingDataContext, node: WareNode, target?: MoldingGeometryStructure): MoldingGeometryStructure;
        process(context: MoldingDataContext, content: any, target?: any, options?: any): ResultEnum;
    }
}
declare module "sk/rule/data/molding/WareNodeOutline2dStructure" {
    import { MoldingOutline2dStructure } from 'foundation/data/common/model/molding/MoldingOutline2dStructure';
    export class WareNodeOutline2dStructure extends MoldingOutline2dStructure {
    }
}
declare module "sk/rule/data/molding/WareNodeOutline2dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline2dOptions } from 'foundation/data/common/model/molding/MoldingOutline2dOptions';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { FamilyInstanceOutline2dConverter } from "sk/rule/data/molding/FamilyInstanceOutline2dConverter";
    import { WareNodeOutline2dStructure } from "sk/rule/data/molding/WareNodeOutline2dStructure";
    export class WareNodeOutline2dConverter extends FamilyInstanceOutline2dConverter {
        constructor();
        process(context: MoldingContext, node: WareNode, target?: WareNodeOutline2dStructure, options?: MoldingOutline2dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/molding/WareNodeOutline3dStructure" {
    import { MoldingOutline3dStructure } from 'foundation/data/common/model/molding/MoldingOutline3dStructure';
    export class WareNodeOutline3dStructure extends MoldingOutline3dStructure {
    }
}
declare module "sk/rule/data/molding/WareNodeOutline3dConverter" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MoldingContext } from 'foundation/core/module/molding/MoldingContext';
    import { MoldingOutline3dOptions } from 'foundation/data/common/model/molding/MoldingOutline3dOptions';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { FamilyInstanceOutline3dConverter } from "sk/rule/data/molding/FamilyInstanceOutline3dConverter";
    import { WareNodeOutline3dStructure } from "sk/rule/data/molding/WareNodeOutline3dStructure";
    export class WareNodeOutline3dConverter extends FamilyInstanceOutline3dConverter {
        constructor();
        process(context: MoldingContext, node: WareNode, target?: WareNodeOutline3dStructure, options?: MoldingOutline3dOptions): ResultEnum;
    }
}
declare module "sk/rule/data/pattern/process/AssembleLevelingCeilingPatternRuleProcess" {
    import { PatternRuleProcesResult } from 'sk/data/family/pattern/process/PatternRuleProcesResult';
    import { PatternRuleProcess } from 'sk/data/family/pattern/process/PatternRuleProcess';
    import { PatternRuleProcessContext } from 'sk/data/family/pattern/process/PatternRuleProcessContext';
    import { PatternRuleProcessInput } from 'sk/data/family/pattern/process/PatternRuleProcessInput';
    import { PatternRuleProcessOutput } from 'sk/data/family/pattern/process/PatternRuleProcessOutput';
    export class AssembleLevelingCeilingPatternRuleProcess extends PatternRuleProcess {
        processAsync(context: PatternRuleProcessContext, input: PatternRuleProcessInput, output: PatternRuleProcessOutput): Promise<PatternRuleProcesResult>;
    }
}
declare module "sk/rule/data/pattern/process/BathroomFloorDryPatternRuleProcess" {
    import { PatternRuleProcesResult } from 'sk/data/family/pattern/process/PatternRuleProcesResult';
    import { PatternRuleProcess } from 'sk/data/family/pattern/process/PatternRuleProcess';
    import { PatternRuleProcessContext } from 'sk/data/family/pattern/process/PatternRuleProcessContext';
    import { PatternRuleProcessInput } from 'sk/data/family/pattern/process/PatternRuleProcessInput';
    import { PatternRuleProcessOutput } from 'sk/data/family/pattern/process/PatternRuleProcessOutput';
    export class BathroomFloorDryPatternRuleProcess extends PatternRuleProcess {
        processAsync(context: PatternRuleProcessContext, input: PatternRuleProcessInput, output: PatternRuleProcessOutput): Promise<PatternRuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/BathroomData" {
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    export type BathroomHardwareInfo = {
        floorConnectorFamilyId: string;
        floorConnectorFamilyInfo?: ISpecificationFamilyInfo;
    };
    export class BathroomHardwareData {
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        familyInfo: ISpecificationFamilyInfo;
    }
    export class BathroomData {
        hardwareInfo: BathroomHardwareInfo;
        x: number;
        y: number;
        z: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        hardwares: BathroomHardwareData[];
        constructor();
    }
}
declare module "sk/rule/data/pattern/process/BathroomPatternRuleProcess" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { PatternRuleProcesResult } from 'sk/data/family/pattern/process/PatternRuleProcesResult';
    import { PatternRuleProcess } from 'sk/data/family/pattern/process/PatternRuleProcess';
    import { PatternRuleProcessContext } from 'sk/data/family/pattern/process/PatternRuleProcessContext';
    import { PatternRuleProcessInput } from 'sk/data/family/pattern/process/PatternRuleProcessInput';
    import { PatternRuleProcessOutput } from 'sk/data/family/pattern/process/PatternRuleProcessOutput';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { BathroomData } from "sk/rule/data/rule/bathroomlayout/BathroomData";
    export class BathroomPatternRuleProcess extends PatternRuleProcess {
        protected _schemeConfigService: SchemeConfigService;
        processAsync(context: PatternRuleProcessContext, input: PatternRuleProcessInput, output: PatternRuleProcessOutput): Promise<PatternRuleProcesResult>;
        buildStructureAsync(context: ElementPerformerContext, element: AssembleBathroomElement, data: BathroomData): Promise<ResultObject>;
        createElementAsync(context: ElementPerformerContext, element: AssembleBathroomElement, data: BathroomData): Promise<ResultObject>;
        computeFloorConnectorDataAsync(context: ElementPerformerContext, element: AssembleBathroomElement, data: BathroomData): Promise<ResultObject>;
        loadFamilyInfoAsync(context: ElementPerformerContext, element: AssembleBathroomElement, data: BathroomData): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/pattern/process/BathroomWallStructureCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomWallElement } from 'sk/data/scheme/database/pattern/element/BathroomWallElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { BathroomWallData, BathroomWallHardwareData, BathroomWallHoleData, BathroomWallPlankData } from "sk/rule/data/rule/bathroomlayout/bathroomwall/BathroomWallData";
    export class BathroomWallStructureCalculator {
        private static HOLE_WIDTH;
        private static HOLE_HEIGHT;
        private static DEFAULT_HARDWARE_OFFSET;
        private static DEFAULT_HARDWARE_MIN_LENGTH;
        private static BATHROOM_WALL_RANGECODE;
        protected static _schemeConfigService: SchemeConfigService;
        static buildAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
        static computeAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
        static computePlankCenterHardwareAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
        static createAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
        static createHardwareElementAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, hardwareData: BathroomWallHardwareData): Promise<ResultObject>;
        static createFloorWetSideHoleElementAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallHoleData: BathroomWallHoleData): Promise<ResultObject>;
        static computeFloorHardwareAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
        static computeFloorWetSideHoleAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
        static computeCornerHardwareAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
        static computeCornerHardwareByWalls(remain: BathroomWallElement, other: BathroomWallElement, wallData: BathroomWallData, otherType: "left" | "right"): void;
        static getCutInfoByPlankDatas(leftPlankData: BathroomWallPlankData, rightPlankData: BathroomWallPlankData): {
            x: number;
            y: number;
            height: number;
        };
        static getCutInfosByWallElements(leftWall: BathroomWallElement, rightWall: BathroomWallElement): {
            y: number;
            height: number;
        }[];
        static loadFamilyInfoAsync(context: ElementPerformerContext, wallElement: BathroomWallElement, wallData: BathroomWallData): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/pattern/process/BathroomWallPatternRuleProcess" {
    import { PatternRuleProcesResult } from 'sk/data/family/pattern/process/PatternRuleProcesResult';
    import { PatternRuleProcess } from 'sk/data/family/pattern/process/PatternRuleProcess';
    import { PatternRuleProcessContext } from 'sk/data/family/pattern/process/PatternRuleProcessContext';
    import { PatternRuleProcessInput } from 'sk/data/family/pattern/process/PatternRuleProcessInput';
    import { PatternRuleProcessOutput } from 'sk/data/family/pattern/process/PatternRuleProcessOutput';
    export class BathroomWallPatternRuleProcess extends PatternRuleProcess {
        processAsync(context: PatternRuleProcessContext, input: PatternRuleProcessInput, output: PatternRuleProcessOutput): Promise<PatternRuleProcesResult>;
    }
}
declare module "sk/rule/data/performer/InstanceElementPerformer" {
    import { NestElementPerformer } from "sk/rule/data/performer/NestElementPerformer";
    export class InstanceElementPerformer extends NestElementPerformer {
    }
}
declare module "sk/rule/data/performer/brep/BrepElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { InstanceElementPerformer } from "sk/rule/data/performer/InstanceElementPerformer";
    export class BrepElementPerformer extends InstanceElementPerformer {
        protected _schemeConfigService: SchemeConfigService;
        buildElementAsync(context: ElementPerformerContext, containerElement: BrepElement, element: BrepElement, parameters?: any): Promise<ResultObject>;
        computeElementProperty(context: ElementPerformerContext, source: BrepElement, target: BrepElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: BrepElement, node: BrepNode): void;
        computeProperty(context: ElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        computeBindingValues(context: ElementPerformerContext, element: BrepElement, node: BrepNode): ResultEnum;
        computePropertyAfter(context: ElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        computeConfigure(context: ElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        private getConditionValue;
        computeCondition(context: ElementPerformerContext, element: BrepElement, node: BrepNode, parameters?: any): ResultEnum;
        computeShapeMolding(context: ElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
        computeShapeBoundary(context: ElementPerformerContext, element: BrepElement, index: number, node: BrepNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/reference/AssistantElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AssistantElement } from 'sk/data/family/element/assistant/AssistantElement';
    import { AssistantNode } from 'sk/data/family/model/assistant/AssistantNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class AssistantElementPerformer extends BrepElementPerformer {
        computeProperty(context: ElementPerformerContext, element: AssistantElement, index: number, node: AssistantNode): ResultEnum;
        computeLocalMatrix(node: AssistantNode): void;
        computeShapeMatrix(context: ElementPerformerContext, element: AssistantElement, index: number, node: AssistantNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/assistant/AnchorElementPerformer" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { AnchorElement } from 'sk/data/family/element/assistant/AnchorElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { AnchorNode } from 'sk/data/family/model/assistant/AnchorNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class AnchorElementPerformer extends AssistantElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AnchorElement): AnchorElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: AnchorElement): AnchorNode;
        computeElementProperty(context: ElementPerformerContext, source: AnchorElement, target: AnchorElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: AnchorElement, node: AnchorNode): void;
        computeLocalMatrix(node: AnchorNode): Matrix3d;
    }
}
declare module "sk/rule/data/performer/assistant/DistanceDimensionElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { DistanceDimensionElement } from 'sk/data/family/element/assistant/dimension/DistanceDimensionElement';
    import { DistanceDimensionNode } from 'sk/data/family/model/assistant/dimension/DistanceDimensionNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { InstanceElementPerformer } from "sk/rule/data/performer/InstanceElementPerformer";
    export class DistanceDimensionElementPerformer extends InstanceElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: DistanceDimensionElement): DistanceDimensionElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: DistanceDimensionElement): DistanceDimensionNode;
        computeStructureChildren(context: ElementPerformerContext, element: DistanceDimensionElement, node: DistanceDimensionNode): ResultEnum;
        computeStructureChildrenAsync(context: ElementPerformerContext, element: DistanceDimensionElement, node: DistanceDimensionNode): Promise<ElementPerformerResult>;
        computeStructureAfter(context: ElementPerformerContext, element: DistanceDimensionElement, node: DistanceDimensionNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/assistant/SpatialTagElementPerformer" {
    import { SpatialTagElement } from 'sk/data/family/element/assistant/tag/SpatialTagElement';
    import { SpatialTagNode } from 'sk/data/family/model/assistant/tag/SpatialTagNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class SpatialTagElementPerformer extends AssistantElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SpatialTagElement): SpatialTagElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: SpatialTagElement): SpatialTagNode;
    }
}
declare module "sk/rule/data/performer/brep/VertexElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { VertexElement } from 'sk/data/family/element/brep/VertexElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class VertexElementPerformer extends BrepElementPerformer {
        computeElementProperty(context: ElementPerformerContext, source: VertexElement, target: VertexElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: VertexElement, node: VertexNode): void;
        computeProperty(context: ElementPerformerContext, element: VertexElement, index: number, node: VertexNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: VertexElement, index: number, node: VertexNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/SpatialElementPerformer" {
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { SpatialElement } from 'sk/data/family/element/brep/SpatialElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { VertexElementPerformer } from "sk/rule/data/performer/brep/VertexElementPerformer";
    export class SpatialElementPerformer extends VertexElementPerformer {
        computeElementProperty(context: ElementPerformerContext, source: SpatialElement, target: SpatialElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: SpatialElement, node: SpatialNode): void;
        computeLocalMatrix(context: ElementPerformerContext, node: SpatialNode): void;
    }
}
declare module "sk/rule/data/performer/brep/ContentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SpatialElementPerformer } from "sk/rule/data/performer/brep/SpatialElementPerformer";
    export class ContentElementPerformer extends SpatialElementPerformer {
        computeElementProperty(context: ElementPerformerContext, source: ContentElement, target: ContentElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: ContentElement, node: ContentNode): void;
        computeProperty(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        protected computeOctreeNode(node: ContentNode): void;
        computeLocalMatrix(context: ElementPerformerContext, node: ContentNode): void;
        computeShapeClippingPrepare(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeClippingApply(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeMatrixImpl(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeMolding(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShapeBoundary(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
        computeShape(context: ElementPerformerContext, element: ContentElement, index: number, node: ContentNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/area/AreaHoleElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AreaHoleElement } from 'sk/data/family/element/brep/area/AreaHoleElement';
    import { AreaHoleNode } from 'sk/data/family/model/brep/area/AreaHoleNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class AreaHoleElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AreaHoleElement): AreaHoleNode;
        computeShapeMatrix(context: ElementPerformerContext, element: AreaHoleElement, index: number, node: AreaHoleNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: AreaHoleElement, node: AreaHoleNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/area/AreaLineElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AreaLineElement } from 'sk/data/family/element/brep/area/AreaLineElement';
    import { AreaLineNode } from 'sk/data/family/model/brep/area/AreaLineNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class AreaLineElementPerformer extends BrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AreaLineElement): AreaLineNode;
        computeShape(context: ElementPerformerContext, element: AreaLineElement, index: number, node: AreaLineNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: AreaLineElement, index: number, node: AreaLineNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/area/AreaPointElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AreaPointElement } from 'sk/data/family/element/brep/area/AreaPointElement';
    import { AreaPointNode } from 'sk/data/family/model/brep/area/AreaPointNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { VertexElementPerformer } from "sk/rule/data/performer/brep/VertexElementPerformer";
    export class AreaPointElementPerformer extends VertexElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AreaPointElement): AreaPointNode;
        computeShapeMatrix(context: ElementPerformerContext, element: AreaPointElement, index: number, node: AreaPointNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/area/AreaPolygonElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AreaPolygonElement } from 'sk/data/family/element/brep/area/AreaPolygonElement';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class AreaPolygonElementPerformer extends ContentInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AreaPolygonElement): AreaPolygonNode;
        computeShapeMatrix(context: ElementPerformerContext, element: AreaPolygonElement, index: number, node: AreaPolygonNode): ResultEnum;
        computeProperty(context: SchemeElementPerformerContext, element: AreaPolygonElement, index: number, node: AreaPolygonNode): ResultEnum;
        buildElementAsync(context: SchemeElementPerformerContext, element: AreaPolygonElement, componentElement: BrepElement, parameter?: any): Promise<ResultObject>;
        updateSurfaceElementDecorate(element: AreaPolygonElement, parent?: BrepElement): void;
        computeStructureBefore(context: ElementPerformerContext, element: AreaPolygonElement, node: AreaPolygonNode): ResultEnum;
        computeStructureAfterAsync(context: ElementPerformerContext, element: AreaPolygonElement, node: AreaPolygonNode): Promise<ResultObject>;
        computeStructureAfter(context: ElementPerformerContext, element: AreaPolygonElement, node: AreaPolygonNode): ResultEnum;
        protected setAreaPolygonMaterialIdAsync(context: ElementPerformerContext, element: AreaPolygonElement, node: AreaPolygonNode): Promise<void>;
    }
}
declare module "sk/rule/data/performer/brep/geometric/CurveElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CurveElement } from 'sk/data/family/element/brep/geometric/CurveElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class CurveElementPerformer extends BrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CurveElement): any;
        processInstance(context: ElementPerformerContext, element: CurveElement): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/drawing/CircleArc2Curve2dDrawingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleArc2Curve2dDrawingElement } from 'sk/data/family/element/brep/drawing/curve2d/CircleArc2Curve2dDrawingElement';
    import { CircleArc2Curve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/CircleArc2Curve2dDrawingNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CurveElementPerformer } from "sk/rule/data/performer/brep/geometric/CurveElementPerformer";
    export class CircleArc2Curve2dDrawingElementPerformer extends CurveElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CircleArc2Curve2dDrawingElement): CircleArc2Curve2dDrawingElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CircleArc2Curve2dDrawingElement): CircleArc2Curve2dDrawingNode;
        buildElementReleation(context: ElementPerformerContext, element: CircleArc2Curve2dDrawingElement): void;
        computeElementProperty(context: ElementPerformerContext, source: any, target: any): void;
        processInstance(context: ElementPerformerContext, element: CircleArc2Curve2dDrawingElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: CircleArc2Curve2dDrawingElement, index: number, node: CircleArc2Curve2dDrawingNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/drawing/CircleCurve2dDrawingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleCurve2dDrawingElement } from 'sk/data/family/element/brep/drawing/curve2d/CircleCurve2dDrawingElement';
    import { CircleCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/CircleCurve2dDrawingNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CurveElementPerformer } from "sk/rule/data/performer/brep/geometric/CurveElementPerformer";
    export class CircleCurve2dDrawingElementPerformer extends CurveElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CircleCurve2dDrawingElement): CircleCurve2dDrawingNode;
        processInstance(context: ElementPerformerContext, element: CircleCurve2dDrawingElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: CircleCurve2dDrawingElement, index: number, node: CircleCurve2dDrawingNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/drawing/LineCurve2dDrawingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { LineCurve2dDrawingElement } from 'sk/data/family/element/brep/drawing/curve2d/LineCurve2dDrawingElement';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { CurveElementPerformer } from "sk/rule/data/performer/brep/geometric/CurveElementPerformer";
    export class LineCurve2dDrawingElementPerformer extends CurveElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LineCurve2dDrawingElement): LineCurve2dDrawingElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LineCurve2dDrawingElement): LineCurve2dDrawingNode;
        processInstance(context: ElementPerformerContext, element: LineCurve2dDrawingElement): ResultEnum;
        buildElementReleation(context: SchemeElementPerformerContext, element: LineCurve2dDrawingElement): void;
        computeProperty(context: ElementPerformerContext, element: LineCurve2dDrawingElement, index: number, node: LineCurve2dDrawingNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: LineCurve2dDrawingElement, node: LineCurve2dDrawingNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/drawing/PointDrawingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PointDrawingElement } from 'sk/data/family/element/brep/drawing/PointDrawingElement';
    import { PointDrawingNode } from 'sk/data/family/model/brep/drawing/PointDrawingNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { VertexElementPerformer } from "sk/rule/data/performer/brep/VertexElementPerformer";
    export class PointDrawingElementPerformer extends VertexElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: PointDrawingElement): PointDrawingNode;
        processInstance(context: ElementPerformerContext, element: PointDrawingElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: PointDrawingElement, index: number, node: PointDrawingNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/BoxSolidElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BoxSolidNode } from 'foundation/data/common/model/brep/geometric/solid/BoxSolidNode';
    import { BoxSolidElement } from 'sk/data/family/element/brep/geometric/solid/BoxSolidElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SpatialElementPerformer } from "sk/rule/data/performer/brep/SpatialElementPerformer";
    export class BoxSolidElementPerformer extends SpatialElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: BoxSolidElement): BoxSolidNode;
        computeProperty(context: ElementPerformerContext, element: BoxSolidElement, index: number, node: BoxSolidNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer" {
    import { Curve2dElement } from 'sk/data/family/element/brep/geometric/Curve2dElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CurveElementPerformer } from "sk/rule/data/performer/brep/geometric/CurveElementPerformer";
    export class Curve2dElementPerformer extends CurveElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: Curve2dElement): any;
    }
}
declare module "sk/rule/data/performer/brep/geometric/CircleArc2Curve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleArc2Curve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/CircleArc2Curve2dNode';
    import { CircleArc2Curve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArc2Curve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class CircleArc2Curve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CircleArc2Curve2dElement): CircleArc2Curve2dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CircleArc2Curve2dElement): CircleArc2Curve2dNode;
        buildElementReleation(context: ElementPerformerContext, element: CircleArc2Curve2dElement): void;
        processInstance(context: ElementPerformerContext, element: CircleArc2Curve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: CircleArc2Curve2dElement, node: CircleArc2Curve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: CircleArc2Curve2dElement, index: number, node: CircleArc2Curve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: CircleArc2Curve2dElement, node: CircleArc2Curve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/CircleArc2Curve3dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleArc2Curve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/CircleArc2Curve3dNode';
    import { CircleArc2Curve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/CircleArc2Curve3dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class CircleArc2Curve3dElementPerformer extends BrepElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CircleArc2Curve3dElement): CircleArc2Curve3dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CircleArc2Curve3dElement): CircleArc2Curve3dNode;
        buildElementReleation(context: ElementPerformerContext, element: CircleArc2Curve3dElement): void;
        processInstance(context: ElementPerformerContext, element: CircleArc2Curve3dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: CircleArc2Curve3dElement, node: CircleArc2Curve3dNode): void;
        computeProperty(context: ElementPerformerContext, element: CircleArc2Curve3dElement, index: number, node: CircleArc2Curve3dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: CircleArc2Curve3dElement, node: CircleArc2Curve3dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/CircleArc3Curve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleArc3Curve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/CircleArc3Curve2dNode';
    import { CircleArc3Curve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArc3Curve2dElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class CircleArc3Curve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CircleArc3Curve2dElement): CircleArc3Curve2dNode;
        processInstance(context: ElementPerformerContext, element: CircleArc3Curve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: CircleArc3Curve2dElement, node: CircleArc3Curve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: CircleArc3Curve2dElement, index: number, node: CircleArc3Curve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: CircleArc3Curve2dElement, node: CircleArc3Curve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/CircleArcCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleArcCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/CircleArcCurve2dNode';
    import { CircleArcCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleArcCurve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class CircleArcCurve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CircleArcCurve2dElement): CircleArcCurve2dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CircleArcCurve2dElement): CircleArcCurve2dNode;
        buildElementReleation(context: ElementPerformerContext, element: CircleArcCurve2dElement): void;
        processInstance(context: ElementPerformerContext, element: CircleArcCurve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: CircleArcCurve2dElement, node: CircleArcCurve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: CircleArcCurve2dElement, index: number, node: CircleArcCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: CircleArcCurve2dElement, node: CircleArcCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/CircleCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/CircleCurve2dNode';
    import { CircleCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/CircleCurve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class CircleCurve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CircleCurve2dElement): CircleCurve2dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CircleCurve2dElement): CircleCurve2dNode;
        processInstance(context: ElementPerformerContext, element: CircleCurve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: CircleCurve2dElement, node: CircleCurve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: CircleCurve2dElement, index: number, node: CircleCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: CircleCurve2dElement, node: CircleCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/EllipseArcCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { EllipseArcCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/EllipseArcCurve2dNode';
    import { EllipseArcCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/EllipseArcCurve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class EllipseArcCurve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: EllipseArcCurve2dElement): EllipseArcCurve2dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: EllipseArcCurve2dElement): EllipseArcCurve2dNode;
        processInstance(context: ElementPerformerContext, element: EllipseArcCurve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: EllipseArcCurve2dElement, node: EllipseArcCurve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: EllipseArcCurve2dElement, index: number, node: EllipseArcCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: EllipseArcCurve2dElement, node: EllipseArcCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/EllipseCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { EllipseCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/EllipseCurve2dNode';
    import { EllipseCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/EllipseCurve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class EllipseCurve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: EllipseCurve2dElement): EllipseCurve2dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: EllipseCurve2dElement): EllipseCurve2dNode;
        processInstance(context: ElementPerformerContext, element: EllipseCurve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: EllipseCurve2dElement, node: EllipseCurve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: EllipseCurve2dElement, index: number, node: EllipseCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: EllipseCurve2dElement, node: EllipseCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/EllipsoidSolidElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { EllipsoidSolidNode } from 'foundation/data/common/model/brep/geometric/solid/EllipsoidSolidNode';
    import { EllipsoidSolidElement } from 'sk/data/family/element/brep/geometric/solid/EllipsoidSolidElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SpatialElementPerformer } from "sk/rule/data/performer/brep/SpatialElementPerformer";
    export class EllipsoidSolidElementPerformer extends SpatialElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: EllipsoidSolidElement): EllipsoidSolidNode;
        computeProperty(context: ElementPerformerContext, element: EllipsoidSolidElement, index: number, node: EllipsoidSolidNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/LineCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { LineCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/LineCurve2dNode';
    import { LineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/LineCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class LineCurveElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LineCurve2dElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LineCurve2dElement): LineCurve2dNode;
        buildElementReleation(context: ElementPerformerContext, element: LineCurve2dElement): void;
        processInstance(context: ElementPerformerContext, element: LineCurve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: LineCurve2dElement, node: LineCurve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: LineCurve2dElement, index: number, node: LineCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: LineCurve2dElement, node: LineCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/LineCurve3dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { LineCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/LineCurve3dNode';
    import { LineCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/LineCurve3dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CurveElementPerformer } from "sk/rule/data/performer/brep/geometric/CurveElementPerformer";
    export class LineCurve3dElementPerformer extends CurveElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LineCurve3dElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LineCurve3dElement): LineCurve3dNode;
        buildElementReleation(context: ElementPerformerContext, element: LineCurve3dElement): void;
        processInstance(context: ElementPerformerContext, element: LineCurve3dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: LineCurve3dElement, node: LineCurve3dNode): void;
        computeProperty(context: ElementPerformerContext, element: LineCurve3dElement, index: number, node: LineCurve3dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: LineCurve3dElement, node: LineCurve3dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/NurbsCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NurbsCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/NurbsCurve2dNode';
    import { NurbsCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/NurbsCurve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class NurbsCurve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: NurbsCurve2dElement): NurbsCurve2dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: NurbsCurve2dElement): NurbsCurve2dNode;
        processInstance(context: ElementPerformerContext, element: NurbsCurve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: NurbsCurve2dElement, node: NurbsCurve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: NurbsCurve2dElement, index: number, node: NurbsCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: NurbsCurve2dElement, node: NurbsCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/PathCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PathCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/PathCurve2dNode';
    import { PathCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PathCurve2dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class PathElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PathCurve2dElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PathCurve2dElement): PathCurve2dNode;
        processInstance(context: ElementPerformerContext, element: PathCurve2dElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: PathCurve2dElement, index: number, node: PathCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: PathCurve2dElement, node: PathCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/PathCurve3dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PathCurve3dNode } from 'foundation/data/common/model/brep/geometric/curve3d/PathCurve3dNode';
    import { PathCurve3dElement } from 'sk/data/family/element/brep/geometric/curve3d/PathCurve3dElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CurveElementPerformer } from "sk/rule/data/performer/brep/geometric/CurveElementPerformer";
    export class PathCurve3dElementPerformer extends CurveElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PathCurve3dElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PathCurve3dElement): PathCurve3dNode;
        processInstance(context: ElementPerformerContext, element: PathCurve3dElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: PathCurve3dElement, index: number, node: PathCurve3dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: PathCurve3dElement, node: PathCurve3dNode): ResultEnum;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementShapePlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementShapePlain extends WorkflowPlainProcess implements IElementTraversal {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/performer/brep/geometric/PointElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { PointElement } from 'sk/data/family/element/brep/geometric/PointElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { VertexElementPerformer } from "sk/rule/data/performer/brep/VertexElementPerformer";
    export class PointElementPerformer extends VertexElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PointElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PointElement): PointNode;
        processInstance(context: ElementPerformerContext, element: PointElement): ResultEnum;
        protected testIsSkipCompute(context: ElementPerformerContext, element: PointElement, defaultValue?: boolean): boolean;
        computeShapeMatrix(context: ElementPerformerContext, element: PointElement, index: number, node: PointNode): ResultEnum;
        computeShape(context: ElementPerformerContext, element: PointElement, index: number, node: PointNode): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: PointElement, index: number, node: PointNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/PolygonCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PolygonCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/PolygonCurve2dNode';
    import { PolygonCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PolygonCurve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class PolygonCurve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PolygonCurve2dElement): PolygonCurve2dElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): PolygonCurve2dNode;
        computePropertyTransform(context: ElementPerformerContext, element: PolygonCurve2dElement, node: PolygonCurve2dNode): void;
        computeStructureAfter(context: ElementPerformerContext, element: PolygonCurve2dElement, node: PolygonCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/PolylineCurve2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PolylineCurve2dNode } from 'foundation/data/common/model/brep/geometric/curve2d/PolylineCurve2dNode';
    import { PolylineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/PolylineCurve2dElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { Curve2dElementPerformer } from "sk/rule/data/performer/brep/geometric/Curve2dElementPerfermer";
    export class PolylineCurve2dElementPerformer extends Curve2dElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PolylineCurve2dElement): PolylineCurve2dElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PolylineCurve2dElement): PolylineCurve2dNode;
        processInstance(context: ElementPerformerContext, element: PolylineCurve2dElement): ResultEnum;
        computePropertyTransform(context: ElementPerformerContext, element: PolylineCurve2dElement, node: PolylineCurve2dNode): void;
        computeProperty(context: ElementPerformerContext, element: PolylineCurve2dElement, index: number, node: PolylineCurve2dNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: PolylineCurve2dElement, node: PolylineCurve2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/geometric/SphereSolidElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { SphereSolidNode } from 'foundation/data/common/model/brep/geometric/solid/SphereSolidNode';
    import { SphereSolidElement } from 'sk/data/family/element/brep/geometric/solid/SphereSolidElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SpatialElementPerformer } from "sk/rule/data/performer/brep/SpatialElementPerformer";
    export class SphereSolidElementPerformer extends SpatialElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: SphereSolidElement): SphereSolidNode;
        computeProperty(context: ElementPerformerContext, element: SphereSolidElement, index: number, node: SphereSolidNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/GroupElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { GroupElement } from 'sk/data/family/element/brep/GroupElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class GroupElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: ComponentElement, element: GroupElement): GroupNode;
        computeProperty(context: SchemeElementPerformerContext, element: GroupElement, index: number, node: GroupNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/ObserverElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { ObserverElement } from 'sk/data/family/element/brep/ObserverElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { VertexElementPerformer } from "sk/rule/data/performer/brep/VertexElementPerformer";
    export class ObserverElementPerformer extends VertexElementPerformer {
        computeElementProperty(context: ElementPerformerContext, source: ObserverElement, target: ObserverElement): void;
        computeProperty(context: ElementPerformerContext, element: ObserverElement, index: number, node: ObserverNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/observer/ObserverViewElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ObserverViewElement } from 'sk/data/family/element/brep/observer/ObserverViewElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ObserverElementPerformer } from "sk/rule/data/performer/brep/ObserverElementPerformer";
    export class ObserverViewElementPerformer extends ObserverElementPerformer {
        computeElementProperty(context: ElementPerformerContext, source: ObserverViewElement, target: ObserverViewElement): void;
        computeProperty(context: ElementPerformerContext, element: ObserverViewElement, index: number, node: ObserverViewNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/observer/ObserverBirdRenderElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ObserverBirdRenderNode } from 'foundation/data/common/model/brep/observer/ObserverBirdRenderNode';
    import { ObserverBirdRenderElement } from 'sk/data/family/element/brep/observer/ObserverBirdRenderElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ObserverViewElementPerformer } from "sk/rule/data/performer/brep/observer/ObserverViewElementPerformer";
    export class ObserverBirdRenderElementPerformer extends ObserverViewElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ObserverBirdRenderElement): ObserverBirdRenderNode;
        computeElementProperty(context: ElementPerformerContext, source: ObserverBirdRenderElement, target: ObserverBirdRenderElement): void;
        computeProperty(context: ElementPerformerContext, element: ObserverBirdRenderElement, index: number, node: ObserverBirdRenderNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/observer/ObserverNormalRenderElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ObserverNormalRenderNode } from 'foundation/data/common/model/brep/observer/ObserverNormalRenderNode';
    import { ObserverNormalRenderElement } from 'sk/data/family/element/brep/observer/ObserverNormalRenderElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ObserverViewElementPerformer } from "sk/rule/data/performer/brep/observer/ObserverViewElementPerformer";
    export class ObserverNormalRenderElementPerformer extends ObserverViewElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ObserverNormalRenderElement): ObserverNormalRenderNode;
        computeElementProperty(context: ElementPerformerContext, source: ObserverNormalRenderElement, target: ObserverNormalRenderElement): void;
        computeProperty(context: ElementPerformerContext, element: ObserverNormalRenderElement, index: number, node: ObserverNormalRenderNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/observer/ObserverPanoRenderElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ObserverPanoRenderNode } from 'foundation/data/common/model/brep/observer/ObserverPanoRenderNode';
    import { ObserverPanoRenderElement } from 'sk/data/family/element/brep/observer/ObserverPanoRenderElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ObserverViewElementPerformer } from "sk/rule/data/performer/brep/observer/ObserverViewElementPerformer";
    export class ObserverPanoRenderElementPerformer extends ObserverViewElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ObserverPanoRenderElement): ObserverPanoRenderNode;
        computeElementProperty(context: ElementPerformerContext, source: ObserverPanoRenderElement, target: ObserverPanoRenderElement): void;
        computeProperty(context: ElementPerformerContext, element: ObserverPanoRenderElement, index: number, node: ObserverPanoRenderNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/brep/ScopeElementPerformer" {
    import { ScopeNode } from 'foundation/data/common/model/brep/ScopeNode';
    import { ScopeElement } from 'sk/data/family/element/brep/ScopeElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class ScopeElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: ComponentElement, element: ScopeElement): ScopeNode;
    }
}
declare module "sk/rule/data/performer/brep/vision/VisionBoxSolidElementPerformer" {
    import { VisionBoxSolidNode } from 'foundation/data/common/model/brep/vision/solid/VisionBoxSolidNode';
    import { VisionBoxSolidElement } from 'sk/data/family/element/brep/vision/solid/VisionBoxSolidElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class VisionBoxSolidElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: VisionBoxSolidElement): VisionBoxSolidNode;
    }
}
declare module "sk/rule/data/performer/brep/vision/VisionSphereSolidElementPerformer" {
    import { VisionSphereSolidNode } from 'foundation/data/common/model/brep/vision/solid/VisionSphereSolidNode';
    import { VisionSphereSolidElement } from 'sk/data/family/element/brep/vision/solid/VisionSphereSolidElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class VisionSphereSolidElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: VisionSphereSolidElement): VisionSphereSolidNode;
    }
}
declare module "sk/rule/data/performer/component/ComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ComponentNode } from 'sk/data/family/model/component/ComponentNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleService } from 'sk/data/family/rule/RuleService';
    import { RuleTypeDocumentService } from 'sk/data/family/rule/RuleTypeDocumentService';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    export class ComponentElementCache extends NestElementCache {
    }
    export class ComponentElementPerformer extends ContentElementPerformer {
        protected _familyConfigService: FamilyConfigService;
        protected _schemeConfigService: SchemeConfigService;
        protected _ruleTypeDocumentService: RuleTypeDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        protected _ruleService: RuleService;
        createCache(context: ElementPerformerContext): ElementCache;
        buildElementStructureAsync(context: ElementPerformerContext, parentElement: ComponentInstanceElement | FamilyInstanceElement, structure: StructureElement): Promise<ResultObject>;
        buildStructureDocumentAsync(context: ElementPerformerContext, element: ComponentInstanceElement | FamilyInstanceElement, familyDocument: FamilyDocument): Promise<ResultObject>;
        computeElementProperty(context: ElementPerformerContext, source: ComponentElement, target: ComponentElement): void;
        computeStructureRuleAsync(context: ElementPerformerContext, element: ComponentElement, node: ComponentNode | FamilyInstanceNode): Promise<ResultObject>;
        computeProperty(context: ElementPerformerContext, element: ComponentElement, index: number, node: ComponentNode | ContentInstanceNode): ResultEnum;
        validateChildrenAsync(context: ElementPerformerContext, element: ComponentElement): Promise<ResultObject>;
        validateAsync(context: ElementPerformerContext, element: ComponentElement): Promise<ResultObject>;
        validateStructureAsync(context: ElementPerformerContext, element: ComponentElement): Promise<ResultObject>;
        validatePropertyAsync(context: ElementPerformerContext, element: ComponentElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/performer/CollisionComponentElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { CollisionComponentElement } from 'sk/data/family/element/component/CollisionComponentElement';
    import { CollisionNode } from 'sk/data/family/model/component/CollisionNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class CollisionComponentElementPerformer extends ComponentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CollisionComponentElement): CollisionNode;
    }
}
declare module "sk/rule/data/performer/component/LightComponentPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LightComponentElement } from 'sk/data/family/element/component/LightComponentElement';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class LightComponentPerformer extends ComponentElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LightComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LightComponentElement): LightNode;
        processInstance(context: ElementPerformerContext, element: LightComponentElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: LightComponentElement, index: number, node: LightNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/AreaLightComponentPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AreaLightComponentElement } from 'sk/data/family/database/light/element/AreaLightComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AreaLightNode } from 'sk/data/scheme/database/light/model/AreaLightNode';
    import { LightComponentPerformer } from "sk/rule/data/performer/component/LightComponentPerformer";
    export class AreaLightComponentPerformer extends LightComponentPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AreaLightComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AreaLightComponentElement): AreaLightNode;
        processInstance(context: ElementPerformerContext, element: AreaLightComponentElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: AreaLightComponentElement, index: number, node: AreaLightNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/ChestComponentElementPerformer" {
    import { ChestComponentElement } from 'sk/data/family/database/furniture/element/ChestComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ChestElement } from 'sk/data/scheme/database/furniture/element/ChestElement';
    import { ChestNode } from 'sk/data/scheme/database/furniture/model/ChestNode';
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class ChestComponentElementCache extends NestElementCache {
    }
    export class ChestComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: Element): Element;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ChestComponentElement | ChestElement): ChestNode;
    }
}
declare module "sk/rule/data/performer/component/ComponentInstanceElementPerformer" {
    import { UniqueTypes } from 'cross/runtime/lang/collection/UniqueTypes';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { ComponentInstanceNode } from 'sk/data/family/model/component/ComponentInstanceNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { ComponentElementCache, ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class ComponentInstanceElementCache extends ComponentElementCache {
        getInstanceElements(): UniqueTypes<Element>;
    }
    export abstract class ComponentInstanceElementPerformer extends ComponentElementPerformer {
        protected _familyDocumentService: FamilyDocumentService;
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ComponentInstanceElement): ComponentInstanceElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ComponentInstanceElement): ComponentInstanceNode;
        onPrepareAsync(context: ElementPerformerContext, containerElement: BrepElement, element: ComponentInstanceElement): Promise<ElementPerformerResult>;
    }
}
declare module "sk/rule/data/performer/component/ContainerComponentElementPerformer" {
    import { ContainerElement } from 'sk/data/family/element/brep/frame/ContainerElement';
    import { ContainerNode } from 'sk/data/family/model/brep/frame/ContainerNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContainerComponentElement } from 'sk/data/family/element/component/ContainerComponentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class ContainerComponentElementPerformer extends ComponentElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ContainerComponentElement): ContainerElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ContainerElement): ContainerNode;
    }
}
declare module "sk/rule/data/performer/component/WareComponentElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { WareComponentElement } from 'sk/data/family/element/component/WareComponentElement';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class WareComponentInstanceElementCache extends NestElementCache {
    }
    export class WareComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: Element): Element;
        computeElementProperty(context: ElementPerformerContext, source: WareComponentElement, target: WareComponentElement): void;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: WareComponentElement): WareNode;
    }
}
declare module "sk/rule/data/performer/component/DynamicWareComponentElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { DynamicWareComponentElement } from 'sk/data/family/element/component/DynamicWareComponentElement';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WareComponentElementPerformer } from "sk/rule/data/performer/component/WareComponentElementPerformer";
    export class DynamicWareComponentElementPerformer extends WareComponentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: DynamicWareComponentElement): DynamicWareNode;
    }
}
declare module "sk/rule/data/performer/component/SurfaceComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { SurfaceComponentElement } from 'sk/data/family/element/component/SurfaceComponentElement';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class SurfaceComponentElementPerformer extends ComponentElementPerformer {
        protected _familyConfigService: FamilyConfigService;
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SurfaceComponentElement): Element;
        computeProperty(context: ElementPerformerContext, element: SurfaceComponentElement, index: number, node: SurfaceNode): ResultEnum;
        protected getFamilyFeaturesByCodeAsync(context: ElementPerformerContext, element: SurfaceComponentElement, featureName: string): Promise<any>;
        computeStructureAfterAsync(context: ElementPerformerContext, element: SurfaceComponentElement, node: SurfaceNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/performer/component/PlaneSurfaceComponentPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PlaneSurfaceComponentElement } from 'sk/data/family/element/component/PlaneSurfaceComponentElement';
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { SurfaceComponentElementPerformer } from "sk/rule/data/performer/component/SurfaceComponentElementPerformer";
    export class PlaneSurfaceComponentCache extends ElementCache {
        materialId: string;
        materialVersion: string;
    }
    export class PlaneSurfaceComponentPerformer extends SurfaceComponentElementPerformer {
        protected _familyConfigService: FamilyConfigService;
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PlaneSurfaceComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: PlaneSurfaceComponentElement): PlaneSurfaceNode;
        onPrepareAsync(context: ElementPerformerContext, containerElement: BrepElement, element: PlaneSurfaceComponentElement): Promise<ElementPerformerResult>;
        computeProperty(context: ElementPerformerContext, element: PlaneSurfaceComponentElement, index: number, node: SurfaceNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/EdgeSurfaceComponentPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { EdgeSurfaceComponentElement } from 'sk/data/family/element/component/EdgeSurfaceComponentElement';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { ComponentInstanceElementCache } from "sk/rule/data/performer/component/ComponentInstanceElementPerformer";
    import { SurfaceComponentElementPerformer } from "sk/rule/data/performer/component/SurfaceComponentElementPerformer";
    export class EdgeSurfaceComponentInstanceElementCache extends ComponentInstanceElementCache {
    }
    export class EdgeSurfaceComponentPerformer extends SurfaceComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: EdgeSurfaceComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: EdgeSurfaceComponentElement): EdgeSurfaceNode;
        buildElementReleation(context: ElementPerformerContext, element: EdgeSurfaceComponentElement): void;
        onPrepareAsync(context: ElementPerformerContext, containerElement: BrepElement, element: EdgeSurfaceComponentElement): Promise<ElementPerformerResult>;
        computeProperty(context: ElementPerformerContext, element: EdgeSurfaceComponentElement, index: number, node: EdgeSurfaceNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/ElementStructureUtil" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { GeometricStructure } from 'foundation/data/common/structure/GeometricStructure';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    export class ElementStructureUtil {
        static curveElementToStructure(context: ElementPerformerContext, element: BrepElement, node: BrepNode): GeometricStructure;
    }
}
declare module "sk/rule/data/performer/component/FragmentComponentElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { FragmentComponentElement } from 'sk/data/family/element/component/FragmentComponentElement';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class FragmentComponentInstanceElementCache extends NestElementCache {
    }
    export class FragmentComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: Element): Element;
        computeElementProperty(context: ElementPerformerContext, source: ComponentElement, target: ComponentElement): void;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: FragmentComponentElement): WareNode;
    }
}
declare module "sk/rule/data/performer/component/GridComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { GridComponentElement } from 'sk/data/family/element/component/GridComponentElement';
    import { GridComponentNode } from 'sk/data/family/model/component/GridComponentNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class GridComponentElementCache extends ElementCache {
        materialId: string;
        materialVersion: string;
    }
    export class GridComponentElementPerformer extends ComponentElementPerformer {
        protected _familyConfigService: FamilyConfigService;
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: GridComponentElement): GridComponentNode;
        computeStructureAfter(context: ElementPerformerContext, element: GridComponentElement, node: GridComponentNode): ResultEnum;
        computeElement(context: ElementPerformerContext, element: GridComponentElement): ResultEnum;
        protected removeChildByType(element: GridComponentElement, type: Function): void;
        computeProperty(context: ElementPerformerContext, element: GridComponentElement, index: number, node: GridComponentNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/GridMeshComponentElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { GridMeshComponentElement } from 'sk/data/family/element/component/GridMeshComponentElement';
    import { GridMeshComponentNode } from 'sk/data/family/model/component/GridMeshComponentNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class GridMeshComponentElementCache extends ElementCache {
        materialId: string;
        materialVersion: string;
    }
    export class GridMeshComponentElementPerformer extends ComponentElementPerformer {
        protected _familyConfigService: FamilyConfigService;
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: GridMeshComponentElement): GridMeshComponentNode;
        protected removeChildByType(element: GridMeshComponentElement, type: Function): void;
    }
}
declare module "sk/rule/data/performer/component/HardwareComponentElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { HardwareComponentElement } from 'sk/data/family/element/component/HardwareComponentElement';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class HardwareComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: HardwareComponentElement): HardwareComponentElement;
        createNode(context: ElementPerformerContext, element: HardwareComponentElement): HardwareNode;
    }
}
declare module "sk/rule/data/performer/component/LayoutComponentElementPerformer" {
    import { UniqueTypes } from 'cross/runtime/lang/collection/UniqueTypes';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { VisionModelElement } from 'sk/data/family/element/brep/vision/VisionModelElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { LayoutComponentElement } from 'sk/data/family/element/component/LayoutComponentElement';
    import { ComponentInstanceNode } from 'sk/data/family/model/component/ComponentInstanceNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { LayoutInfo } from "sk/rule/data/base/element/brep/LayoutPerformerUtil";
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class LayoutComponentElementCache extends NestElementCache {
        constructor();
        getInstanceElements(): UniqueTypes<Element>;
        layoutElementsInfos: Array<{
            info: LayoutInfo;
            element: ComponentInstanceElement | VisionModelElement;
        }>;
    }
    export abstract class LayoutComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LayoutComponentElement): LayoutComponentElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: LayoutComponentElement): ComponentInstanceNode;
        computeStructureChildrenAsync(context: ElementPerformerContext, element: LayoutComponentElement, node: ContentNode): Promise<ElementPerformerResult>;
        private createOrSetNewElementByInfo;
    }
}
declare module "sk/rule/data/performer/component/LinearComponentPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve2dStructure } from 'foundation/data/common/structure/geometric/curve2d/LineCurve2dStructure';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { LinearComponentElement } from 'sk/data/family/element/component/LinearComponentElement';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { ProfileDocument } from 'sk/data/family/structure/profile/ProfileDocument';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { CurveDocument } from 'sk/data/resource/curve/model/CurveDocument';
    import { CurveDocumentService } from 'sk/data/resource/curve/service/CurveDocumentService';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class LinearComponentPerformer extends ComponentElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        protected _curveDocumentService: CurveDocumentService;
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LinearComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LinearComponentElement): LinearNode;
        onPrepareAsync(context: ElementPerformerContext, containerElement: BrepElement, element: LinearComponentElement): Promise<ElementPerformerResult>;
        processInstance(context: ElementPerformerContext, element: LinearComponentElement): ResultEnum;
        createLineCurve2dStructure(begin: Vector3, end: Vector3): LineCurve2dStructure;
        processProfileProperty(context: ElementPerformerContext, element: LinearComponentElement, points: Array<Vector3>, node: LinearNode): void;
        computeProperty(context: ElementPerformerContext, element: LinearComponentElement, index: number, node: LinearNode): ResultEnum;
        protected updateLinearByCurveDocument(context: ElementPerformerContext, doc: CurveDocument, element: LinearComponentElement, node: LinearNode): void;
        protected updateLinear(context: ElementPerformerContext, doc: ProfileDocument, element: LinearComponentElement, node: LinearNode): void;
        computeStructureAfterAsync(context: ElementPerformerContext, element: LinearComponentElement, node: LinearNode): Promise<ResultObject>;
        computeStructureAfter(context: ElementPerformerContext, element: LinearComponentElement, node: LinearNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/LinearPointElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LinearPointElement } from 'sk/data/family/element/instance/LinearPointElement';
    import { LinearPointNode } from 'sk/data/family/model/instance/LinearPointNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { VertexElementPerformer } from "sk/rule/data/performer/brep/VertexElementPerformer";
    export class LinearPointElementPerformer extends VertexElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LinearPointElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LinearPointElement): LinearPointNode;
        processInstance(context: ElementPerformerContext, element: LinearPointElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: LinearPointElement, index: number, node: PointNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/NodeStructureUtil" {
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { Curve2dStructure } from 'foundation/data/common/structure/geometric/Curve2dStructure';
    import { PointStructure } from 'foundation/data/common/structure/geometric/PointStructure';
    export class NodeStructureUtil {
        static curveNodeToStructure(node: BrepNode): Curve2dStructure;
        static curveStructureByPointNode(node: PointNode): PointStructure;
    }
}
declare module "sk/rule/data/performer/component/OpeningComponentElementPerformer" {
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class OpeningComponentElementPerformer extends ComponentElementPerformer {
        constructor();
    }
}
declare module "sk/rule/data/performer/component/PlaneComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { PlaneComponentElement } from 'sk/data/family/element/component/PlaneComponentElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class PlaneComponentElementPerformer extends ComponentElementPerformer {
        protected _familyDocumentService: FamilyDocumentService;
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PlaneComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PlaneElement): PlaneNode;
        computeElementProperty(context: ElementPerformerContext, source: ComponentInstanceElement | PlaneComponentElement, target: PlaneComponentElement): void;
        buildElementAsync(context: ElementPerformerContext, parentElement: PlaneElement, element: BrepElement): Promise<ResultObject>;
        computeStructureBefore(context: ElementPerformerContext, element: PlaneComponentElement, node: PlaneNode): ResultEnum;
        computeStructureBeforeAsync(context: ElementPerformerContext, element: PlaneComponentElement, node: PlaneNode): Promise<ResultObject>;
        buildElementStructureAsync(context: ElementPerformerContext, parentElement: PlaneElement, structure: StructureElement): Promise<ResultObject>;
        computeStructureAfter(context: ElementPerformerContext, element: PlaneElement, node: PlaneNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/PlankComponentElementPerformer" {
    import { PlankComponentElement } from 'sk/data/family/database/furniture/element/PlankComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class PlankComponentElementCache extends NestElementCache {
    }
    export class PlankComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: Element): Element;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: PlankComponentElement): PlankNode;
    }
}
declare module "sk/rule/data/performer/component/PointLightComponentPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PointLightComponentElement } from 'sk/data/family/database/light/element/PointLightComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PointLightNode } from 'sk/data/scheme/database/light/model/PointLightNode';
    import { LightComponentPerformer } from "sk/rule/data/performer/component/LightComponentPerformer";
    export class PointLightComponentPerformer extends LightComponentPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PointLightComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PointLightComponentElement): PointLightNode;
        processInstance(context: ElementPerformerContext, element: PointLightComponentElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: PointLightComponentElement, index: number, node: PointLightNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/SlidingDoorComponentElementPerformer" {
    import { SlidingDoorComponentElement } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SlidingDoorNode } from 'sk/data/scheme/database/furniture/model/SlidingDoorNode';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class SlidingDoorComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SlidingDoorComponentElement): SlidingDoorComponentElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: SlidingDoorComponentElement): SlidingDoorNode;
    }
}
declare module "sk/rule/data/performer/component/SpotLightComponentPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { SpotLightComponentElement } from 'sk/data/family/database/light/element/SpotLightComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SpotLightNode } from 'sk/data/scheme/database/light/model/SpotLightNode';
    import { LightComponentPerformer } from "sk/rule/data/performer/component/LightComponentPerformer";
    export class SpotLightComponentPerformer extends LightComponentPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SpotLightComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: SpotLightComponentElement): SpotLightNode;
        processInstance(context: ElementPerformerContext, element: SpotLightComponentElement): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: SpotLightComponentElement, index: number, node: SpotLightNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/SubstrateComponentElementPerformer" {
    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 { SubstrateComponentElement } from 'sk/data/family/element/component/SubstrateComponentElement';
    import { SubstrateNode } from 'sk/data/family/model/instance/SubstrateNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class SubstrateComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SubstrateComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: SubstrateComponentElement): SubstrateNode;
        computeStructureAfterAsync(context: ElementPerformerContext, element: SubstrateComponentElement, node: SubstrateNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/performer/component/TechnologyComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyComponentElement } from 'sk/data/family/element/component/TechnologyComponentElement';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class TechnologyComponentElementCache extends NestElementCache {
    }
    export class TechnologyComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: TechnologyComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: TechnologyComponentElement): TechnologyNode;
        computeElementProperty(context: ElementPerformerContext, source: TechnologyComponentElement, target: TechnologyComponentElement): void;
        computeProperty(context: ElementPerformerContext, element: TechnologyComponentElement, index: number, node: TechnologyNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/component/TechnologyGroupComponentElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyGroupComponentElement } from 'sk/data/family/element/component/TechnologyGroupComponentElement';
    import { TechnologyGroupNode } from 'sk/data/family/model/component/TechnologyGroupNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class TechnologyGroupComponentElementCache extends NestElementCache {
    }
    export class TechnologyGroupComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: TechnologyGroupComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: TechnologyGroupComponentElement): TechnologyGroupNode;
    }
}
declare module "sk/rule/data/performer/component/VisionGridModelElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { VisionGridModelNode } from 'foundation/data/common/model/brep/vision/VisionGridModelNode';
    import { VisionGridModelElement } from 'sk/data/family/element/brep/vision/VisionGridModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class VisionGridModelElementCache extends ElementCache {
        materialId: string;
        materialVersion: string;
    }
    export class VisionGridModelElementPerformer extends ContentElementPerformer {
        constructor();
        createCache(context: ElementPerformerContext): ElementCache;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: VisionGridModelElement): VisionGridModelElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: VisionGridModelElement): VisionGridModelNode;
        computeProperty(context: ElementPerformerContext, element: VisionGridModelElement, index: number, node: VisionGridModelNode): ResultEnum;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: VisionGridModelElement, node: VisionGridModelNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/performer/ContactComponentElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContactComponentElement } from 'sk/data/family/element/component/ContactComponentElement';
    import { ContactNode } from 'sk/data/family/model/component/ContactNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class ContactComponentElementPerformer extends ComponentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ContactComponentElement): ContactNode;
    }
}
declare module "sk/rule/data/performer/ContactLineElementPerformer" {
    import { ContactLineElement } from 'sk/data/family/element/assistant/contact/ContactLineElement';
    import { ContactLineNode } from 'sk/data/family/model/assistant/contact/ContactLineNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class ContactLineElementPerformer extends AssistantElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ContactLineElement): ContactLineElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ContactLineElement): ContactLineNode;
        computeElementProperty(context: ElementPerformerContext, source: ContactLineElement, target: ContactLineElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: ContactLineElement, node: ContactLineNode): void;
        computeLocalMatrix(node: ContactLineNode): void;
    }
}
declare module "sk/rule/data/performer/ContactPointElementPerformer" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { ContactPointElement } from 'sk/data/family/element/assistant/contact/ContactPointElement';
    import { ContactPointNode } from 'sk/data/family/model/assistant/contact/ContactPointNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class ContactPointElementPerformer extends AssistantElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ContactPointElement): ContactPointElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ContactPointElement): ContactPointNode;
        computeElementProperty(context: ElementPerformerContext, source: ContactPointElement, target: ContactPointElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: ContactPointElement, node: ContactPointNode): void;
        computeLocalMatrix(node: ContactPointNode): Matrix3d;
    }
}
declare module "sk/rule/data/performer/ContactSurfaceElementPerformer" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { ContactSurfaceElement } from 'sk/data/family/element/assistant/contact/ContactSurfaceElement';
    import { ContactSurfaceNode } from 'sk/data/family/model/assistant/contact/ContactSurfaceNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class ContactSurfaceElementPerformer extends AssistantElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ContactSurfaceElement): ContactSurfaceElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ContactSurfaceElement): ContactSurfaceNode;
        computeElementProperty(context: ElementPerformerContext, source: ContactSurfaceElement, target: ContactSurfaceElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: ContactSurfaceElement, node: ContactSurfaceNode): void;
        computeLocalMatrix(node: ContactSurfaceNode): Matrix3d;
    }
}
declare module "sk/rule/data/performer/database/architecture/BeamComponentElementPerformer" {
    import { BeamComponentElement } from 'sk/data/family/database/architecture/element/BeamComponentElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class BeamComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: BrepElement, element: BeamComponentElement): BeamComponentElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: BeamComponentElement): BeamNode;
    }
}
declare module "sk/rule/data/performer/database/architecture/ColumnComponentElementPerformer" {
    import { ColumnComponentElement } from 'sk/data/family/database/architecture/element/ColumnComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ColumnNode } from 'sk/data/scheme/database/floorplan/model/ColumnNode';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class ColumnComponentElementPerformer extends ComponentElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ColumnComponentElement): ColumnComponentElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ColumnComponentElement): ColumnNode;
    }
}
declare module "sk/rule/data/performer/database/architecture/DoorComponentElementPerformer" {
    import { DoorComponentElement } from 'sk/data/family/database/architecture/element/DoorComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { DoorNode } from 'sk/data/scheme/database/floorplan/model/DoorNode';
    import { OpeningComponentElementPerformer } from "sk/rule/data/performer/component/OpeningComponentElementPerformer";
    export class DoorComponentElementPerformer extends OpeningComponentElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: DoorComponentElement): DoorComponentElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: DoorComponentElement): DoorNode;
    }
}
declare module "sk/rule/data/performer/database/architecture/HoleComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { HoleComponentElement } from 'sk/data/family/database/architecture/element/HoleComponentElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ComponentNode } from 'sk/data/family/model/component/ComponentNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { HoleNode } from 'sk/data/scheme/database/floorplan/model/HoleNode';
    import { OpeningComponentElementPerformer } from "sk/rule/data/performer/component/OpeningComponentElementPerformer";
    export class HoleComponentElementPerformer extends OpeningComponentElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        createElement(context: ElementPerformerContext, containerElement: BrepElement, element: HoleComponentElement): HoleComponentElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: HoleComponentElement): HoleNode;
        computeProperty(context: ElementPerformerContext, element: HoleComponentElement, index: number, node: ComponentNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/database/architecture/WindowComponentElementPerformer" {
    import { HoleComponentElement } from 'sk/data/family/database/architecture/element/HoleComponentElement';
    import { WindowComponentElement } from 'sk/data/family/database/architecture/element/WindowComponentElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WindowNode } from 'sk/data/scheme/database/floorplan/model/WindowNode';
    import { OpeningComponentElementPerformer } from "sk/rule/data/performer/component/OpeningComponentElementPerformer";
    export class WindowComponentElementPerformer extends OpeningComponentElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: HoleComponentElement): HoleComponentElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: WindowComponentElement): WindowNode;
    }
}
declare module "sk/rule/data/performer/frame/ControlElementPerformer" {
    import { ControlElement } from 'sk/data/family/element/brep/frame/ControlElement';
    import { ControlNode } from 'sk/data/family/model/brep/frame/ControlNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class ControlElementPerformer extends BrepElementPerformer {
        computePropertyTransform(context: ElementPerformerContext, element: ControlElement, node: ControlNode): void;
    }
}
declare module "sk/rule/data/performer/drawing/DrawingDomainComponentElementPerformer" {
    import { DrawingDomainElement } from 'sk/data/family/drawing/element/DrawingDomainElement';
    import { DrawingDomainNode } from 'sk/data/family/drawing/model/DrawingDomainNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ControlElementPerformer } from "sk/rule/data/performer/frame/ControlElementPerformer";
    export class DrawingDomainComponentElementPerformer extends ControlElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: DrawingDomainElement): DrawingDomainNode;
    }
}
declare module "sk/rule/data/performer/frame/ContainerElementPerformer" {
    import { ControlElementPerformer } from "sk/rule/data/performer/frame/ControlElementPerformer";
    export class ContainerElementPerformer extends ControlElementPerformer {
        constructor();
    }
}
declare module "sk/rule/data/performer/drawing/DrawingFrameComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { DrawingFrameElement } from 'sk/data/family/drawing/element/DrawingFrameElement';
    import { DrawingFrameNode } from 'sk/data/family/drawing/model/DrawingFrameNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContainerElementPerformer } from "sk/rule/data/performer/frame/ContainerElementPerformer";
    export class DrawingFrameComponentElementPerformer extends ContainerElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: DrawingFrameElement): DrawingFrameNode;
        computeProperty(context: ElementPerformerContext, element: DrawingFrameElement, index: number, node: DrawingFrameNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/drawing/DrawingInstanceComponentElementPerformer" {
    import { ControlElementPerformer } from "sk/rule/data/performer/frame/ControlElementPerformer";
    export class DrawingInstanceComponentElementPerformer extends ControlElementPerformer {
    }
}
declare module "sk/rule/data/performer/StructureElementPerformer" {
    import { NestElementPerformer } from "sk/rule/data/performer/NestElementPerformer";
    export class StructureElementPerformer extends NestElementPerformer {
    }
}
declare module "sk/rule/data/performer/DrawingGraphStructureElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { DrawingGraphStructureElement } from 'sk/data/family/drawing/element/DrawingGraphStructureElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { GraphBlueprintNode } from 'sk/data/resource/graph/model/GraphBlueprintNode';
    import { StructureElementPerformer } from "sk/rule/data/performer/StructureElementPerformer";
    export class DrawingGraphStructureElementPerformer extends StructureElementPerformer {
        computeProperty(context: ElementPerformerContext, element: DrawingGraphStructureElement, index: number, node: GraphBlueprintNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/frame/control/MemoControlElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MemoControlElement } from 'sk/data/family/element/brep/frame/control/MemoControlElement';
    import { MemoControlNode } from 'sk/data/family/model/brep/frame/control/MemoControlNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ControlElementPerformer } from "sk/rule/data/performer/frame/ControlElementPerformer";
    export class MemoControlElementPerformer extends ControlElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, controlElement: BrepElement, element: MemoControlElement): MemoControlNode;
        computeProperty(context: ElementPerformerContext, element: MemoControlElement, index: number, node: MemoControlNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/frame/control/PanelControlElementPerformer" {
    import { PanelControlElement } from 'sk/data/family/element/brep/frame/control/PanelControlElement';
    import { PanelControlNode } from 'sk/data/family/model/brep/frame/control/PanelControlNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContainerElementPerformer } from "sk/rule/data/performer/frame/ContainerElementPerformer";
    export class PanelControlElementPerformer extends ContainerElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: PanelControlElement): PanelControlNode;
    }
}
declare module "sk/rule/data/performer/frame/control/PictureControlElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PictureControlElement } from 'sk/data/family/element/brep/frame/control/PictureControlElement';
    import { PictureControlNode } from 'sk/data/family/model/brep/frame/control/PictureControlNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ControlElementPerformer } from "sk/rule/data/performer/frame/ControlElementPerformer";
    export class PictureControlElementPerformer extends ControlElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, controlElement: BrepElement, element: PictureControlElement): PictureControlNode;
        computeProperty(context: ElementPerformerContext, element: PictureControlElement, index: number, node: PictureControlNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/frame/control/TextControlElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { TextControlElement } from 'sk/data/family/element/brep/frame/control/TextControlElement';
    import { TextControlNode } from 'sk/data/family/model/brep/frame/control/TextControlNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ControlElementPerformer } from "sk/rule/data/performer/frame/ControlElementPerformer";
    export class TextControlElementPerformer extends ControlElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, controlElement: BrepElement, element: TextControlElement): TextControlNode;
        computeProperty(context: ElementPerformerContext, element: TextControlElement, index: number, node: TextControlNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/furniture/CollisionGroovElementPerformer" {
    import { ElementPerformer } from 'sk/data/family/performer/element/ElementPerformer';
    export class CollisionGroovElementPerformer extends ElementPerformer {
    }
}
declare module "sk/rule/data/performer/furniture/CollisionSlotElementPerformer" {
    import { ElementPerformer } from 'sk/data/family/performer/element/ElementPerformer';
    export class CollisionSlotElementPerformer extends ElementPerformer {
    }
}
declare module "sk/rule/data/performer/furniture/HardwareElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { HardwareElement } from 'sk/data/family/element/instance/HardwareElement';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ComponentElementPerformer } from "sk/rule/data/performer/component/ComponentElementPerformer";
    export class HardwareElementPerformer extends ComponentElementPerformer {
        createNode(context: ElementPerformerContext, element: HardwareElement): HardwareNode;
        processInstance(context: ElementPerformerContext, element: HardwareElement, node: HardwareNode): ResultEnum;
        processProperty(context: ElementPerformerContext, element: HardwareElement, node: HardwareNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/furniture/HardwareInstanceElementPerformer" {
    import { HardwareElement } from 'sk/data/family/element/instance/HardwareElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class HardwareInstanceElementCalculatorCache extends ElementCache {
        familyDocument: FamilyDocument;
        hardwareElement: HardwareElement;
    }
    export class HardwareInstanceElementPerformer extends ContentElementPerformer {
    }
}
declare module "sk/rule/data/performer/furniture/HitRuleElementPerformer" {
    import { HitRuleElement } from 'sk/data/family/rule/element/brep/HitRuleElement';
    import { ElementPerformer } from 'sk/data/family/performer/element/ElementPerformer';
    export class HitRuleElementPerformer extends ElementPerformer {
        static backHitOtherRule(): HitRuleElement;
        testInstance(instance: any): boolean;
    }
}
declare module "sk/rule/data/performer/furniture/PlankHardwareRuleInstanceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PlankHardwareRuleInstanceElement } from 'sk/data/family/database/furniture/element/rule/PlankHardwareRuleInstanceElement';
    import { HardwareElement } from 'sk/data/family/element/instance/HardwareElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class HardwareRuleInstanceElementCalculatorCache extends ElementCache {
        familyDocument: FamilyDocument;
        hardwareElement: HardwareElement;
    }
    export class PlankHardwareRuleInstanceElementPerformer extends ContentElementPerformer {
        protected _familyDocumentService: FamilyDocumentService;
        constructor();
        processElement(context: ElementPerformerContext, element: PlankHardwareRuleInstanceElement, node: PlankNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/furniture/PlankHitPlakResult" {
    export class PlankHitPlankResult {
    }
}
declare module "sk/rule/data/performer/furniture/PlankInstanceElementPerformer" {
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class PlankInstanceElementCalculatorCache extends ElementCache {
        familyDocument: FamilyDocument;
    }
    export class PlankInstanceElementPerformer extends ContentElementPerformer {
    }
}
declare module "sk/rule/data/performer/furniture/TechnologyHitPlakResult" {
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    export class TechnologyHitPlakResult {
        p: any;
        t: any;
        constructor(p: any, t: TechnologyNode);
    }
}
declare module "sk/rule/data/performer/pattern/BathroomPatternElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class BathroomPatternElementPerformer extends FamilyInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/performer/pattern/LevelingCeilingPatternElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class LevelingCeilingPatternElementPerformer extends FamilyInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/performer/pattern/LevelingWallPatternElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class LevelingWallPatternElementPerformer extends FamilyInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/performer/pattern/PatternInstanceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class PatternInstanceElementPerformer extends ContentInstanceElementPerformer {
        structureName: string;
        prepareAsync(context: SchemeElementPerformerContext, containerElement: NestElement, element: PatternInstanceElement, parameters?: any): Promise<ElementPerformerResult>;
        computeStructureChildrenAsync(context: SchemeElementPerformerContext, element: PatternInstanceElement, node: PatternInstanceNode, parameters?: any): Promise<ElementPerformerResult>;
        computeProperty(context: SchemeElementPerformerContext, element: PatternInstanceElement, index: number, node: PatternInstanceNode): ResultEnum;
        onPrepareAsync(context: SchemeElementPerformerContext, containerElement: BrepElement, element: FamilyInstanceElement): Promise<ElementPerformerResult>;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: FamilyInstanceElement, element: PatternInstanceElement, parameter?: any): Promise<ResultObject>;
        computeElementAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement): Promise<ResultObject>;
        buildElementDocumentAsync(context: SchemeElementPerformerContext, element: PatternInstanceElement, patternDocument: PatternDocument, buildChild?: boolean): Promise<ResultObject>;
        computeStructureBeforeAsync(context: SchemeElementPerformerContext, element: PatternInstanceElement, node: PatternInstanceNode): Promise<ResultObject>;
        processFamilyRuleAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: PatternInstanceNode): Promise<ResultObject>;
        processParentDocumentRuleAsync(context: SchemeElementPerformerContext, element: FamilyInstanceElement, node: PatternInstanceNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/performer/reference/ReferenceAxisElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ReferenceAxisElement } from 'sk/data/family/element/assistant/reference/ReferenceAxisElement';
    import { ReferenceAxisNode } from 'sk/data/family/model/assistant/reference/ReferenceAxisNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class ReferenceAxisElementPerformer extends AssistantElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ReferenceAxisElement): ReferenceAxisElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ReferenceAxisElement): ReferenceAxisNode;
        computeProperty(context: ElementPerformerContext, element: ReferenceAxisElement, index: number, node: ReferenceAxisNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: ReferenceAxisElement, index: number, node: ReferenceAxisNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/reference/ReferenceLineElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ReferenceLineElement } from 'sk/data/family/element/assistant/reference/ReferenceLineElement';
    import { ReferenceLineNode } from 'sk/data/family/model/assistant/reference/ReferenceLineNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class ReferenceLineElementPerformer extends AssistantElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ReferenceLineElement): ReferenceLineElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ReferenceLineElement): ReferenceLineNode;
        computeProperty(context: ElementPerformerContext, element: ReferenceLineElement, index: number, node: ReferenceLineNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: ReferenceLineElement, index: number, node: ReferenceLineNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/reference/ReferencePlaneElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ReferencePlaneElement } from 'sk/data/family/element/assistant/reference/ReferencePlaneElement';
    import { ReferencePlaneNode } from 'sk/data/family/model/assistant/reference/ReferencePlaneNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class ReferencePlaneElementPerformer extends AssistantElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ReferencePlaneElement): ReferencePlaneElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ReferencePlaneElement): ReferencePlaneNode;
        computeProperty(context: ElementPerformerContext, element: ReferencePlaneElement, index: number, node: ReferencePlaneNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: ReferencePlaneElement, index: number, node: ReferencePlaneNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/RuleElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ElementPerformer } from 'sk/data/family/performer/element/ElementPerformer';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleElement } from 'sk/data/family/rule/element/RuleElement';
    export abstract class RuleElementPerformer extends ElementPerformer {
        processRule(context: ElementPerformerContext, element: RuleElement, node: DataNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/structure/ProfileCurveElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ProfileCurveElement } from 'sk/data/family/structure/profile/element/ProfileCurveElement';
    import { ProfileCurveNode } from 'sk/data/family/structure/profile/model/ProfileCurveNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class ProfileCurveElementPerformer extends BrepElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ProfileCurveElement): ProfileCurveElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ProfileCurveElement): ProfileCurveNode;
        computeProperty(context: ElementPerformerContext, element: ProfileCurveElement, index: number, node: ProfileCurveNode): ResultEnum;
        computeStructureRelation(context: ElementPerformerContext, element: ProfileCurveElement, node: ProfileCurveNode): ResultEnum;
        computeAfterProperty(context: ElementPerformerContext, element: ProfileCurveElement, node: ProfileCurveNode): ResultEnum;
        curveComputer(context: ElementPerformerContext, element: ProfileCurveElement, node: ProfileCurveNode): ResultEnum;
        protected pointsFromLineCd(context: ElementPerformerContext, element: ProfileCurveElement, node: ProfileCurveNode): void;
        protected centerVector(context: ElementPerformerContext, element: ProfileCurveElement, node: ProfileCurveNode, isClockwise: boolean): Vector2;
        protected centerPositionVector(context: ElementPerformerContext, element: ProfileCurveElement, node: ProfileCurveNode, normal: Vector2): Vector2;
        protected getLeftNormal(source: Vector2): void;
        protected getRightNormal(source: Vector2): void;
        protected isNumberCheck(value: string): boolean;
        computeElementProperty(context: ElementPerformerContext, source: ProfileCurveElement, target: ProfileCurveElement, parameters?: any): void;
    }
}
declare module "sk/rule/data/performer/structure/ProfilePointElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ProfilePointElement } from 'sk/data/family/structure/profile/element/ProfilePointElement';
    import { ProfilePointNode } from 'sk/data/family/structure/profile/model/ProfilePointNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PointElementPerformer } from "sk/rule/data/performer/brep/geometric/PointElementPerformer";
    export class ProfilePointElementPerformer extends PointElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ProfilePointElement): ProfilePointNode;
        computeProperty(context: ElementPerformerContext, element: ProfilePointElement, index: number, node: ProfilePointNode): ResultEnum;
        private circleArcCenterCompute;
        computeStructureRelation(context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode): ResultEnum;
        computeAfterProperty(context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode): ResultEnum;
        protected crossPointsCompute(context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode, param: any): boolean;
        protected ellipseLineCrossPointCompute(context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode, isPrev: boolean): Vector2;
        protected dashedLineCompute(context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode, param?: any): boolean;
        protected curvesCompute(context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode, param?: any): boolean;
        protected createCircularArc(element: ProfilePointElement, node: ProfilePointNode, param: any, diection?: String): boolean;
        protected createEllipseArc(element: ProfilePointElement, node: ProfilePointNode, param?: any): boolean;
        protected ellipseArcAxisCompute(context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode, param?: any): boolean;
        protected isClockwise(node: ProfilePointNode): boolean;
        protected isNumberCheck(value: string): boolean;
        protected getFormulaValue(field: string, context: ElementPerformerContext, element: ProfilePointElement, node: ProfilePointNode): number;
    }
}
declare module "sk/rule/data/performer/structure/ProfileElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CircleArc2Curve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/CircleArc2Curve2dDrawingNode';
    import { CircleCurve2dDrawingNodeMap } from 'sk/data/family/model/brep/drawing/curve2d/CircleCurve2dDrawingNode';
    import { LineCurve2dDrawingNode } from 'sk/data/family/model/brep/drawing/curve2d/LineCurve2dDrawingNode';
    import { PointDrawingNode } from 'sk/data/family/model/brep/drawing/PointDrawingNode';
    import { ProfileElement } from 'sk/data/family/structure/profile/element/ProfileElement';
    import { ProfileNode } from 'sk/data/family/structure/profile/model/ProfileNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { NestElementCache, NestElementPerformer } from "sk/rule/data/performer/NestElementPerformer";
    type PointDrawingNodeMap = {
        [key: string]: PointDrawingNode;
    };
    type LineCurve2dDrawingNodeMap = {
        [key: string]: LineCurve2dDrawingNode;
    };
    type CircleArc2Curve2dDrawingNodeMap = {
        [key: string]: CircleArc2Curve2dDrawingNode;
    };
    export class ProfileElementCache extends NestElementCache {
        pointMap: PointDrawingNodeMap;
        lineMap: LineCurve2dDrawingNodeMap;
        circleArcMap: CircleArc2Curve2dDrawingNodeMap;
        circleMap: CircleCurve2dDrawingNodeMap;
        constructor();
    }
    export class ProfileChildElementCache extends ElementCache {
        profileElementCache: ProfileElementCache;
        profileNode: ProfileNode;
        constructor();
    }
    export class ProfileElementPerformer extends NestElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ProfileElement): ProfileElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ProfileElement): ProfileNode;
        computeProperty(context: ElementPerformerContext, element: ProfileElement, index: number, node: ProfileNode): ResultEnum;
        computePointsProperty(context: ElementPerformerContext, element: ProfileElement, node: ProfileNode): void;
        computeCurvesProperty(context: ElementPerformerContext, element: ProfileElement, node: ProfileNode): void;
        computeStructureAfter(context: ElementPerformerContext, element: ProfileElement, node: ProfileNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/structure/SpatialStructElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BlueprintNode } from 'foundation/data/common/model/base/BlueprintNode';
    import { DataNode, DataNodeMap } from 'foundation/data/common/model/base/DataNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { SpatialStructureElement } from 'sk/data/family/element/brep/SpatialStructureElement';
    import { BoundaryNode } from 'sk/data/family/model/assistant/BoundaryNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { StructureElementPerformer } from "sk/rule/data/performer/StructureElementPerformer";
    export class SpatialStructElementCache extends ElementCache {
        boundaryNode: BoundaryNode;
        clearRemoveMap(node: DataNode, removeMap?: DataNodeMap): void;
    }
    export class SpatialStructElementPerformer extends StructureElementPerformer {
        createCache(context: ElementPerformerContext): SpatialStructElementCache;
        computeStructureBefore(context: ElementPerformerContext, element: Element, node: DataNode): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: SpatialStructureElement, index: number, node: BlueprintNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/Text2dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Text2dElement } from 'sk/data/family/element/assistant/text/Text2dElement';
    import { Text2dNode } from 'sk/data/family/model/assistant/text/Text2dNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class Text2dElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: Text2dElement): Text2dNode;
        computeProperty(context: ElementPerformerContext, element: Text2dElement, index: number, node: Text2dNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/vision/MeshResourceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MeshResourceNode } from 'foundation/data/common/model/brep/vision/MeshResourceNode';
    import { MeshResourceElement } from 'sk/data/family/element/brep/vision/MeshResourceElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class MeshResourceElementPerformer extends ContentElementPerformer {
        protected _modelDocumentService: ModelDocumentService;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: MeshResourceElement): MeshResourceElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: MeshResourceElement): MeshResourceNode;
        onPrepareAsync(context: ElementPerformerContext, containerElement: BrepElement, element: MeshResourceElement): Promise<ElementPerformerResult>;
        computeContentLengthX(element: MeshResourceElement, node: MeshResourceNode): number;
        computeContentLengthY(element: MeshResourceElement, node: MeshResourceNode): number;
        computeContentLengthZ(element: MeshResourceElement, node: MeshResourceNode): number;
        computeProperty(context: ElementPerformerContext, element: MeshResourceElement, index: number, node: MeshResourceNode): ResultEnum;
    }
}
declare module "sk/rule/data/performer/vision/VisionLineModelElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { VisionLineModelNode } from 'foundation/data/common/model/brep/vision/VisionLineModelNode';
    import { VisionLineModelElement } from 'sk/data/family/element/brep/vision/VisionLineModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class VisionLineModelElementPerformer extends ContentElementPerformer {
        protected _modelDocumentService: ModelDocumentService;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: VisionLineModelElement): VisionLineModelElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: VisionLineModelElement): VisionLineModelNode;
        computeProperty(context: ElementPerformerContext, element: VisionLineModelElement, index: number, node: VisionLineModelNode): ResultEnum;
        computeStructureAfterAsync(context: ElementPerformerContext, element: VisionLineModelElement, node: VisionLineModelNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/performer/vision/VisionModelElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { VisionModelNode } from 'foundation/data/common/model/brep/vision/VisionModelNode';
    import { VisionModelElement } from 'sk/data/family/element/brep/vision/VisionModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class VisionModelElementPerformer extends ContentElementPerformer {
        protected _modelDocumentService: ModelDocumentService;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: VisionModelElement): VisionModelElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: VisionModelElement): VisionModelNode;
        onPrepareAsync(context: ElementPerformerContext, containerElement: BrepElement, element: VisionModelElement): Promise<ElementPerformerResult>;
        computeContentLengthX(element: VisionModelElement, node: VisionModelNode): number;
        computeContentLengthY(element: VisionModelElement, node: VisionModelNode): number;
        computeContentLengthZ(element: VisionModelElement, node: VisionModelNode): number;
        computeProperty(context: ElementPerformerContext, element: VisionModelElement, index: number, node: VisionModelNode): ResultEnum;
    }
}
declare module "sk/rule/data/resource/performer/EffectElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { EffectElement } from 'sk/data/resource/effect/element/EffectElement';
    import { EffectNode } from 'sk/data/resource/effect/model/EffectNode';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class EffectElementPerformer extends BrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: EffectElement): EffectNode;
    }
}
declare module "sk/rule/data/resource/performer/EffectMaterialElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { EffectMaterialElement } from 'sk/data/resource/effect/element/EffectMaterialElement';
    import { EffectMaterialNode } from 'sk/data/resource/effect/model/EffectMaterialNode';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class EffectMaterialElementPerformer extends BrepElementPerformer {
        setField(node: any, element: any, fieldNames: any[]): void;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: EffectMaterialElement): EffectMaterialNode;
    }
}
declare module "sk/rule/data/resource/performer/MaterialElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { MaterialElement } from 'sk/data/resource/material/element/MaterialElement';
    import { MaterialNode } from 'sk/data/resource/material/model/MaterialNode';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class MaterialElementPerformer extends BrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: MaterialElement): MaterialNode;
    }
}
declare module "sk/rule/data/resource/performer/MaterialMaterialElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { MaterialMaterialElement } from 'sk/data/resource/material/element/MaterialMaterialElement';
    import { MaterialMaterialNode } from 'sk/data/resource/material/model/MaterialMaterialNode';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class MaterialMaterialElementPerformer extends BrepElementPerformer {
        setField(node: any, element: any, fieldNames: any[]): void;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: MaterialMaterialElement): MaterialMaterialNode;
    }
}
declare module "sk/rule/data/resource/performer/ModelElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ModelElement } from 'sk/data/resource/model/element/ModelElement';
    import { ModelNode } from 'sk/data/resource/model/model/ModelNode';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class ModelElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: Element, element: ModelElement): ModelNode;
        computeProperty(context: ElementPerformerContext, element: ModelElement, index: number, node: ModelNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: ModelElement, node: ModelNode, parameters?: any): ResultEnum;
    }
}
declare module "sk/rule/data/resource/performer/ModelGeometryElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ModelGeometryElement } from 'sk/data/resource/model/element/ModelGeometryElement';
    import { ModelGeometryNode } from 'sk/data/resource/model/model/ModelGeometryNode';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class ModelGeometryElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: Element, element: ModelGeometryElement): ModelGeometryNode;
        computeProperty(context: ElementPerformerContext, element: ModelGeometryElement, index: number, node: ModelGeometryNode): ResultEnum;
    }
}
declare module "sk/rule/data/resource/performer/ModelMaterialElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ModelMaterialElement } from 'sk/data/resource/model/element/ModelMaterialElement';
    import { ModelMaterialNode } from 'sk/data/resource/model/model/ModelMaterialNode';
    import { DataElementPerformer } from "sk/rule/data/base/element/DataElementPerformer";
    export class ModelMaterialElementPerformer extends DataElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: Element, element: ModelMaterialElement): ModelMaterialNode;
        computeProperty(context: ElementPerformerContext, element: ModelMaterialElement, index: number, node: ModelMaterialNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: ModelMaterialElement, node: ModelMaterialNode, parameters?: any): ResultEnum;
    }
}
declare module "sk/rule/data/resource/performer/ModelMeshElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ModelMeshElement } from 'sk/data/resource/model/element/ModelMeshElement';
    import { ModelMeshNode } from 'sk/data/resource/model/model/ModelMeshNode';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class ModelMeshElementPerformer extends ContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: Element, element: ModelMeshElement): ModelMeshNode;
        computeProperty(context: ElementPerformerContext, element: ModelMeshElement, index: number, node: ModelMeshNode): ResultEnum;
        computeStructureAfter(context: ElementPerformerContext, element: ModelMeshElement, node: ModelMeshNode, parameters?: any): ResultEnum;
    }
}
declare module "sk/rule/data/resource/performer/ResourcePictureElementPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ResourcePictureElement } from 'sk/data/resource/base/element/ResourcePictureElement';
    import { PictureNode } from 'sk/data/resource/picture/model/PictureNode';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class ResourcePictureElementPerformer extends BrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: ResourcePictureElement): PictureNode;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleCeilingHangingElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { AssembleIntegrationCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleIntegrationCeilingPatternElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { PolygonAreaData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    export class AssembleCeilingHangingElementUtil {
        protected static _calculatorService: CalculatorService;
        static getAreasFromCeilingSurfaces(roomNode: RoomNode): Array<{
            polygons: Array<Array<Vector2>>;
            surface: CeilingSurfaceElement;
        }>;
        private static createAssembleCeilingHanging;
        private static computeColumnPolygon;
        private static computeColumnPolygonV2;
        static setAssembleCeilingHangingProperty(element: PatternInstanceElement, area: PolygonAreaData, thickness?: number): void;
        static getIntegrationParametersAsync(context: ElementPerformerContext, assembleIntegerationCeiling: AssembleIntegrationCeilingPatternElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/baseoutlinebuilder/data/FlatWallOutlineParas" {
    export class FlatWallOutlineParas {
        x: number;
        y: number;
        width: number;
        height: number;
        length: number;
        rotationZ: number;
        constructor();
        set(oriX: number, oriY: number, width: number, height: number, length: number, rotationZ: number): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/baseoutlinebuilder/data/OutlineFlatwallHoleType" {
    export class OutlineFlatwallHoleType {
        static VerticalBeam: string;
        static ParalerBeam: string;
        static door: string;
        static window: string;
        static plankSeperated: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/baseoutlinebuilder/data/FlatWallOutlineSingleStructInfo" {
    import { CubeHoleStructure } from 'foundation/data/common/structure/CubeHoleStructure';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallSingleStructInfo } from "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallSingleStructInfo";
    export class FlatWallOutlineSingleStructInfo extends FlatWallSingleStructInfo {
        flatwallElement: FlatWallElement;
        constructor(assembleFlatWall: AssembleFlatWallElement, walllNode?: WallNode);
        getlayoutArea(): FlatWallLayoutArea;
        protected computeWallLineByFramePara(bReverse: boolean): void;
        protected setFlatWallProp(layoutArea: FlatWallLayoutArea): void;
        protected setVerticalBeamProp(wallThickness: number, beam: BeamArea, hole: CubeHoleStructure): void;
        protected setParaBeamProp(wallThickness: number, beam: BeamArea, hole: CubeHoleStructure): void;
        protected computeFlatWallLines(layoutArea: FlatWallLayoutArea, innerStartExtend: number, innerEndExtend: number, outStartExtend: number, outerEndExtend: number): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/baseoutlinebuilder/FlatwallOutlineBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatwallBuilder } from "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallBuilder";
    export class FlatwallOutlineBuilder extends FlatwallBuilder {
        initFlatWallElementAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<ContentElement>>;
        buildFromFrameParas(context: RuleProcessContext, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        construWallInfoFromSingleFrameContainerAsync(resultElement: AssembleFlatWallElement): Promise<void>;
    }
}
declare module "sk/rule/data/rule/assemble/OutlineFlatWallElementUtils" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { FlatWallOutlineParas } from "sk/rule/data/rule/flatwalllayout/baseoutlinebuilder/data/FlatWallOutlineParas";
    import { FlatWallElementUtil } from "sk/rule/data/rule/assemble/FlatWallElementUtil";
    export class OutlineFlatWallElementUtils extends FlatWallElementUtil {
        static createFlatWallElementFromOutlinesAsync(context: ContextObject, element: FlatWallElement, outLineParas?: FlatWallOutlineParas): Promise<ResultObject<FlatWallElement>>;
        static updateFlatWallAsync(context: ContextObject, element: FlatWallElement, calculateType?: BuildStructureTypeEnum): Promise<ResultObject>;
        static setFlatWallDatas(flatwallelement: FlatWallElement, outLineParas: FlatWallOutlineParas): void;
        static computeFlatWallStruct(element: FlatWallElement): void;
        static buildFlatWallFromOutlineAsync(context: ContextObject, element: AssembleFlatWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/AssembleFloorplanElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BathroomLayoutAreaElement } from 'sk/data/family/element/instance/BathroomLayoutAreaElement';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { FloorplanNode } from 'sk/data/scheme/database/floorplan/model/FloorplanNode';
    import { AssembleFloorplanElement } from 'sk/data/scheme/database/pattern/element/AssembleFloorplanElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    export class AssembleFloorplanElementUtil {
        static createAssembleRoomsAsync(assembleFloorplan: AssembleFloorplanElement, floorplan: FloorplanNode): Promise<ResultObject>;
        static updateAssembleFloorplanAsync(floorplan: FloorplanElement): Promise<void>;
        static refreshAssembleFloorplan(floorplan: FloorplanElement): void;
        private static refreshFlatWall;
        private static showFlatWallLinkWalls;
        static refreshBathroom(bathroom: BathroomElement): void;
        static refreshBathroomLayout(layout: BathroomLayoutAreaElement): void;
        static refreshAssembleRoom(assembleRoom: AssembleRoomElement): void;
    }
}
declare module "sk/rule/data/rule/assemble/BathroomFloorWetUtil" {
    export class BathroomFloorWetUtil {
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/BeamContentModel" {
    import { AroundBox } from 'foundation/data/common/model/base/AroundBox';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class BeamContentModel extends ContentBase {
        startContraction: number;
        endContraction: number;
        aroundBox: AroundBox;
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/FixedLevelerComponent" {
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    export class FixedLevelerComponent extends FamilyContentBase {
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/calculator/LayoutLevelerCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SurveyLineBase } from "sk/rule/data/rule/assemble/beam/calculator/layout/SurveyLineBase";
    export class LayoutLevelerCalculator {
        outlines: Array<SurveyLineBase>;
        horizontalLines: Array<SurveyLineBase>;
        verticalLines: Array<SurveyLineBase>;
        constructor();
        compute(outlines: Array<Vector3>, holes: Array<Array<Vector2>>, points: Array<Vector3>): void;
        calculateOutlines(outlines: Array<Vector3>, holes: Array<Array<Vector2>>): void;
        calculateHorizontalLines(point: Vector3): void;
        calculateVerticalLines(point: Vector3): void;
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/layout/PlankSpliter" {
    export class PlankSpliter {
    }
}
declare module "sk/rule/data/rule/assemble/beam/calculator/MetalLevelerComponent" {
    import { FamilyContentBase } from "sk/rule/data/rule/assemble/beam/base/FamilyContentBase";
    export class MetalLevelerComponent extends FamilyContentBase {
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/CeilingSplitData" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class CeilingSplitData {
        areas: {
            typeCode: string;
            polygon: Vector2[];
        }[];
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        splitAsync(context: ElementPerformerContext, room: RoomNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/CompositeCeilingContext" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssembleCompositeCeilingPatternElement } from 'sk/data/family/database/pattern/element/AssembleCompositeCeilingPatternElement';
    import { CompositeCeilingPatternElement } from 'sk/data/family/database/pattern/element/CompositeCeilingPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { ProxyCeilingElement } from 'sk/data/scheme/database/pattern/element/ProxyCeilingElement';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class CompositeCeilingContext {
        document: SchemeDocument;
        roomNode: RoomNode;
        ceiling: ProxyCeilingElement;
        context: ContextObject;
        proxyCeilingInfoId: string;
        proxyPatternCeiling: CompositeCeilingPatternElement;
        assembleCeilingInfoId: string;
        assemblePatternCeiling: AssembleCompositeCeilingPatternElement;
        assembleLevelingCeilingInfoId: string;
        assembleCeilingEdgeInfoId: string;
        assembleCeilingPlaneInfoId: string;
        loadCeilingParamsAsync(context: ElementPerformerContext, referenceInfoId: string): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeParamers" {
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    export type CompositeCeilingEdgeParamers = {
        thickness: number;
        straightWareId: string;
        straightWareWidth: number;
        straightWareHeight: number;
        straightWareStandardLength: number;
        straightWareMinLength: number;
        cornerWareId: string;
        cornerWareWidth: number;
        cornerWareHeight: number;
        cornerWareThickness: number;
        ceilingClipKeelId: string;
        ceilingClipKeelThick: number;
        ceilingClipKeelWidth: number;
        ceilingClipKeelSTLength: number;
        ceilingClipKeelHeight: number;
        ceilingClipKeelMinLength: number;
        ceilingclipKeelStepRuleValue: number;
        ceilingclipKeelArrangeParralelEndRemain: number;
        ceilingclipKeelArrangeVerticalEndRemain: number;
        ceilingclipKeelClawCenterToEndValue: number;
        ceilingclipKeelSteeveToKeelEndValue: number;
        ceilingclipKeelSteeveModule: number;
        hangingPlankId: string;
        hangingPlankStandardWidth: number;
        hangingPlankStandardHeight: number;
        hangingPlankThickness: number;
        hangingPlankMinLength: number;
        hangingPlaneNail2Side: number;
        hangingPlaneNail2End: number;
        hangingPlaneNailMoudle: number;
        hangingPlaneNailMinGap: number;
        ceilingEdgeKeelId: string;
        ceilingEdgeKeelHeight: number;
        ceilingEdgeKeelUpWidth: number;
        ceilingEdgeKeelDownWidth: number;
        ceilingEdgeKeelStandardLength: number;
        ceilingEdgeKeelThick: number;
        ceilingEdgeKeelMinLength: number;
        ceilingEdgeKeelNail2End: number;
        ceilingEdgeKeelNailModule: number;
        ceilingEdgeKeelNailMinGap: number;
        angleKeelID: string;
        angleKeelWidth: number;
        angleKeelHeight: number;
        angleKeelThickness: number;
        angleKeelStandardLength: number;
        angleKeelMinLength: number;
        angleKeelBolt2Side: number;
        angleKeelBolt2End: number;
        angleKeelBoltMoudle: number;
        angleKeelBoltMinGap: number;
        ceilingViceKeelId: string;
        ceilingViceThick: number;
        ceilingViceHeight: number;
        ceilingViceSTLength: number;
        ceilingViceWidth: number;
        ceilingViceSideLength: number;
        horizontalConnectionId: string;
        horizontalConnectionLength: number;
        horizontalConnectionHeight: number;
        horizontalConnectionWidth: number;
        horizontalConnectionThick: number;
        viceKeelHangingID: string;
        viceKeelHangingLengthX: number;
        viceKeelHangingLengthY: number;
        viceKeelHangingLengthZ: number;
        viceKeelHangingThick: number;
        viceKeelHanging2plankLappedConnection: number;
        viceKeelHanging2plankStraightConnection: number;
        viceKeelHangingModule: number;
        viceKeelHangingMinGap: number;
        viceKeelHangingNail2HangingPlaneSide: number;
        plankStraightConnectionID: string;
        plankStraightConnectionLengthX: number;
        plankStraightConnectionLengthY: number;
        plankStraightConnectionLengthZ: number;
        plankLappedConnectionID: string;
        plankLappedConnectionLengthX: number;
        plankLappedConnectionLengthY: number;
        plankLappedConnectionLengthZ: number;
        ceilingPlasterPlankId: string;
        ceilingPlasterPlankThick: number;
        ceilingPlasterPlankSTWidth: number;
        ceilingPlasterPlankSTLength: number;
        ceilingPlasterPlankMinWidth: number;
        ceilingPlasterPlankMinLength: number;
        screw6BoltId: string;
        screw8BoltId: string;
        clipKeelSteeveId: string;
        dryWallNail25Id: string;
        nail25Id: string;
        decorateFaceId: string;
        lowerWidthD: number;
        mgrgBottomWidthM: number;
        mgrgBottomWidthM1: number;
        lowerToCeilingHeight: number;
        angleKeelBegin2Wall: number;
        angleKeelEnd2Wall: number;
        buildType: BuildStructureTypeEnum;
    };
}
declare module "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeCalculatorInput" {
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { CompositeCeilingEdgeParamers } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeParamers";
    export class CompositeCeilingEdgeCalculatorInput {
        thickness: number;
        polySurface: LayoutablePolySurface;
        params: CompositeCeilingEdgeParamers;
    }
}
declare module "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeCalculatorOutput" {
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { LoDbPlank } from "sk/rule/data/rule/layout/entitys/LoDbPlank";
    import { LoDbReferenceLine } from "sk/rule/data/rule/layout/entitys/LoDbReferenceLine";
    export class CompositeCeilingEdgeCalculatorOutput {
        edgeKeels: Array<LoDbEntity>;
        nail25s: Array<LoDbEntity>;
        topAngleKeels: Array<LoDbEntity>;
        bolts: Array<LoDbEntity>;
        ceilingPlanks: Array<LoDbEntity>;
        plankStraightConnections: Array<LoDbEntity>;
        plankLappedConnections: Array<LoDbEntity>;
        viceKeelHangings: Array<LoDbEntity>;
        viceKeels: Array<LoDbEntity>;
        straightConnectionBasePlates: Array<LoDbEntity>;
        horizontalConnections: Array<LoDbEntity>;
        basedPlanks: Array<LoDbPlank>;
        surfacePlanks: Array<LoDbPlank>;
        clipKeels: Array<LoDbEntity>;
        clipKeelSteeves: Array<LoDbEntity>;
        layer: Array<LoDbEntity>;
        referenceLines: Array<LoDbReferenceLine>;
        constructor();
    }
}
declare module "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgePolygonLayoutData" {
    import { CeilingEdgeHoldTypeEnum } from 'sk/data/family/enumeration/pattern/rule/assemble/ceiling/CeilingEdgeHoldTypeEnum';
    import { AssembleCeilingEdgeElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class CompositeCeilingEdgePolygonLayoutData extends ContentBase {
        prev: AssembleCeilingEdgeElement;
        next: AssembleCeilingEdgeElement;
        leftHoldType: CeilingEdgeHoldTypeEnum;
        rightHoldType: CeilingEdgeHoldTypeEnum;
        identifier: number;
    }
}
declare module "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { AssemblyCeilingModelCalculator } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingModelCalculator";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { CompositeCeilingEdgeCalculatorInput } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeCalculatorInput";
    import { CompositeCeilingEdgeCalculatorOutput } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeCalculatorOutput";
    import { CompositeCeilingEdgeParamers } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeParamers";
    import { CompositeCeilingEdgePolygonLayoutData } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgePolygonLayoutData";
    export class PlasterPlank {
        origin: Vector3;
        lengthX: number;
        lengthY: number;
        nailsLines: Array<LayoutableLine>;
        constructor(origin?: Vector3, lengthX?: number, lengthY?: number);
    }
    export class CompositeCeilingEdgeCalculator extends AssemblyCeilingModelCalculator {
        input: CompositeCeilingEdgeCalculatorInput;
        output: CompositeCeilingEdgeCalculatorOutput;
        inputParams: CompositeCeilingEdgeParamers;
        layoutData: CompositeCeilingEdgePolygonLayoutData;
        private viceKeelIdentifier;
        private angleKeelIdentifier;
        private edgeKeelIdentifier;
        private hangingPlankIdentifier;
        private clipKeelIdentifier;
        calculateLayerComponent(input: CompositeCeilingEdgeCalculatorInput, output: CompositeCeilingEdgeCalculatorOutput): ResultObject;
        calculateComponent(input: CompositeCeilingEdgeCalculatorInput, output: CompositeCeilingEdgeCalculatorOutput): ResultObject;
        private calculateSimplifyBasePlank;
        private calculateSimplifySurfacePlank;
        private calculateEdgeKeels;
        private calculateKeelNails;
        private calculateOutsideEdgeKeels;
        private calculateFixedKeels;
        private calculateSurveyFromLayoutableLine;
        private calculateSurveyFromPoint;
        private calculateBolts;
        private calculateHangingPlanks;
        private calculateStraightConnection;
        private calculateLappedConnection;
        private calculateViceKeelHangings;
        private calculateViceKell;
        private calculateViceKeelCorner;
        private calculateViceKeelBeginCorner;
        private calculateViceKeelEndCorner;
        calculateViceKeelOverhang(viceKeelPoints: Array<Vector3>): void;
        calculateBasePlasterPlanks(viceKeelPoints: Array<Vector3>): void;
        calculateSufacePlasterPlanks(viceKeelPoints: Array<Vector3>, riskPoints: Array<Vector3>): void;
        calculateClipKeels(viceKeelPoints: Array<Vector3>): void;
        calculateClipViceSteeves(layoutline: LayoutableLine): void;
        calcualteBasePlasterPlankNail(plasterPlank: PlasterPlank): void;
        calcualteSurfacePlasterPlankNail(plasterPlank: PlasterPlank): void;
    }
}
declare module "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeModelProcess" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { CompositeCeilingEdgeCalculatorInput } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeCalculatorInput";
    import { CompositeCeilingEdgeCalculatorOutput } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeCalculatorOutput";
    import { CompositeCeilingEdgeParamers } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeParamers";
    import { CompositeCeilingEdgePolygonLayoutData } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgePolygonLayoutData";
    export class CompositeCeilingEdgeModelProcess {
        layoutData: CompositeCeilingEdgePolygonLayoutData;
        protected _schemeConfigService: SchemeConfigService;
        protected _calculatorService: CalculatorService;
        buildAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, layoutData: CompositeCeilingEdgePolygonLayoutData, params: CompositeCeilingEdgeParamers): Promise<RuleProcesResult>;
        buildLayerAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, layoutData: CompositeCeilingEdgePolygonLayoutData, params: CompositeCeilingEdgeParamers): Promise<RuleProcesResult>;
        calculateLayerProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: CompositeCeilingEdgeCalculatorInput): Promise<RuleProcesResult>;
        calculateProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: CompositeCeilingEdgeCalculatorInput): Promise<RuleProcesResult>;
        outputProcessAsync(context: ElementPerformerContext, calculatorInput: CompositeCeilingEdgeCalculatorInput, calculatorOutput: CompositeCeilingEdgeCalculatorOutput, input: RuleProcessInput, output: RuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeBuilder" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { CompositeCeilingEdgeParamers } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgeParamers";
    import { CompositeCeilingEdgePolygonLayoutData } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgePolygonLayoutData";
    export class CompositeCeilingEdgeBuilder {
        private layoutData;
        private params;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: CompositeCeilingEdgePolygonLayoutData, params: CompositeCeilingEdgeParamers);
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcesResult>;
        buildLayerAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/CompositeCeilingEdgeElementUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { AssembleCeilingEdgeElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { CeilingEdgeParamers } from "sk/rule/data/rule/lappedceilinglayout/edge/CeilingEdgeParamers";
    import { CompositeCeilingEdgePolygonLayoutData } from "sk/rule/data/rule/compositeceilinglayout/CompositeCeilingEdgePolygonLayoutData";
    export class CompositeCeilingEdgeElementUtil {
        protected static _schemeConfigService: SchemeConfigService;
        static updateCeilingElementAsync(context: ContextObject, ceilingEdgeElement: AssembleCeilingEdgeElement, buildType: BuildStructureTypeEnum, params?: any): Promise<ResultObject>;
        static getLayoutDataFromCeilingEdge(ceilingEdge: AssembleCeilingEdgeElement): CompositeCeilingEdgePolygonLayoutData;
        static clearCeilingElement(element: AssembleCeilingEdgeElement): void;
        static getDefaultParams(): CeilingEdgeParamers;
        static findRelationRoom(element: PatternInstanceElement): RoomElement;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/data/CompositeCeilingEdgeContent" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class EdgeLineTypeEnum {
        static nearWall: string;
        static nearPlaneCeiling: string;
        static nearProxyCeilingPlane: string;
        static neraProxyCeilingEdge: string;
    }
    export class CeilingEdgeLine extends Line2 {
        relationPolygon: {
            typeCode: string;
            polygon: Vector2[];
        };
        relationElement: PatternInstanceElement;
        edgeLineTypeEnum: EdgeLineTypeEnum;
    }
    export class CompositeCeilingEdgeContent extends ContentBase {
        identifier: number;
        area: {
            typeCode: string;
            polygon: Vector2[];
        };
        ceilingEdgeLines: CeilingEdgeLine[];
        isRectPolygon: boolean;
        morePolygon: Vector2[];
        constructor();
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/CompositeCeilingElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { AssembleCompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCompositeCeilingElement';
    import { CompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/CompositeCeilingElement';
    import { CompositeCeilingEdgeContent } from "sk/rule/data/rule/assemble/ceiling/data/CompositeCeilingEdgeContent";
    import { CeilingSplitData } from "sk/rule/data/rule/assemble/ceiling/CeilingSplitData";
    import { CompositeCeilingContext } from "sk/rule/data/rule/assemble/ceiling/CompositeCeilingContext";
    export class CompositeCeilingElementUtil {
        static createAssembleCeilingAsync(context: ElementPerformerContext, proxyCeiling: CompositeCeilingElement, room: RoomNode, options?: any): Promise<ResultObject>;
        static buildAsync(context: ElementPerformerContext, ceilingElement: AssembleCompositeCeilingElement): Promise<ResultObject>;
        static createCeilingElementByArea(context: ElementPerformerContext, ceilingContext: CompositeCeilingContext, parent: AssembleCompositeCeilingElement, ceilingSplitData: CeilingSplitData, areaInfo: {
            typeCode: string;
            polygon: Vector2[];
        }): void;
        static createAssembleLevelingCeilingElementByArea(context: ElementPerformerContext, ceilingContext: CompositeCeilingContext, parent: AssembleCompositeCeilingElement, areaInfo: {
            type?: any;
            polygon: Vector2[];
        }): any;
        static createAssembleCeilingEdgeElementByArea(context: ElementPerformerContext, ceilingContext: CompositeCeilingContext, parent: AssembleCompositeCeilingElement, ceilingSplitData: CeilingSplitData, areaInfo: {
            type?: any;
            polygon: Vector2[];
        }): any;
        static createAssembleCeilingPlaneElementByArea(context: ElementPerformerContext, ceilingContext: CompositeCeilingContext, parent: AssembleCompositeCeilingElement, areaInfo: {
            type?: any;
            polygon: Vector2[];
        }): any;
        static createAssembleCompositeCeilingElement(context: ElementPerformerContext, ceilingContext: CompositeCeilingContext, parent: NestElement): AssembleCompositeCeilingElement;
        static setPropertyByPolygon(element: PatternInstanceElement, polygon: Value2[], origin?: Value2): void;
        static ceilingPolygonCalculate(ceilingSplitData: CeilingSplitData, area: {
            typeCode: string;
            polygon: Vector2[];
        }): CompositeCeilingEdgeContent;
        static findRelationRoom(element: PatternInstanceElement): RoomElement;
    }
}
declare module "sk/rule/data/rule/assemble/ceiling/LevelingFloorContext" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssembleLevelingFloorPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingFloorPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    export class LevelingFloorContext {
        assembleLevelingFloorFamilyInfo: any;
        assembleLevelingFloorPattern: AssembleLevelingFloorPatternElement;
        hardWareFamilyInfoId: any;
        plankFamilyInfoId: any;
        loadFloorParamsAsync(context: ElementPerformerContext, element: LevelingFloorElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/assemble/CompositeWallElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    import { AssembleLevelingWallPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingWallPatternElement';
    import { CompositeWallPatternElement } from 'sk/data/family/database/pattern/element/CompositeWallPatternElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BeamWallIntersectInfo } from 'sk/data/scheme/database/floorplan/model/util/BeamNodeUtil';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { WallElement } from 'sk/data/scheme/database/floorplan/element/WallElement';
    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 { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { LevelingLayoutParamers } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class CompositeWallElementUtil {
        static createCompositeWallsByWallSurfaceAsync(compositeWall: CompositeWallElement, wallSurfaceNode: WallSurfaceNode): Promise<void>;
        static createLevelingWallsByRoomAsync(assembleContext: AssembleRoomContext, room: RoomNode): Promise<void>;
        static createSplitLevelingWallsAsync(assembleContext: AssembleRoomContext, wallSurfaceNode: WallSurfaceNode, room: RoomNode): Promise<void>;
        private static createCompositeWallsByLineInfosAsync;
        static createCompositeWallElement(assembleContext: AssembleRoomContext, from: Vector2, to: Vector2): any;
        static createAssebmleWallAndDecorateLayer(element: CompositeWallElement): void;
        static createCompositeWallElement2(assembleContext: AssembleRoomContext, position: Vector3, size: Vector3, rotation: Vector3, placeCd: ContentPlaceTypeEnum): any;
        static loadCompositeWallPatternParametersAsync(assembleCompositeWallPattern: CompositeWallPatternElement, assembleWallElementInfoId: string, wallDecorateLinkPattern: LinkerPatternElement, element: CompositeWallElement): Promise<void>;
        static updateLevelingWallDecorateAsync(element: CompositeWallElement): Promise<void>;
        private static updateLevelingWallByDecorate;
        static updateCompositeWallAsync(context: ElementPerformerContext, element: CompositeWallElement, simplify?: boolean): Promise<ResultObject>;
        static updateCompositeWallBaseAsync(context: ElementPerformerContext, element: CompositeWallElement, simplify?: boolean): Promise<ResultObject>;
        static updateCompositeWallSurfaceAsync(context: ElementPerformerContext, element: CompositeWallElement, simplify?: boolean): Promise<ResultObject>;
        static updateCompositeWallDecorateAsync(context: ElementPerformerContext, element: CompositeWallElement, simplify?: boolean): Promise<ResultObject>;
        static getCompositeWallFamilyInfoIdsAsync(context: ElementPerformerContext, element: CompositeWallElement): Promise<ResultObject<{
            levelerId: string;
            boltId: string;
            baseId: string;
            surfaceId: string;
            screwId: string;
            surfaceScrewId: string;
        }>>;
        static getParamsFromLevelingWallAsync(context: ElementPerformerContext, element: CompositeWallElement): Promise<ResultObject<LevelingLayoutParamers>>;
        static setLeveilingWallParamAsync(context: ElementPerformerContext, element: AssembleLevelingWallPatternElement, params: LevelingLayoutParamers): Promise<ResultObject>;
        static buildCompositeWallAsync(context: ElementPerformerContext, element: CompositeWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static buildCompositeLayerWallAsync(context: ElementPerformerContext, element: CompositeWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static getConnectBeamInfosOfLevelingWall(levelingWall: CompositeWallElement): Array<BeamWallIntersectInfo>;
        static getConnectAssembleBeamInfosOfLevelingWall(compositeWall: CompositeWallElement): Array<any>;
        static getBeamInfoOnLine(beam: AssembleBeamElement, line: Line2): any;
        static getThicknessWithSpace(assembleWallElement: CompositeWallElement, spaceThickness: number): number;
        static getThicknessWithDecorate(assembleWallElement: CompositeWallElement, thicknessWithDecorate: number): number;
        static getSpaceThickness(assembleWallElement: CompositeWallElement): number;
        static getDecorateThickness(assembleWallElement: CompositeWallElement): number;
        static updatePlankPressRelationAsync(assembleRoom: AssembleRoomElement): Promise<void>;
        static processFlatwallAsync(curLevelingWall: CompositeWallElement): Promise<void>;
        static getAllSameLineWalls(curWall: WallElement, room: RoomElement): Array<WallElement>;
        static minWallToLineDistance(curWall: WallElement, line: Line2): number;
        static isWallCloseWiseOrder(curWall: WallElement, preLine: Line2): boolean;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatwallWareInfos" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    export class FlatwallWareInfos {
        static enclosedComponent: string;
        static opengingComponent: string;
        static verticalSupportKeel: string;
        static rubberPad: string;
        static heavenKeel: string;
        static earthKeel: string;
        static stullKeel: string;
        static pierceKeel: string;
        static verticalKeel: string;
        static leveler: string;
        static plugBolt: string;
        static beamKeelStrgthComponent: string;
        static hardWareHorizontalKeel: string;
        static antiSkidNail: string;
        static plank: string;
        enclosedComponentID: string;
        opengingComponentID: string;
        verticalSupportKeelID: string;
        rubberPadID: string;
        heavenKeelID: string;
        earthKeelID: string;
        stullKeelID: string;
        pierceKeelID: string;
        verticalKeelID: string;
        levelerID: string;
        plugBoltID: string;
        beamKeelStrgthComponentID: string;
        hardWareHorizontalKeelID: string;
        antiSkidNailID: string;
        plankID: string;
        constructor();
        getComponentIdsAsync(context: ContextObject, flatWallElemet: FlatWallElement): Promise<ResultObject<any>>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData" {
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { FlatwallWareInfos } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatwallWareInfos";
    export class FlatwallBaseData {
        keelContainerWares: Map<string, FamilyInstanceNode[]>;
        innerKeelContainerWares: Map<string, FamilyInstanceNode[]>;
        outerKeelContainerWares: Map<string, FamilyInstanceNode[]>;
        innerPlankContainerWares: Map<string, FamilyInstanceNode[]>;
        outerPlankContainerWares: Map<string, FamilyInstanceNode[]>;
        linkerContainerWares: Map<string, FamilyInstanceNode[]>;
        constructor(flatwallNode: FlatWallNode, flatwallWareInfos: FlatwallWareInfos);
        private getkeelLayerComponents;
        private fillContainerMap;
        private insertMap;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/BaseWareTranslator" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { ContentArea } from "sk/rule/data/rule/levelinglayout/ContentArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    export class BaseWareTranslator {
        constructor();
        static translate(input: FlatWallInput, layoutInfo: FlatWallArea, outputLayoutStruct: FlatWallAreaLayoutOutputStructure, oriDatas: FamilyInstanceNode[]): ContentArea[];
        protected static modelTransToLocalPos(oriData: FamilyInstanceNode, dataPoints: Array<Vector3>): Array<Vector3>;
        protected static worldTransToLocalPos(oriData: FamilyInstanceNode, dataPoints: Array<Vector3>): Array<Vector3>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/HoritionalKeelTranslator" {
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { BaseWareTranslator } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/BaseWareTranslator";
    export class HoritionalKeelTranslator extends BaseWareTranslator {
        static translate(input: FlatWallInput, layoutInfo: FlatWallArea, outputLayoutStruct: FlatWallAreaLayoutOutputStructure, oriDatas: FamilyInstanceNode[]): ContentArea[];
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/LevelersTranslator" {
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { BaseWareTranslator } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/BaseWareTranslator";
    export class LevelersTranslator extends BaseWareTranslator {
        static translate(input: FlatWallInput, layoutInfo: FlatWallArea, outputLayoutStruct: FlatWallAreaLayoutOutputStructure, oriDatas: FamilyInstanceNode[]): ContentArea[];
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/VerticalKeelsTranslator" {
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { BaseWareTranslator } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/BaseWareTranslator";
    export class VerticalKeelsTranslator extends BaseWareTranslator {
        static translate(input: FlatWallInput, layoutInfo: FlatWallArea, outputLayoutStruct: FlatWallAreaLayoutOutputStructure, oriDatas: FamilyInstanceNode[]): ContentArea[];
        private static constructBasicKeel;
        private static setVerticalKeelTypes;
        private static setWallEdgeProp;
        private static setHoleProp;
        private static setBeamProp;
        private static setPlankEdgeProp;
        private static rePosePlankEdge;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallDataBasedHoritionalKeelCalculator" {
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { BeamArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallBeamArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallHoritionalKeelCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallHoritionalKeelCalculator";
    export class FlatWallDataBasedHoritionalKeelCalculator extends FlatWallHoritionalKeelCalculator {
        heavenKeels: ContentArea[];
        earthKeels: ContentArea[];
        verticalKeels: ContentArea[];
        stullKeels: ContentArea[];
        pierceKeels: ContentArea[];
        constructor(input: FlatWallInput, output: FlatWallOutput, wallArea: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        loadBaseDatas(heavenKeels: ContentArea[], earthKeels: ContentArea[], verticalKeels: ContentArea[], stullKeels: ContentArea[], pierceKeels: ContentArea[]): void;
        compute(): void;
        createHeavenPlugBolt(input: FlatWallInput, output: FlatWallOutput, wallArea: FlatWallArea): void;
        protected isCrossBeamBottomHeavenKeel(curKeel: ContentArea): boolean;
        protected calculateSmallHeavenKeelPlugBolt(curKeel: ContentArea): void;
        createBeamHeaveKeelsplugBolts(input: FlatWallInput, output: FlatWallOutput, wallArea: FlatWallArea, crossBeam: BeamArea): void;
        protected computeSectionKeelMiddleStruct(input: FlatWallInput, output: FlatWallOutput, keelStructureHeight: number, verticalFrameStructure: Array<FlatWallVerticalFrameStructure>): void;
        createRubbberPadFromEarthKeels(input: FlatWallInput, output: FlatWallOutput, sectionKeelStart: number, sectionKeelsLength: number): void;
        createPierceKeelHardwareSupportClips(input: FlatWallInput, output: FlatWallOutput, curPierceKeel: ContentArea, sectionKeels: Array<FlatWallVerticalFrameStructure>): void;
        createStullKeelComponents(input: FlatWallInput, output: FlatWallOutput, curStullKeel: ContentArea, sectionKeels: Array<FlatWallVerticalFrameStructure>): void;
        protected createOneStullKeelComponent(input: FlatWallInput, output: FlatWallOutput, preVerticalKeelStruct: FlatWallVerticalFrameStructure, nextVertcialKeelStruct: FlatWallVerticalFrameStructure, stullKeelPosY: number): void;
        createVerticalKeelPlugBoltOneSide(input: FlatWallInput, output: FlatWallOutput, bStart: Boolean, keelStructureHeight: number, wallArea: FlatWallArea): void;
        createEarthPlugBolt(input: FlatWallInput, output: FlatWallOutput, sectionKeelStart: number, sectionKeelsLength: number): void;
        protected getKeelLayerHeight(): number;
        protected getEdgeWallHeight(bStart: Boolean): number;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/PlankStructsTranslator" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicPlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { BaseWareTranslator } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/translator/BaseWareTranslator";
    export class PlankStructsTranslator extends BaseWareTranslator {
        static translate(input: FlatWallInput, layoutInfo: FlatWallArea, outputLayoutStruct: FlatWallAreaLayoutOutputStructure, oriDatas: FamilyInstanceNode[]): ContentArea[];
        protected static transToPlankData(input: FlatWallInput, layoutInfo: FlatWallArea, outputLayoutStruct: FlatWallAreaLayoutOutputStructure, modelLocalPoses: Array<Vector3>, bHReverse: boolean): FlatWallBasicPlankStructure;
        protected static setCurPlankCutLines(plankPoints: Array<Vector3>, basePlank: FlatWallBasicPlankStructure, bHReverse: boolean): void;
        protected static getAllHoleLines(plankPoints: Array<Vector3>, boundary: Array<Vector2>): Array<Array<Line2>>;
        protected static getAllHoleCutLines(boundary: Array<Vector2>, plankPoints: Array<Vector3>, insideLines: Line2[][], leftLine: Line2, rightLine: Line2, bottomLine: Line2, topLine: Line2): Array<Array<Line2>>;
        protected static getNeighbourOutLine(boundary: Array<Vector2>, polygonPoints: Array<Vector2>, holeStartPoint: Vector2): Line2;
        protected static getCurHoleCutLine(curHoleLines: Array<Line2>, startBoundaryLine: Line2, endBoundaryLine: Line2, leftLine: Line2, rightLine: Line2, bottomLine: Line2, topLine: Line2): Array<Line2>;
        protected static reverseHoleLine(curHoleLines: Array<Line2>): Array<Line2>;
        protected static getCoordinateLine(holeLines: Array<Line2>, orginPoint: Vector2): Array<Line2>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallNoVerticalDoorStructCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallDoorStructCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallDoorStructCalculator";
    export class FlatWallNoVerticalDoorStructCalculator extends FlatWallDoorStructCalculator {
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        protected createAllKeelStructs(holeStartPoint: Vector2, holeWidth: number, holeHeight: number, outVerticalKeels: Array<FlatWallVerticalFrameStructure>): boolean;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallNoPlankDoorStructCalculator" {
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallNoVerticalDoorStructCalculator } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallNoVerticalDoorStructCalculator";
    export class FlatWallNoPlankDoorStructCalculator extends FlatWallNoVerticalDoorStructCalculator {
        constructor(input: FlatWallInput, output: FlatWallOutput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        protected createDoorUpStructs(holeArea: OpeningArea): boolean;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallVerticalKeelBasedStructuresManager" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FlatwallBaseData } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    import { FlatWallStructuresManager } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallStructuresManager";
    export class FlatWallVerticalKeelBasedStructuresManager extends FlatWallStructuresManager {
        protected baseData: FlatwallBaseData;
        constructor(input: FlatWallInput, output: FlatWallOutput, layoutAreaArea: FlatWallLayoutArea, verticalData: FlatwallBaseData);
        protected preCalculate(): boolean;
        protected computeVerticals(): boolean;
        protected outputVerticalKeelsStructures(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): Promise<ResultObject>;
        protected outputVerticalsAsync(keelStructs: FlatWallVerticalFrameStructure[]): Promise<void>;
        private seperateVerticals;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallVerticalPlankBasedStructuresManager" {
    import { FlatwallBaseData } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallVerticalKeelBasedStructuresManager } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallVerticalKeelBasedStructuresManager";
    export class FlatWallVerticalPlankBasedStructuresManager extends FlatWallVerticalKeelBasedStructuresManager {
        protected baseData: FlatwallBaseData;
        constructor(input: FlatWallInput, output: FlatWallOutput, layoutAreaArea: FlatWallLayoutArea, verticalData: FlatwallBaseData);
        protected preCalculate(): boolean;
        protected computePlanks(): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallCreateNailsManager" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FlatwallBaseData } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallVerticalPlankBasedStructuresManager } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/manager/FlatWallVerticalPlankBasedStructuresManager";
    export class FlatWallCreateNailsManager extends FlatWallVerticalPlankBasedStructuresManager {
        protected baseData: FlatwallBaseData;
        constructor(input: FlatWallInput, output: FlatWallOutput, layoutAreaArea: FlatWallLayoutArea, verticalData: FlatwallBaseData);
        protected preCalculate(): boolean;
        protected midCalculate(): void;
        protected computeHoritionalComponents(): void;
        protected computeLevers(): void;
        protected outPutStruct(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): boolean;
        protected outputVerticalKeelsStructures(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): Promise<ResultObject>;
        protected outputLelvers(outputLayoutStruct: FlatWallAreaLayoutOutputStructure): void;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/FlatWallBaseDataManager" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { FlatwallBaseData } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData";
    import { FlatwallWareInfos } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatwallWareInfos";
    export class FlatWallBaseDataManager {
        context: ContextObject;
        flatWallNode: FlatWallNode;
        flatwallWareInfos: FlatwallWareInfos;
        flatwallBaseData: FlatwallBaseData;
        constructor(context: ContextObject, flatWallNode: FlatWallNode);
        getFlatWallBaseDataAsync(): Promise<ResultObject<any>>;
    }
}
declare module "sk/rule/data/rule/assemble/FlatWallActionsUtils" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { WallElement } from 'sk/data/scheme/database/floorplan/element/WallElement';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    export class FlatWallActionsUtil {
        static getLinkedOriginWalls(elements: FlatWallElement[]): WallElement[];
        static updateFlatWallAsync(context: ContextObject, element: FlatWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateConnectedFlatWallAsync(context: ContextObject, element: FlatWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/FlatWallVerticalKeelBasedWareBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { CowallNode } from 'sk/data/scheme/database/floorplan/model/CowallNode';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatwallBuilder } from "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallBuilder";
    import { FlatwallBaseData } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData";
    export class FlatWallVerticalKeelBasedWareBuilder extends FlatwallBuilder {
        flatwallNode: FlatWallNode;
        constructor(flatWallNode: FlatWallNode);
        buildStruct(context: RuleProcessContext, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput, curWall?: CowallNode): void;
        initFlatWallElementAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<ContentElement>>;
        calculateFlatWallComponentResultAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        getBaseDataAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        getFlatWallResultAsync(layoutAreaArea: FlatWallLayoutArea, baseData: FlatwallBaseData): Promise<ResultObject<any>>;
        buildFromFrameParas(context: RuleProcessContext, resultElement: AssembleFlatWallElement, rectModelInput: FlatWallInput): void;
        construWallInfoFromSingleFrameContainerAsync(resultElement: AssembleFlatWallElement): Promise<void>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/FlatWallCreateNailsBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallAntiSkidNail25 } from "sk/rule/data/rule/flatwalllayout/calculator/FlatWallAntiSkidNail25";
    import { FlatwallBaseData } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData";
    import { FlatWallVerticalKeelBasedWareBuilder } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/FlatWallVerticalKeelBasedWareBuilder";
    export class FlatWallCreateNailsBuilder extends FlatWallVerticalKeelBasedWareBuilder {
        flatwallNode: FlatWallNode;
        constructor(flatWallNode: FlatWallNode);
        initFlatWallElementAsync(): Promise<ResultObject<ContentElement>>;
        virtualObjectShowingManagerAsync(element: ContentElement): Promise<ResultObject>;
        computeContianerPos(): boolean;
        createContainers(element: ContentElement, bSingleWall: boolean): void;
        showKeels(): void;
        processSingleKeelFlatwallAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        processDoubleKeelFlatwallAsync(calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        calculateFlatWallComponentResultAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        getBaseDataAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        getFlatWallResultAsync(layoutAreaArea: FlatWallLayoutArea, baseData: FlatwallBaseData): Promise<ResultObject<any>>;
        fillContainerKeelsComponentAsync(layer: number, rectModelInput: FlatWallInput, keelContainer: ContainerElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
        fillBaseNailsOneSideAsync(baseNails: Array<FlatWallAntiSkidNail25>, plankContainer: ContainerElement, calculateType: BuildStructureTypeEnum): Promise<ResultObject<any>>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/basedatabuilder/FlatWallVerticalPlankBasedWareBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatwallBaseData } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/data/FlatWallBaseData";
    import { FlatWallVerticalKeelBasedWareBuilder } from "sk/rule/data/rule/flatwalllayout/basedatabuilder/FlatWallVerticalKeelBasedWareBuilder";
    export class FlatWallVerticalPlankBasedWareBuilder extends FlatWallVerticalKeelBasedWareBuilder {
        flatwallNode: FlatWallNode;
        constructor(flatWallNode: FlatWallNode);
        calculateFlatWallComponentResultAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        getBaseDataAsync(layoutAreaArea: FlatWallLayoutArea): Promise<ResultObject<any>>;
        getFlatWallResultAsync(layoutAreaArea: FlatWallLayoutArea, baseData: FlatwallBaseData): Promise<ResultObject<any>>;
    }
}
declare module "sk/rule/data/rule/assemble/EditorFlatWallGeneratedUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { CowallNode } from 'sk/data/scheme/database/floorplan/model/CowallNode';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { ConnectedWallPlankParas } from "sk/rule/data/rule/assemble/FlatWallElementUtil";
    export class EditorFlatWallGeneratedType {
        static VerticalKeelsGenerated: string;
        static VerticalKeelsAndPlanksGenerated: string;
        static NailGenerated: string;
    }
    export class EditorFlatWallGeneratedUtil {
        protected static _calculateService: CalculatorService;
        static updateConnectedFlatWallFromWallsAndDatasAsync(flatwallNode: FlatWallNode, generatedType: EditorFlatWallGeneratedType, calculateType: BuildStructureTypeEnum): Promise<ResultObject>;
        static computeFlatWallNailsAsync(context: ContextObject, flatwallNode: FlatWallNode, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static updateFlatWallFromWallAndDatasAsync(context: ContextObject, flatwallNode: FlatWallNode, generatedType: EditorFlatWallGeneratedType, simple?: boolean): Promise<ResultObject>;
        static buildFlatWallAsync(context: ContextObject, flatwallNode: FlatWallNode, buildType: BuildStructureTypeEnum, generatedType: EditorFlatWallGeneratedType, cowallNode?: CowallNode): Promise<ResultObject>;
        static buildFlatWallFromWallsAsync(context: ContextObject, flatwallNode: FlatWallNode, wallNodes: Array<WallNode>, plankPara: ConnectedWallPlankParas, buildType: BuildStructureTypeEnum, generatedType: EditorFlatWallGeneratedType): Promise<ResultObject>;
        static generateDefaultRuleContext(element: FlatWallElement): RuleProcessContext;
    }
}
declare module "sk/rule/data/rule/assemble/kitchenroom/KitchenroomCabinetElementUtil" {
    import { KitchenroomFloorCabinetElement } from 'sk/data/scheme/database/pattern/element/KitchenroomFloorCabinetElement';
    export class KitchenroomCabinetElementUtil {
        static deleteKitchenroomCabinet(kitchenroomCabinet: KitchenroomFloorCabinetElement): void;
        static updateKitchenroomAsync(): Promise<void>;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/LappedCeilingParamers" {
    export type LappedCeilingParamers = {
        thickness: number;
        straightWareId: string;
        straightWareWidth: number;
        straightWareHeight: number;
        straightWareStandardLength: number;
        cornerWareId: string;
        cornerWareWidth: number;
        cornerWareHeight: number;
        cornerWareThickness: number;
        basePlankId: string;
        basePlankStandardWidth: number;
        basePlankStandardHeight: number;
        basePlankThickness: number;
        basePlankMinLength: number;
        ceilingEdgeKeelId: string;
        ceilingEdgeKeelHeight: number;
        ceilingEdgeKeelUpWidth: number;
        ceilingEdgeKeelDownWidth: number;
        ceilingEdgeKeelSTLength: number;
        ceilingEdgeKeelThick: number;
        fixedKeelID: string;
        fixedKeelWidth: number;
        fixedKeelHeight: number;
        fixedKeelThickness: number;
        fixedKeelStandardLength: number;
        fixedKeelEndWallDistance: number;
        fixedKeelBolt2Side: number;
        ceilingViceKeelId: string;
        ceilingViceThick: number;
        ceilingViceHeight: number;
        ceilingViceSTLength: number;
        ceilingViceWidth: number;
        viceKeelConnectionId: string;
        viceKeelConnectionLength: number;
        viceKeelConnectionWidth: number;
        viceKeelConnectionHeight: number;
        viceKeelConnectionThick: number;
        horizontalConnectionId: string;
        horizontalConnectionLength: number;
        horizontalConnectionHeight: number;
        horizontalConnectionWidth: number;
        horizontalConnectionThick: number;
        viceKeelHangingID: string;
        viceKeelHangingLengthX: number;
        viceKeelHangingLengthY: number;
        viceKeelHangingLengthZ: number;
        plankStraightConnectionID: string;
        plankStraightConnectionLengthX: number;
        plankStraightConnectionLengthY: number;
        plankStraightConnectionLengthZ: number;
        plankLappedConnectionID: string;
        plankLappedConnectionLengthX: number;
        plankLappedConnectionLengthY: number;
        plankLappedConnectionLengthZ: number;
        ceilingPlasterPlankId: string;
        ceilingPlasterPlankThick: number;
        ceilingPlasterPlankSTWidth: number;
        ceilingPlasterPlankSTLength: number;
        ceilingClipKeelId: string;
        ceilingClipKeelThick: number;
        ceilingClipKeelWidth: number;
        ceilingClipKeelSTLength: number;
        ceilingClipKeelHeight: number;
        screwBoltId: string;
        clipKeelSteeveId: string;
        dryWallNail25Id: string;
        dryWallNail35Id: string;
        nail25Id: string;
        decorateFaceId: string;
        ceilingEdgeKeelMinLength: number;
        ceilingEdgeKeelNailModule: number;
        lowerWidth: number;
        mgrgBottomWidth: number;
        lowerToCeilingHeight: number;
        fixedKeelMinLength: number;
        fixedKeelBoltMoudle: number;
        fixedKeelBoltEndDist: number;
        fixedKeelBoltMinDist: number;
        viceKeelHangingMoudle: number;
        viceKeelHangingDistToStraightConnection: any;
        viceKeelHangingDistToLappedConnection: any;
        viceKeelHangingMinDist: any;
    };
}
declare module "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingCalculatorBase" {
    export class AssemblyLappedCeilingCalculatorBase {
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingGeneralCalculatorInput" {
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { LayoutableSurface } from "sk/rule/data/rule/layout/LayoutableSurface";
    export class AssemblyLappedCeilingGeneralCalculatorInput {
        ceiling: LayoutableSurface;
        flues: Array<LayoutableSurface>;
        polyCeiling: LayoutablePolySurface;
        thickness: number;
        straightWareId: string;
        straightWareWidth: number;
        straightWareHeight: number;
        straightWareStandardLength: number;
        cornerWareId: string;
        cornerWareWidth: number;
        cornerWareHeight: number;
        cornerWareThickness: number;
        basePlankId: string;
        basePlankStandardWidth: number;
        basePlankStandardHeight: number;
        basePlankThickness: number;
        basePlankMinLength: number;
        ceilingEdgeKeelId: string;
        ceilingEdgeKeelHeight: number;
        ceilingEdgeKeelUpWidth: number;
        ceilingEdgeKeelDownWidth: number;
        ceilingEdgeKeelSTLength: number;
        ceilingEdgeKeelThick: number;
        fixedKeelID: string;
        fixedKeelWidth: number;
        fixedKeelHeight: number;
        fixedKeelThickness: number;
        fixedKeelStandardLength: number;
        fixedKeelEndWallDistance: number;
        fixedKeelBolt2Side: number;
        ceilingViceKeelId: string;
        ceilingViceThick: number;
        ceilingViceHeight: number;
        ceilingViceSTLength: number;
        ceilingViceWidth: number;
        viceKeelConnectionId: string;
        viceKeelConnectionLength: number;
        viceKeelConnectionWidth: number;
        viceKeelConnectionHeight: number;
        viceKeelConnectionThick: number;
        horizontalConnectionId: string;
        horizontalConnectionLength: number;
        horizontalConnectionHeight: number;
        horizontalConnectionWidth: number;
        horizontalConnectionThick: number;
        viceKeelHangingID: string;
        viceKeelHangingLengthX: number;
        viceKeelHangingLengthY: number;
        viceKeelHangingLengthZ: number;
        plankStraightConnectionID: string;
        plankStraightConnectionLengthX: number;
        plankStraightConnectionLengthY: number;
        plankStraightConnectionLengthZ: number;
        plankLappedConnectionID: string;
        plankLappedConnectionLengthX: number;
        plankLappedConnectionLengthY: number;
        plankLappedConnectionLengthZ: number;
        ceilingPlasterPlankId: string;
        ceilingPlasterPlankThick: number;
        ceilingPlasterPlankSTWidth: number;
        ceilingPlasterPlankSTLength: number;
        ceilingClipKeelId: string;
        ceilingClipKeelThick: number;
        ceilingClipKeelWidth: number;
        ceilingClipKeelSTLength: number;
        ceilingClipKeelHeight: number;
        screwBoltId: string;
        clipKeelSteeveId: string;
        dryWallNail25Id: string;
        dryWallNail35Id: string;
        nail25Id: string;
        decorateFaceId: string;
        ceilingEdgeKeelMinLength: number;
        ceilingEdgeKeelNailModule: number;
        lowerWidth: number;
        mgrgBottomWidth: number;
        lowerToCeilingHeight: number;
        fixedKeelMinLength: number;
        fixedKeelBoltMoudle: number;
        fixedKeelBoltEndDist: number;
        fixedKeelBoltMinDist: number;
        viceKeelHangingMoudle: number;
        viceKeelHangingDistToStraightConnection: any;
        viceKeelHangingDistToLappedConnection: any;
        viceKeelHangingMinDist: any;
        constructor();
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingGeneralCalculatorOutput" {
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    import { LoDbReferenceLine } from "sk/rule/data/rule/layout/entitys/LoDbReferenceLine";
    export class AssemblyLappedCeilingGeneralCalculatorOutput {
        wallEdgeKeels: Array<LoDbEntity>;
        topFixedKeels: Array<LoDbEntity>;
        hangingPlanks: Array<LoDbEntity>;
        hangingPlankStraightConnections: Array<LoDbEntity>;
        hangingPlankStraightConnectionSubplates: Array<LoDbEntity>;
        hangingPlankCornerConnections: Array<LoDbEntity>;
        plankViceKeelHangings: Array<LoDbEntity>;
        plankViceKeels: Array<LoDbEntity>;
        plankViceKeelConnections: Array<LoDbEntity>;
        hangings: Array<LoDbEntity>;
        mainKeelHangings: Array<LoDbEntity>;
        mainKeels: Array<LoDbEntity>;
        viceKeelHangings: Array<LoDbEntity>;
        viceKeels: Array<LoDbEntity>;
        viceKeelConnecters: Array<LoDbEntity>;
        referenceLines: Array<LoDbReferenceLine>;
        keelNails: Array<LoDbEntity>;
        bolts: Array<LoDbEntity>;
        constructor();
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingGeneralCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutablePoint } from "sk/rule/data/rule/layout/LayoutablePoint";
    import { LayoutableLineWithCorner } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    import { AssemblyLappedCeilingCalculatorBase } from "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingCalculatorBase";
    import { AssemblyLappedCeilingGeneralCalculatorInput } from "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingGeneralCalculatorInput";
    import { AssemblyLappedCeilingGeneralCalculatorOutput } from "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingGeneralCalculatorOutput";
    export class AssemblyLappedCeilingGeneralCalculator extends AssemblyLappedCeilingCalculatorBase {
        input: AssemblyLappedCeilingGeneralCalculatorInput;
        output: AssemblyLappedCeilingGeneralCalculatorOutput;
        elevationFinish: number;
        elevationWallEdgeKeel: number;
        elevationViceKeel: number;
        elevationViceKeelHanging: number;
        elevationMainKeel: number;
        elevationMainKeelHanging: number;
        elevationHanging: number;
        calculateComponent(input: AssemblyLappedCeilingGeneralCalculatorInput, output: AssemblyLappedCeilingGeneralCalculatorOutput): ResultObject;
        calculateWallEdgeKeels(loLineInfo: LayoutableLineWithCorner[]): void;
        calculateOutsideEdgeKeels(loLineInfo: LayoutableLineWithCorner[]): void;
        calculateKeelNails(layoutLine: LayoutableLine): void;
        calculateFixedKeels(loLineInfo: LayoutableLineWithCorner[]): void;
        calculateBolts(layoutLine: LayoutableLine): void;
        calculateHangingPlanks(loLine: LayoutableLineWithCorner, plankHeight: number, isLongEdge?: boolean): void;
        calculateConnections(loLine: LayoutableLineWithCorner, plankHeight: number): void;
        calculateStraightConnection(plankHeight: number, plankLine: LayoutableLine): void;
        calculateLappedConnection(plankHeight: number, loLine: LayoutableLineWithCorner): void;
        calculateViceKeelHanging(plankHeight: number, plankLine: LayoutableLine, point: LayoutablePoint): void;
        calculateViceKell(plankLine: LayoutableLine, point: LayoutablePoint): void;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingProcess" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { RuleProcessOutput } from 'sk/data/family/rule/process/RuleProcessOutput';
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { LappedCeilingParamers } from "sk/rule/data/rule/lappedceilinglayout/LappedCeilingParamers";
    import { AssemblyLappedCeilingGeneralCalculatorInput } from "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingGeneralCalculatorInput";
    import { AssemblyLappedCeilingGeneralCalculatorOutput } from "sk/rule/data/rule/lappedceilinglayout/calculator/AssemblyLappedCeilingGeneralCalculatorOutput";
    export class AssemblyLappedCeilingProcess {
        protected _calculatorService: CalculatorService;
        buildAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, layoutData: PolygonLayoutData, params: LappedCeilingParamers): Promise<RuleProcesResult>;
        setCalculatorInputFromInputBoard(calculatorInput: AssemblyLappedCeilingGeneralCalculatorInput, inputBoard: LappedCeilingParamers): void;
        calculateProcessAsync(context: ElementPerformerContext, input: RuleProcessInput, output: RuleProcessOutput, calculatorInput: AssemblyLappedCeilingGeneralCalculatorInput): Promise<RuleProcesResult>;
        outputProcessAsync(context: ElementPerformerContext, calculatorInput: AssemblyLappedCeilingGeneralCalculatorInput, calculatorOutput: AssemblyLappedCeilingGeneralCalculatorOutput, input: RuleProcessInput, output: RuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/lappedceilinglayout/LappedCeilingBuilder" {
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { LappedCeilingParamers } from "sk/rule/data/rule/lappedceilinglayout/LappedCeilingParamers";
    export class LappedCeilingBuilder {
        private layoutData;
        private params;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: PolygonLayoutData, params: LappedCeilingParamers);
        rotateLayoutData(layoutData: PolygonLayoutData): void;
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/assemble/LappedCeilingElementUtil" {
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { LevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/LevelingCeilingElement';
    import { LappedCeilingParamers } from "sk/rule/data/rule/lappedceilinglayout/LappedCeilingParamers";
    export class LappedCeilingElementUtil {
        static buildLappedCeilingElementAsync(context: ContextObject, levelingCeilingElement: LevelingCeilingElement, roomNode: RoomNode, simplify?: boolean, params?: LappedCeilingParamers): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutDataUtil3" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { LayoutSurfaceData } from "sk/rule/data/rule/assemble/beam/calculator/layout/LayoutSurfaceData";
    import { HoleData, LevelingLayoutData, PlankData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingLayoutDataUtil3 {
        static getLayoutDataFromLevelingWall(levelingWall: LevelingWallElement): LevelingLayoutData;
        static getLayoutDataFromCompositeWall(compositeWall: CompositeWallElement): LevelingLayoutData;
        static quadratePipeCompositeWallTypeData(layoutData: LevelingLayoutData, element: CompositeWallElement): void;
        static quadratePipeTypeData(layoutData: LevelingLayoutData, element: LevelingWallElement): void;
        private static setFlatWallInfoToLayoutData;
        static getContentSegmentOnLine(content: ContentInstanceElement, from: Vector2, to: Vector2): any;
        private static setFlatWallInfoToLayoutData2;
        private static getLineOpengingsHoleDatas;
        private static getOpeningHoleData;
        private static getLineBeamHoleDatas;
        private static getLineCeilingHoleDatas;
        static getBeamHoleData(layoutData: LevelingLayoutData, beam: BeamNode, x: number, subLine: Line2): any;
        static getCeilingHoleData(layoutData: LevelingLayoutData, ceilingSurface: CeilingSurfaceNode, x: number, subLine: Line2, ceilingZ: number): any;
        static getBeamHoles(levelingWall: LevelingWallElement, side: LayoutSurfaceData): void;
        static deepCopyBeamHoles(hole: any): any;
        static clonePlank(plank: PlankData): PlankData;
        static cloneHole(hole: HoleData): HoleData;
        static getLayoutDataFromWallSurface(wallSurface: WallSurfaceNode): Array<LevelingLayoutData>;
        static getLayoutDataFromInput(intput: RuleProcessInput): Array<LevelingLayoutData>;
        private static getWallAreasFromInput;
        private static getLayoutDataFromSurfaceParam;
        private static getWallAreas;
    }
}
declare module "sk/rule/data/rule/assemble/LevelingWallElementUtil3" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    import { AssembleLevelingWallPatternElement } from 'sk/data/family/database/pattern/element/AssembleLevelingWallPatternElement';
    import { LinkerPatternElement } from 'sk/data/family/element/pattern/LinkerPatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { BeamWallIntersectInfo } from 'sk/data/scheme/database/floorplan/model/util/BeamNodeUtil';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { WallElement } from 'sk/data/scheme/database/floorplan/element/WallElement';
    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 { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { LevelingLayoutParamers } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { AssembleRoomContext } from "sk/rule/data/rule/assemble/AssembleRoomContext";
    export class LevelingWallElementUtil3 {
        static createLevelingWallsByRoomAsync(assembleContext: AssembleRoomContext, room: RoomNode): Promise<void>;
        static createSplitLevelingWallsAsync(assembleContext: AssembleRoomContext, wallSurfaceNode: WallSurfaceNode, room: RoomNode): Promise<any>;
        private static createLevelingWallsByLineInfosAsync;
        static createLevelingWallElement(assembleContext: AssembleRoomContext, from: Vector2, to: Vector2): any;
        static createAssebmleWallAndDecorateLayer(element: LevelingWallElement): void;
        static createLevelingWallElement2(assembleContext: AssembleRoomContext, position: Vector3, size: Vector3, rotation: Vector3, placeCd: ContentPlaceTypeEnum): any;
        static loadWallPatternParametersAsync(assembleWallPattern: AssembleLevelingWallPatternElement, assembleWallElementInfoId: string, wallDecorateLinkPattern: LinkerPatternElement, element: LevelingWallElement): Promise<void>;
        static updateLevelingWallDecorateAsync(element: LevelingWallElement): Promise<void>;
        private static updateLevelingWallByDecorate;
        static updateLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, simplify?: boolean): Promise<ResultObject>;
        static getLevelingWallFamilyInfoIdsAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject<{
            levelerId: string;
            boltId: string;
            baseId: string;
            surfaceId: string;
            screwId: string;
            surfaceScrewId: string;
        }>>;
        static getParamsFromLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement): Promise<ResultObject<LevelingLayoutParamers>>;
        static setLeveilingWallParamAsync(context: ElementPerformerContext, element: AssembleLevelingWallPatternElement, params: LevelingLayoutParamers): Promise<ResultObject>;
        static buildLevelingWallAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static buildLevelingLayerWallAsync(context: ElementPerformerContext, element: LevelingWallElement, buildType: BuildStructureTypeEnum): Promise<ResultObject>;
        static getConnectBeamInfosOfLevelingWall(levelingWall: LevelingWallElement): Array<BeamWallIntersectInfo>;
        static getConnectAssembleBeamInfosOfLevelingWall(levelingWall: LevelingWallElement): Array<any>;
        static getBeamInfoOnLine(beam: AssembleBeamElement, line: Line2): any;
        static getThicknessWithSpace(assembleWallElement: AssembleLevelingWallElement, spaceThickness: number): number;
        static getThicknessWithDecorate(assembleWallElement: AssembleLevelingWallElement, thicknessWithDecorate: number): number;
        static getSpaceThickness(assembleWallElement: AssembleLevelingWallElement): number;
        static getDecorateThickness(assembleWallElement: AssembleLevelingWallElement): number;
        static updatePlankPressRelationAsync(assembleRoom: AssembleRoomElement): Promise<void>;
        static processFlatwallAsync(curLevelingWall: LevelingWallElement): Promise<void>;
        static getAllSameLineWalls(curWall: WallElement, room: RoomElement): Array<WallElement>;
        static minWallToLineDistance(curWall: WallElement, line: Line2): number;
        static isWallCloseWiseOrder(curWall: WallElement, preLine: Line2): boolean;
    }
}
declare module "sk/rule/data/rule/assemble/UniverseCubeElementUtil" {
    import { UniverseCubeStructure } from 'foundation/data/common/structure/UniverseCubeStructure';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { UniverseCubeElement } from 'sk/data/family/element/brep/UniverseCubeElement';
    export class UniverseCubeElementUtil {
        static createCubeById(id: string): UniverseCubeElement;
        static getElementCube(element: ContentElement): UniverseCubeStructure;
    }
}
declare module "sk/rule/data/rule/base/AssemblyWallTechniqueTypeEnum" {
    export class AssemblyWallTechniqueTypeEnum {
        static FlatWall: string;
        static LevelerWall: string;
    }
}
declare module "sk/rule/data/rule/bathroomlayout/content/BathroomConverBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { BathroomContentBuilder } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentBuilder";
    import { BathroomContentContext } from "sk/rule/data/rule/bathroomlayout/content/BathroomContentContext";
    export class BathroomConverBuilder extends BathroomContentBuilder {
        constructor(contentContext: BathroomContentContext, bathroom: AssembleBathroomElement);
        put(): void;
        buildAsync(context?: ElementPerformerContext): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingClipKeelSteeve" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class AssemblyCeilingClipKeelSteeve extends ContentBase {
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingDryWallNail" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class AssemblyCeilingDryWallNail extends ContentBase {
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingHardwareCalculator" {
    import { AssemblyCeilingPolygonModelCalculator } from "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingPolygonModelCalculator";
    export class AssemblyCeilingHardwareCalculator extends AssemblyCeilingPolygonModelCalculator {
    }
}
declare module "sk/rule/data/rule/ceilinglayout/calculator/AssemblyCeilingScrew" {
    import { ContentBase } from "sk/rule/data/rule/base/ContentBase";
    export class AssemblyCeilingScrew extends ContentBase {
    }
}
declare module "sk/rule/data/rule/ceilinglayout/LevelingCeilingBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { PolygonLayoutData } from "sk/rule/data/rule/levelinglayout/PolygonLayoutData";
    import { CeilingParamers } from "sk/rule/data/rule/ceilinglayout/CeilingParamers";
    export class LevelingCeilingBuilder {
        private layoutData;
        private params;
        private ceilingParams;
        private context;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: PolygonLayoutData, params: any, ceilingParams: CeilingParamers);
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        private createConatiner;
        private createElementsAsync;
        createPlanksAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<void>;
        createSurfacePlanksAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<void>;
        createDecoratesAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, offset: number): Promise<ResultObject>;
        private createPlankElementAsync;
        private createDecorateElementAsync;
    }
}
declare module "sk/rule/data/rule/contentlayout/kitchenroom/builders/KitchenroomHandWashSinkBuilder" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { KitchenroomPatternElement } from 'sk/data/family/database/pattern/element/KitchenroomPatternElement';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { AssembleRoomContentBuilder } from "sk/rule/data/rule/contentlayout/AssembleRoomContentBuilder";
    class KitchenroomHandWashSinkContainer {
        sinkDecorateValue: DecorateValueStructure;
        sinkContent: any;
    }
    export class KitchenroomHandWashSinkBuilder extends AssembleRoomContentBuilder {
        handWashSinkContainer: KitchenroomHandWashSinkContainer;
        roomPattern: KitchenroomPatternElement;
        protected _calculatorService: CalculatorService;
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        loadAsync(): Promise<void>;
        put(): void;
        private computeSinkPosition;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/tools/FlatwallPlaneHoleTools" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class FlatwallPlaneHoleTools {
        static getPlaneHoleLines(planePoints: Array<Vector2>): Line2[][];
        static getPlaneHoleClockwiseLines(planePoints: Array<Vector2>): Line2[][];
        static getPlaneHoles(planePoints: Array<Vector2>): Array<Box2>;
        protected static getPlaneOutLineDatas(planePoints: Array<Vector2>): any;
        protected static getAllHoleLines(planePoints: Array<Vector2>, boundary: Array<Vector2>): Array<Array<Line2>>;
        protected static getAllHoleCutLines(boundary: Array<Vector2>, planePoints: Array<Vector2>, insideLines: Line2[][], leftLine: Line2, rightLine: Line2, bottomLine: Line2, topLine: Line2): Array<Array<Line2>>;
        protected static getAllHoleBounds(boundary: Array<Vector2>, planePoints: Array<Vector2>, insideLines: Line2[][], leftLine: Line2, rightLine: Line2, bottomLine: Line2, topLine: Line2): Array<Box2>;
        protected static getNeighbourOutLine(boundary: Array<Vector2>, polygonPoints: Array<Vector2>, holeStartPoint: Vector2): Line2;
        protected static getCurHoleCutLine(curHoleLines: Array<Line2>, startBoundaryLine: Line2, endBoundaryLine: Line2, leftLine: Line2, rightLine: Line2, bottomLine: Line2, topLine: Line2): Array<Line2>;
        protected static getCurHoleRectBound(curHoleLines: Array<Line2>, startBoundaryLine: Line2, leftLine: Line2, rightLine: Line2, bottomLine: Line2, topLine: Line2): Array<Box2>;
        protected static reverseHoleLine(curHoleLines: Array<Line2>): Array<Line2>;
        protected static getCoordinateLine(holeLines: Array<Line2>, orginPoint: Vector2): Array<Line2>;
        protected static getCoordHoles(holes: Array<Box2>, orginPoint: Vector2): Array<Box2>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/baseoutlinebuilder/data/FlatWallOutlineConnectdStructinfo" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { FlatWallLayoutArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallLayoutArea";
    import { FlatWallConnectedStructsInfo } from "sk/rule/data/rule/flatwalllayout/basewallbuilder/FlatWallConnectedStructsInfo";
    export class FlatWallOutlineConnectdStructinfo extends FlatWallConnectedStructsInfo {
        getlayoutArea(): FlatWallLayoutArea;
        protected getBeamAndHoles(wallNodes: Array<WallNode>, wallLine: Line2): any;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/kdtree/KdTreeUtil" {
    import { Region } from 'foundation/runtime/math/Region';
    import { KdTreeNode } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/kdtree/KdTreeNode";
    export class KdTreeUtil {
        static getSplitList(list: Array<any>, direction: string): Array<Array<any>>;
        static buildKdTree(list: Array<any>, depth: number, region: Region): KdTreeNode;
        static searchKdTree(node: KdTreeNode, region: Region): Array<any>;
        static reportSubTreeValues(node: KdTreeNode): Array<any>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/LevelingWallArea" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class LevelingWallArea {
        origin: Vector2;
        height: any;
        innerBasicLine: Vector2;
        innerSurfaceLine: Vector2;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/PlankGapArea" {
    import { AreaData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    export class PlankGapArea extends OpeningArea {
        bInner: boolean;
        leftVerticalGap: number;
        rightVerticalGap: number;
        midHoritionalGap: number;
        constructor();
    }
    export class PlankGapUtil {
        protected wallAreaData: AreaData;
        constructor(wallAreaData: AreaData);
        getPlankGaps(): Array<PlankGapArea>;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/PlankJointContent" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    export class PlankJointContent extends ContentArea {
        isInner: boolean;
        innerGapLine: Line2;
        outerGapLine: Line2;
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/TJoinContent" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    export class TJointContent extends ContentArea {
        isInner: boolean;
        innerGapLine: Line2;
        outerGapLine: Line2;
        constructor();
    }
    export class TJointContentUtil {
        plankThickness: number;
        constructor(plankThickness: number);
        computeTArrays(wallnodes: Array<WallNode>, midFlatWallLine: Line2): Array<TJointContent>;
        private eraseRepateData;
        private getTStruct;
        private getCrossWallDatas;
        private isSameWallNode;
        private getCrossWallStartAndEnd;
        private isSameDirection;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/WindowArea" {
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    export class WindowArea extends OpeningArea {
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallArrangeNumberCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class RefLine {
        type: string;
        min: number;
        max: number;
        constructor(type: string, min: number, max: number);
    }
    export class FlatWallArrangeNumberTool {
        arrangeList: Array<number>;
        resultNumbers: Array<number>;
        remain: number;
        origin: number;
        tryNumbers: Array<number>;
        tryIndex: number;
        totalLenth: number;
        current: number;
        thresh: number;
        refLines: Array<RefLine>;
        private refineGap;
        private stepGap;
        times: number;
        lastTryNumber: number;
        private stepMode;
        constructor(start: number, totalLength: number, refLines: Array<RefLine>, arrangeList?: Array<number>, times?: number);
        arrangeNumbers(): ResultObject;
        arrangeNumbersReverse(): ResultObject;
        private process;
        private processReverse;
        private tryOne;
        private tryOneReverse;
        private checkReflines;
        private isAroundHoleSide;
        private isInHoleSide;
        private isCrossHole;
        private isEndCrossHole;
        private isInRange;
        private isInDeadline;
        private popTry;
        private popTryReverse;
        private getNextTry;
        private getFirstTry;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallfacePlankCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallBasicPlankStructure, FlatWallSurfaceColumnStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    export class FlatWallfacePlankCalculator {
        wallArea: FlatWallArea;
        input: FlatWallInput;
        frameStructure: FlatWallAreaLayoutOutputStructure;
        verticalFrameStructure: Array<FlatWallVerticalFrameStructure>;
        innerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        outerBasicPlanks: Array<FlatWallBasicPlankStructure>;
        innerSurfacePlanks: Array<FlatWallSurfaceColumnStructure>;
        outerSurfacePlanks: Array<FlatWallSurfaceColumnStructure>;
        outerBasePlankScrews: Array<Vector2>;
        constructor(input: FlatWallInput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/FlatWallfaceScrewCalculator" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/FlatWallArea";
    import { FlatWallAreaLayoutOutputStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallAreaLayoutOutputStructure";
    import { FlatWallSurfacePlankStructure, FlatWallBasicPlankStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallPlankFrameStructure";
    type Point = {
        position: Vector2;
        type: string;
    };
    export class FlatWallfaceScrewCalculator {
        wallArea: FlatWallArea;
        input: FlatWallInput;
        frameStructure: FlatWallAreaLayoutOutputStructure;
        innerSurfacePlanks: Array<FlatWallSurfacePlankStructure>;
        outerSurfacePlanks: Array<FlatWallSurfacePlankStructure>;
        innerBasePlanks: Array<FlatWallBasicPlankStructure>;
        outerBasePlanks: Array<FlatWallBasicPlankStructure>;
        constructor(input: FlatWallInput, wallInfo: FlatWallArea, frameStructure: FlatWallAreaLayoutOutputStructure);
        compute(): void;
        calculateKeyPoints(plank: FlatWallSurfacePlankStructure): Array<Point>;
        private addOneKeyPoint;
        uniqueSortArray(array: Array<number>, gap: number): Array<number>;
        getAddNumbers(n1: number, n2: number, gap: number): number[];
        layoutKeyPoints(keyPoints: Array<Point>): Array<Array<number>>;
        createScrews(plank: FlatWallSurfacePlankStructure, isInner: boolean): ResultObject;
        addOneScrew(plank: FlatWallSurfacePlankStructure, position: Vector2, isInner: boolean): void;
        isScrewInPlank(plank: FlatWallSurfacePlankStructure, position: Vector2, isJudgeHole?: boolean): boolean;
        private isScrewInHole;
        private isScrewCollsiionBaseScrew;
        private isScrewCollsiionSurfaceScrew;
        private moveScrew;
        private isValidScrew;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallBasicKeelHeadStructure" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { FlatWallInput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallInput";
    import { FlatWallOutput } from "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallOutput";
    export class FlatWallBasicKeelHeadStructure {
        constructor();
        structureGenerate(input: FlatWallInput, output: FlatWallOutput, structurePos: Vector3, structureLength?: number, structureHeight?: number): void;
        protected createHeaveKeels(input: FlatWallInput, output: FlatWallOutput, keelPos: Vector3, keelLength: number, keelHeight: number): void;
        protected createStandardHeavenKeelPlugBolt(input: FlatWallInput, output: FlatWallOutput, keelPos: Vector3, keelLength: number, keelHeight: number): void;
        private calculatePlugBoltPoses;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallSectionAreaStructure" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { FlatWallVerticalFrameStructure } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/FlatWallVerticalFrameStructure";
    export class FlatWallSectionAreaStructure {
        line: Line2;
        keels: Array<FlatWallVerticalFrameStructure>;
        constructor();
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/model/structure/PlankArea" {
    import { ContentArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/ContentArea";
    import { OpeningArea } from "sk/rule/data/rule/flatwalllayout/frame/flatwallsturctures/layout/OpeningArea";
    export class PlankCutHoleArea extends ContentArea {
        opening: OpeningArea;
        holeType: string;
    }
}
declare module "sk/rule/data/rule/flatwalllayout/frame/model/FlatWallProcessTypeEnum" {
    export class FlatWallProcessTypeEnum {
        static FlatWallStandardWallProcess: string;
        static FlatWallCloseBeamSideWallProcess: string;
        static FlatWallGapBeamSideWallProcess: string;
    }
}
declare module "sk/rule/data/rule/layout/LayoutElementUtil" {
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    export class LayoutElementUtil {
        static refreshMaterialLayout(room: RoomElement): void;
        static refreshMaterialLayoutByFloorplan(floorplan: FloorplanElement): void;
        static buildElementByReferenceAsync(element: LayoutElement): Promise<any>;
    }
}
declare module "sk/rule/data/rule/linear/LinearLinkCodeEnum" {
    export enum LinearLinkCodeEnum {
        Cornice = "cornice",
        Baseboard = "baseboard"
    }
}
declare module "sk/rule/data/rule/linear/baseboard/BaseboardElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { BaseboardElement } from 'sk/data/scheme/database/floorplan/element/BaseboardElement';
    import { CeilingNode } from 'sk/data/scheme/database/floorplan/model/CeilingNode';
    import { FloorNode } from 'sk/data/scheme/database/floorplan/model/FloorNode';
    import { FloorSurfaceNode } from 'sk/data/scheme/database/floorplan/model/FloorSurfaceNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { LinearLinkData } from "sk/rule/data/rule/linear/LinearElementUtil";
    export class BaseboardElementUtil {
        static refreshBaseboard(baseboard: BaseboardElement): void;
        static addBaseboardFromWallSurfaceAsync(wallNode: WallSurfaceNode, roomNode: RoomNode, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<LinearLinkData>>;
        static addBaseboardFromFloorAsync(floorNode: FloorNode, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<LinearLinkData>>;
        static addBaseboardFromAreaPolygonAsync(areaPolygonNode: AreaPolygonNode, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<LinearLinkData>>;
        static removeBaseboard(node: RoomNode | CeilingNode | FloorNode | FloorSurfaceNode | AreaPolygonNode): Array<LinearLinkData>;
        static refreshRoomBaseboard(room: RoomNode): void;
        static calculateBaseboardPosZ(floorNode: FloorNode): number;
    }
}
declare module "sk/rule/data/rule/linear/cornice/CorniceElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { CorniceElement } from 'sk/data/scheme/database/floorplan/element/CorniceElement';
    import { CeilingNode } from 'sk/data/scheme/database/floorplan/model/CeilingNode';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    import { FloorNode } from 'sk/data/scheme/database/floorplan/model/FloorNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { LevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/LevelingCeilingNode';
    import { LinearLinkData } from "sk/rule/data/rule/linear/LinearElementUtil";
    export class CorniceElementUtil {
        static refreshCornice(cornice: CorniceElement): void;
        static addCorniceFromCeilingSurfaceAsync(ceilingSurfaceNode: CeilingSurfaceNode, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<LinearLinkData>>;
        static addCorniceFromLevelingCeilingAsync(levelingCeilingNode: LevelingCeilingNode, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<LinearLinkData>>;
        static addCorniceFromAreaPolygonAsync(areaPolygonNode: AreaPolygonNode, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<LinearLinkData>>;
        static removeCornice(node: RoomNode | CeilingNode | FloorNode | CeilingSurfaceNode | AreaPolygonNode): Array<LinearLinkData>;
        static refreshRoomCornice(room: RoomNode): void;
        static calculateCornicePosZ(node: CeilingSurfaceNode | LevelingCeilingNode, familyInfo: ISpecificationFamilyInfo): number;
    }
}
declare module "sk/rule/data/rule/linear/LinearElementUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { LinearElement } from 'sk/data/family/element/instance/LinearElement';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { LinearLinkCodeEnum } from "sk/rule/data/rule/linear/LinearLinkCodeEnum";
    export class LinearLinkData {
        linkElement: ContentInstanceElement;
        linears: Array<LinearElement>;
        constructor();
    }
    export class LinearElementUtil {
        static refreshLinearFloorplan(floorplan: FloorplanElement): void;
        static refreshRoomLinear(room: RoomNode): void;
        static createLinearElementFromLinesAsync(document: SchemeDocument, parent: BrepElement, familyInfo: ISpecificationFamilyInfo, lines: Array<Line2>): Promise<ResultObject<LinearElement>>;
        static createLinearElementAsync(document: SchemeDocument, parent: BrepElement, familyInfo: ISpecificationFamilyInfo): Promise<ResultObject<FamilyInstanceElement>>;
        static removeLinearByRelationNode(relationNode: ContentInstanceNode, linearLinkCode: LinearLinkCodeEnum): LinearLinkData;
        static removeLinear(linearNode: LinearNode): void;
        static addlinearFromLinesAsync(relationNode: ContentInstanceNode, familyInfo: ISpecificationFamilyInfo, lines: Array<Line2>, linearLinkCode: LinearLinkCodeEnum, linearZ?: number): Promise<ResultObject<LinearElement>>;
        static findLinearRoom(linear: LinearElement): RoomNode;
    }
}
declare module "sk/rule/data/rule/floorplan/FloorplanRefreshUtil" {
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    export type FloorplanRefreshOptions = {
        refreshCeiling?: boolean;
        deleteRoom?: boolean;
    };
    export class FloorplanRefreshUtil {
        static refreshFloorplan(floorplan: FloorplanElement): void;
        static refreshRooms(rooms: Array<RoomNode>, options?: FloorplanRefreshOptions): void;
        static refreshRoom(room: RoomNode, options?: FloorplanRefreshOptions): void;
    }
}
declare module "sk/rule/data/rule/layout/entitys/LoDbKeel" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { LoDbEntity } from "sk/rule/data/rule/layout/entitys/LoDbEntity";
    export class LoDbKeel extends LoDbEntity {
        constructor(id?: string);
        static fromElement(): void;
        clone(): LoDbKeel;
        copyFrom(other: LoDbKeel): void;
        setPropertiesFromElement(element: FamilyInstanceElement): void;
        lengthDir(): Vector3;
        begin(): Vector3;
        end(): Vector3;
        setBegin(pt: Vector2): void;
        setLength(length: number): void;
    }
}
declare module "sk/rule/data/rule/layout/LayoutableFenceSurface" {
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    import { LayoutablePolyline } from "sk/rule/data/rule/layout/LayoutablePolyline";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    export class LayoutableFenceSurface extends LayoutableObject {
        _path: LayoutablePolyline;
        _faces: Array<LayoutablePolySurface>;
    }
}
declare module "sk/rule/data/rule/layout/LayoutableHole" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    import { LayoutablePolyline } from "sk/rule/data/rule/layout/LayoutablePolyline";
    export class LayoutableHole extends LayoutableObject {
        ptList: Array<Vector2>;
        scale: number;
        isRound: boolean;
        static fromPolyline(poly: LayoutablePolyline, scale?: number): LayoutableHole;
        static fromPoints(pts: Array<Vector2>, scale?: number): LayoutableHole;
    }
}
declare module "sk/rule/data/rule/layout/LayoutableOutline" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    import { LayoutablePolyline } from "sk/rule/data/rule/layout/LayoutablePolyline";
    export class LayoutableOutline extends LayoutableObject {
        ptList: Array<Vector2>;
        scale: number;
        isRound: boolean;
        static fromPolyline(poly: LayoutablePolyline, scale?: number): LayoutableOutline;
        static fromPoints(pts: Array<Vector2>, scale?: number): LayoutableOutline;
    }
}
declare module "sk/rule/data/rule/layout/LayoutableRegion" {
    import { LayoutableHole } from "sk/rule/data/rule/layout/LayoutableHole";
    import { LayoutableLine } from "sk/rule/data/rule/layout/LayoutableLine";
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    import { LayoutableOutline } from "sk/rule/data/rule/layout/LayoutableOutline";
    import { LayoutablePolyline } from "sk/rule/data/rule/layout/LayoutablePolyline";
    export class LayoutableRegion extends LayoutableObject {
        outline: LayoutableOutline;
        holes: Array<LayoutableHole>;
        constructor();
        asClipper(clipper: any): void;
        clipPolyline(poly: LayoutablePolyline): Array<any>;
        clipLine(line: LayoutableLine): Array<any>;
        toPathNode(): any;
        static partitionByLine(region: LayoutableRegion, line: LayoutableLine): Array<any>;
        static fromPath(path: any): LayoutableRegion;
    }
}
declare module "sk/rule/data/rule/layout/LayoutableSingleSpace" {
    import { LayoutableObject } from "sk/rule/data/rule/layout/LayoutableObject";
    import { LayoutablePolyline } from "sk/rule/data/rule/layout/LayoutablePolyline";
    import { LayoutablePolySurface } from "sk/rule/data/rule/layout/LayoutablePolySurface";
    export class LayoutableSingleSpace extends LayoutableObject {
        _path: LayoutablePolyline;
        _faces: Array<LayoutablePolySurface>;
    }
}
declare module "sk/rule/data/rule/layout/PolygonArea" {
    import { Point3 } from 'foundation/runtime/math/Point3';
    import { RectArea } from "sk/rule/data/rule/base/RectArea";
    export class PolygonArea extends RectArea {
        outline: Array<Point3>;
        sortOutine(): void;
    }
}
declare module "sk/rule/data/rule/levelinglayout/calculator/PlankDecorateWallData" {
    export class PlankDecorateWallData {
        xx: number;
        yy: number;
        zz: number;
        lengthX: number;
        lengthY: number;
        lengthZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        gap: number;
        constructor();
    }
}
declare module "sk/rule/data/rule/levelinglayout/CompositeLayoutDataCalculator" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { LayoutOption, LevelingLayoutData, LevelingLayoutParamers } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    import { LevelingLayoutDataCalculator } from "sk/rule/data/rule/levelinglayout/LevelingLayoutDataCalculator";
    export class CompositeLayoutDataCalculator extends LevelingLayoutDataCalculator {
        layoutData: LevelingLayoutData;
        protected params: LevelingLayoutParamers;
        protected layoutOption: LayoutOption;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers, layoutOption: LayoutOption);
        caclulate(): RuleProcesResult;
    }
}
declare module "sk/rule/data/rule/levelinglayout/CompositeWallBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    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 { SchemeConfigOperateService } from 'sk/data/scheme/config/SchemeConfigOperateService';
    import { LevelingLayoutData, LevelingLayoutParamers, LayoutOption } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingWallBuilder {
        private layoutData;
        private params;
        private context;
        protected _schemeConfigOperateService: SchemeConfigOperateService;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers);
        buildAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        buildBaseAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        buildSurfaceAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        buildDecorateAsync(context: ElementPerformerContext, element: ContentElement): Promise<ResultObject>;
        getLayoutOption(layoutData: LevelingLayoutData): LayoutOption;
        private createConatiner;
        private choiceLeveller;
        private modifyElementNameAndCode;
        private createElementsAsync;
        private createSurveyLines;
        private createPlankElementAsync;
        private createDecorateElementAsync;
        private createSimpleBasePlankElementAsync;
        private createSimpleSurfacePlankElementAsync;
        createPlanksAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, isNz: boolean, offset: number): Promise<void>;
        createSurfacePlanksAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, isNz: boolean, offset: number): Promise<void>;
        createDecoratesAsync(container: ContentElement, familyInfo: ISpecificationFamilyInfo, thick: number, isNz: boolean, offset: number): Promise<ResultObject>;
        private createLevellerElementAsync;
        private createWindowStoneElementAsync;
        private createQuadratePipeElementAsync;
        private createScrewElementAsync;
        private createLevellersAsync;
        private createBaseScrewsAsync;
        private createQuadratePipeAsync;
        private createWindowStoneAsync;
        private createSurfaceScrewsAsync;
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/DecorateData" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export type DecorateData = {
        width: number;
        height: number;
        polygon?: Array<Vector2>;
        x: number;
        y: number;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/HolePositionTypeEnum" {
    export enum HolePositionTypeEnum {
        LEFT = 1,
        LEFT_TOP = 2,
        LEFT_CENTER = 3,
        LEFT_BOTTOM = 4,
        RIGHT = 5,
        RIGHT_TOP = 6,
        RIGHT_CENTER = 7,
        RIGHT_BOTTOM = 8,
        TOP_CENTER = 9,
        BOTTOM_CENTER = 10
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/HoleData" {
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { HolePositionTypeEnum } from "sk/rule/data/rule/levelinglayout/structure/HolePositionTypeEnum";
    import { HoleTypeEnum } from "sk/rule/data/rule/levelinglayout/structure/HoleTypeEnum";
    export type HoleData = {
        node: FamilyInstanceNode;
        x: number;
        y: number;
        type: HoleTypeEnum;
        width: number;
        height: number;
        startSpaceX: number;
        endSpaceX: number;
        startSpaceY: number;
        endSpaceY: number;
        startSpaceXFace?: number;
        endSpaceXFace?: number;
        startSpaceYFace?: number;
        endSpaceYFace?: number;
        marginStartX?: number;
        marginEndX?: number;
        marginStartY?: number;
        marginEndY?: number;
        position?: HolePositionTypeEnum;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/AreaData" {
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { ColumnData } from "sk/rule/data/rule/levelinglayout/structure/ColumnData";
    import { DecorateData } from "sk/rule/data/rule/levelinglayout/structure/DecorateData";
    import { HoleData } from "sk/rule/data/rule/levelinglayout/structure/HoleData";
    export type AreaData = {
        idx: number;
        width: number;
        height: number;
        holes: HoleData[];
        subHoles: HoleData[];
        decorate?: DecorateData;
        reflines?: Array<RefLine>;
        columns?: Array<ColumnData>;
        surfaceColumns?: Array<ColumnData>;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/LevellerData" {
    import { LevellerTypeEnum } from "sk/rule/data/rule/levelinglayout/structure/LevellerTypeEnum";
    import { PlankData } from "sk/rule/data/rule/levelinglayout/structure/PlankData";
    export type LevellerData = {
        x: number;
        y: number;
        wx: number;
        wy: number;
        prior: number;
        plank: PlankData;
        type?: LevellerTypeEnum;
        params?: any;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/PlankData" {
    import { Curve2 } from 'foundation/runtime/math/Curve2';
    import { ColumnData } from "sk/rule/data/rule/levelinglayout/structure/ColumnData";
    import { HoleData } from "sk/rule/data/rule/levelinglayout/structure/HoleData";
    import { LevellerData } from "sk/rule/data/rule/levelinglayout/structure/LevellerData";
    export type PlankData = {
        idx: number;
        y: number;
        wx: number;
        wy: number;
        width: number;
        height: number;
        column: ColumnData;
        isTop?: boolean;
        isRight?: boolean;
        innerLeft?: number;
        innerRight?: number;
        innerTop?: number;
        innerBottom?: number;
        holes?: Array<HoleData>;
        cutLines?: Array<Curve2>;
        levellers?: Array<LevellerData>;
        params?: any;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/ColumnData" {
    import { RefLine } from "sk/rule/data/rule/levelinglayout/ArrangeNumberTool";
    import { AreaData } from "sk/rule/data/rule/levelinglayout/structure/AreaData";
    import { HoleData } from "sk/rule/data/rule/levelinglayout/structure/HoleData";
    import { PlankData } from "sk/rule/data/rule/levelinglayout/structure/PlankData";
    export type ColumnData = {
        idx: number;
        x: number;
        width: number;
        height: number;
        holes: Array<HoleData>;
        planks?: Array<PlankData>;
        reflines?: Array<RefLine>;
        area: AreaData;
        isLeft: boolean;
        isRight: boolean;
        hasLeveller: boolean;
        innerLeft: number;
        innerRight: number;
        isSurface: boolean;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/LevellerPriorEnum" {
    export enum LevellerPriorEnum {
        Unknown = 0,
        Surface = 1,
        Edge = 2,
        Corner = 3
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutLevellerCalculatorNew" {
    import { ColumnData } from "sk/rule/data/rule/levelinglayout/structure/ColumnData";
    import { LevellerData } from "sk/rule/data/rule/levelinglayout/structure/LevellerData";
    import { LevellerTypeEnum } from "sk/rule/data/rule/levelinglayout/structure/LevellerTypeEnum";
    import { PlankData } from "sk/rule/data/rule/levelinglayout/structure/PlankData";
    import { LevelingLayoutData, LevelingLayoutParamers } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingLayoutLevellerCalculatorNew {
        private layoutData;
        private params;
        private allLevellers;
        constructor(layoutData: LevelingLayoutData, params: LevelingLayoutParamers);
        private checkInPlankHoles;
        private checkInPlank;
        protected addLevellerToPlank(plank: PlankData, x: number, y: number, typeCd?: LevellerTypeEnum, prior?: number): LevellerData;
        protected addPlankLevellers(column: ColumnData, plank: PlankData): void;
        protected addColumnLevellers(column: ColumnData): void;
        calculate(): void;
    }
}
declare module "sk/rule/data/rule/levelinglayout/LevelingLayoutLevellerCalculatorWeb" {
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { PlankData, LevellerData, LevelingLayoutParamers, HoleData } from "sk/rule/data/rule/levelinglayout/LevelingLayoutData";
    export class LevelingLayoutLevellerCalculatorWeb {
        private areaData;
        private params;
        private allLevellers;
        private holes;
        constructor(params: LevelingLayoutParamers);
        createLevelers(plank: PlankData): any;
        getKeyPoints(plank: PlankData): Array<any>;
        getPlankLocalHoles(plank: PlankData, inputHoles: Array<HoleData>): void;
        protected setPlankHoleRect(plank: PlankData, hole: HoleData): void;
        getPlankKeyPoints(plank: PlankData): Array<any>;
        getPlankHoleKeyPoints(plank: PlankData): Array<any>;
        private checkInPlank;
        collisionCheck(plank: PlankData, x: number, y: number): boolean;
        getPositionListByPoints(keyPoints: Array<any>): any;
        moveKeyPoint(keyPoints: Array<any>, index: number, key: string): void;
        insertKeyPoint(keyPoints: Array<any>, index: number, key: string, gap: number): number;
        sortList(keyPoints: Array<any>, key: string): Array<any>;
        addLevelerByLocation(plank: PlankData, xList: Array<any>, yList: Array<any>): void;
        private addLevellerToPlank;
        private checkInPlankHoles;
        createAllLevelers(levelingWall: LevelingWallElement): Array<LevellerData>;
        private buildPlankDatas;
        private buildPlankData;
        private plankIsTop;
        private completePlankDataByHoleData;
        private buildHoleData;
    }
}
declare module "sk/rule/data/rule/levelinglayout/SinglePlankLayoutLevellerCalculator" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    export type SinglePlankInfo = {
        points: Vector2[];
        wx: number;
        wy: number;
    };
    export type SinglePlankInputData = {
        levellers: Array<Vector2>;
        floorArea: Vector2[][];
        plankInfo: SinglePlankInfo;
        holes?: Vector2[][];
        allPlankModle?: boolean;
    };
    export class SinglePlankLayoutLevellerCalculator {
        private outputLevellers;
        private input;
        tmpPolygon: Polygon;
        private diameter;
        private horizontalGap;
        private verticalGap;
        private plankInner;
        calculate(input: SinglePlankInputData): Array<Vector2>;
        private addLevellers;
        private createPlankInnerLevellers;
        private getPlankBox;
        private isLevellerCover;
        private addLevellerToPlank;
        private createPlankSideLevellers;
        private createLineLevellers;
        private isLineOnPolygons;
        private isLineOnPolygon;
        private getLineIndexOnPolygon;
        private moveInterLeveller;
        pushInnerSideLevellers(): void;
        private getPointOnPolygonDir;
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/LayoutLayerTypeEnum" {
    export class LayoutLayerTypeEnum {
        static Base: string;
        static Surface: string;
        static Decorate: string;
        static Leveler: string;
        static Survey: string;
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/LevelingLayoutTypeEnum" {
    export enum LevelingLayoutTypeEnum {
        WALL = 1,
        FLOOR = 2,
        HOLE_INNER_TOP = 3,
        HOLE_INNER_LEFT = 4,
        HOLE_INNER_RIGHT = 5,
        HOLE_INNER_BOTTOM = 6,
        COLUMN_LEFT = 7,
        COLUMN_RIGHT = 8,
        COLUMN_CENTER = 9,
        WINDOW_INNER_BOTTOM = 10,
        DOOR_INNER_BOTTOM = 11,
        NULL = 12
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/PlankCutEnum" {
    export enum PlankCutEnum {
        DOOR_LEFT = 0,
        DOOR_RIGHT = 1,
        WINDOW_LEFT = 2,
        WINDOW_RIGHT = 3,
        WINDOW_LEFT_TOP = 4,
        WINDOW_RIGHT_TOP = 5,
        WINDOW_LEFT_BOTTOM = 6,
        WINDOW_RIGHT_BOTTOM = 7
    }
}
declare module "sk/rule/data/rule/levelinglayout/structure/QuadratePipeData" {
    export type QuadratePipeData = {
        length: number;
        wx: number;
        wy: number;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/ScrewData" {
    export type ScrewData = {
        x: number;
        y: number;
        wx: number;
        wy: number;
    };
}
declare module "sk/rule/data/rule/levelinglayout/structure/WindowStoneData" {
    export type WindowStoneData = {
        depth: number;
        length: number;
    };
}
declare module "sk/rule/data/rule/process/CollisionBaseProcess" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineCurve3d } from 'foundation/runtime/geometry/curve3d/LineCurve3d';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { OctreeNode } from 'foundation/runtime/geometry/Octree';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { MoldingGeometryStructure } from 'foundation/data/common/model/molding/MoldingGeometryStructure';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    export class CollisionResult {
        a: ContentNode;
        d: ContentNode;
        constructor(a: ContentNode, d: ContentNode);
    }
    export class FacePoint {
        c: Vector3;
        l1: LineCurve3d;
        l2: LineCurve3d;
        depth: number;
        dir: Vector3;
        length: number;
    }
    export class AvoidData {
        node: ContentNode;
        geometry: MoldingGeometryStructure;
        box: BufferGeometry;
        section: SectionSurface;
    }
    export class CollisionBaseProcess extends RuleProcess {
        protected technologyDepthCut(a: TechnologyNode, d: ContentNode, a_matirx?: Matrix3d): void;
        protected technologyPathCut(a: TechnologyNode, d: ContentNode): void;
        protected getBoxFaces(box: BoxSolid): Array<FacePoint>;
        protected getAvoidsData(voids: Array<ContentNode>, octreeNode: OctreeNode<ContentNode>): Array<AvoidData>;
    }
}
declare module "sk/rule/data/rule/process/CollisionFamilyLongitudeLatitudeProcess" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { SchemeRuleProcessContext } from "sk/rule/data/base/rule/SchemeRuleProcessContext";
    import { SchemeRuleProcessInput } from "sk/rule/data/base/rule/SchemeRuleProcessInput";
    import { SchemeRuleProcessOutput } from "sk/rule/data/base/rule/SchemeRuleProcessOutput";
    import { CollisionBaseProcess } from "sk/rule/data/rule/process/CollisionBaseProcess";
    export class CollisionFamilyLongitudeLatitudeProcess extends CollisionBaseProcess {
        processAsync(context: SchemeRuleProcessContext, input: SchemeRuleProcessInput, output: SchemeRuleProcessOutput): Promise<RuleProcesResult>;
        private calLongitude;
        private calLagitude;
    }
}
declare module "sk/rule/data/rule/process/instance/CollisionFamilyGenerateMutualProcess" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { SchemeGlobalRuleProcessOutput } from "sk/rule/data/base/rule/SchemeGlobalRuleProcessOutput";
    import { CollisionBaseProcess } from "sk/rule/data/rule/process/CollisionBaseProcess";
    export class CollisionFamilyGenerateMutualProcess extends CollisionBaseProcess {
        processAsync(context: RuleProcessContext, input: RuleProcessInput, output: SchemeGlobalRuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/process/instance/CollisionFamilyTransmitProcess" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { SchemeGlobalRuleProcessOutput } from "sk/rule/data/base/rule/SchemeGlobalRuleProcessOutput";
    import { CollisionBaseProcess } from "sk/rule/data/rule/process/CollisionBaseProcess";
    export class CollisionFamilyTransmitProcess extends CollisionBaseProcess {
        processAsync(context: RuleProcessContext, input: RuleProcessInput, output: SchemeGlobalRuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/data/rule/process/PlankEdgeHingeLineProcess" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeRuleProcessContext } from "sk/rule/data/base/rule/SchemeRuleProcessContext";
    import { SchemeRuleProcessInput } from "sk/rule/data/base/rule/SchemeRuleProcessInput";
    import { SchemeRuleProcessOutput } from "sk/rule/data/base/rule/SchemeRuleProcessOutput";
    export type StepRemain2 = {
        dors: number;
        remains: Array<number>;
    };
    export class PlankEdgeHingeLineProcess extends RuleProcess {
        protected _schemeConfigService: SchemeConfigService;
        protected _familyDocumentService: FamilyDocumentService;
        protected validateCondition(input: SchemeRuleProcessInput): boolean;
        validateCoverAsync(context: SchemeElementPerformerContext, input: SchemeRuleProcessInput): Promise<ResultObject<boolean>>;
        processAsync(context: SchemeRuleProcessContext, input: SchemeRuleProcessInput, output: SchemeRuleProcessOutput): Promise<RuleProcesResult>;
        protected contact(curve: LineCurve2d, mt: Matrix3d, plane: PlaneNode, contacts: Array<ContentNode>): Array<Curve2d>;
        protected aovid(plane: PlaneNode, offsetAnchor: Matrix3d, curve: Curve2d, is_forward: boolean, is_normal_p: boolean, lerpCurr: number, lerpPre: number, lerpNext: number, start: number, end: number, distance: number, familyBox: BoxSolid, aovids: Array<ContentNode>): {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        };
        protected aovid2(plane: PlaneNode, offsetAnchor: Matrix3d, curve: Curve2d, is_forward: boolean, is_normal_p: boolean, lerpCurr: number, disPre: {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        }, disNext: {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        }, distance: number, familyBox: BoxSolid, aovids: Array<ContentNode>): {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        };
        protected distance(plane: PlaneNode, offsetAnchor: Matrix3d, cut: Curve2d, is_forward: boolean, is_normal_p: boolean, lerp: number, familyBox: BoxSolid, aovids: Array<ContentNode>): {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        };
    }
}
declare module "sk/rule/data/rule/process/PlankEdgeStructHardwareLineProcess" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { LineCurve2d } from 'foundation/runtime/geometry/curve2d/LineCurve2d';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Curve2d } from 'foundation/runtime/geometry/Curve2d';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    import { SchemeRuleProcessContext } from "sk/rule/data/base/rule/SchemeRuleProcessContext";
    import { SchemeRuleProcessInput } from "sk/rule/data/base/rule/SchemeRuleProcessInput";
    import { SchemeRuleProcessOutput } from "sk/rule/data/base/rule/SchemeRuleProcessOutput";
    export type StepRemain = {
        dors: number;
        remains: Array<number>;
    };
    export class PlankEdgeStructHardwareLineProcess extends RuleProcess {
        protected validateCondition(input: SchemeRuleProcessInput): boolean;
        processAsync(context: SchemeRuleProcessContext, input: SchemeRuleProcessInput, output: SchemeRuleProcessOutput): Promise<RuleProcesResult>;
        protected contact(curve: LineCurve2d, mt: Matrix3d, plane: PlaneNode, contacts: Array<ContentNode>): Array<Curve2d>;
        protected aovid(plane: PlaneNode, offsetAnchor: Matrix3d, curve: Curve2d, is_forward: boolean, is_normal_p: boolean, lerpCurr: number, lerpPre: number, lerpNext: number, start: number, end: number, distance: number, familyBox: BoxSolid, aovids: Array<ContentNode>): {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        };
        protected aovid2(plane: PlaneNode, offsetAnchor: Matrix3d, curve: Curve2d, is_forward: boolean, is_normal_p: boolean, lerpCurr: number, disPre: {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        }, disNext: {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        }, distance: number, familyBox: BoxSolid, aovids: Array<ContentNode>): {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        };
        protected distance(plane: PlaneNode, offsetAnchor: Matrix3d, cut: Curve2d, is_forward: boolean, is_normal_p: boolean, lerp: number, familyBox: BoxSolid, aovids: Array<ContentNode>): {
            d: number;
            a: ContentNode;
            m: Matrix3d;
            lerp: number;
        };
    }
}
declare module "sk/rule/data/rule/process/PlankEdgeStructHardwareLineSubProcess" {
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { SchemeRuleProcessContext } from "sk/rule/data/base/rule/SchemeRuleProcessContext";
    import { SchemeRuleProcessInput } from "sk/rule/data/base/rule/SchemeRuleProcessInput";
    import { SchemeRuleProcessOutput } from "sk/rule/data/base/rule/SchemeRuleProcessOutput";
    import { PlankEdgeStructHardwareLineProcess } from "sk/rule/data/rule/process/PlankEdgeStructHardwareLineProcess";
    export class PlankEdgeStructHardwareLineSubProcess extends PlankEdgeStructHardwareLineProcess {
        protected validateCondition(input: SchemeRuleProcessInput): boolean;
        processAsync(context: SchemeRuleProcessContext, input: SchemeRuleProcessInput, output: SchemeRuleProcessOutput): Promise<RuleProcesResult>;
        private caulateLerps;
    }
}
declare module "sk/rule/data/rule/process/PlankSurfaceHandleRuleProcess" {
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    import { SchemeRuleProcessContext } from "sk/rule/data/base/rule/SchemeRuleProcessContext";
    import { SchemeRuleProcessInput } from "sk/rule/data/base/rule/SchemeRuleProcessInput";
    import { SchemeRuleProcessOutput } from "sk/rule/data/base/rule/SchemeRuleProcessOutput";
    export class PlankSurfaceHandleRuleProcess extends RuleProcess {
        private isPhreatic;
        private getELementFromInput;
        private makePhreaticPoint;
        private getOffsetByPositionCd;
        private computePhreaticPosition;
        processAsync(context: SchemeRuleProcessContext, input: SchemeRuleProcessInput, output: SchemeRuleProcessOutput): Promise<RuleProcesResult>;
        protected getVariableParamsByBindingValues(family: FamilyInstanceElement): any;
    }
}
declare module "sk/rule/data/rule/RuleUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { RuleItemElement } from 'sk/data/family/rule/element/instance/RuleItemElement';
    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 { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class RuleUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _calculatorService: CalculatorService;
        static loadRuleListFromComponentElementAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement): Promise<ResultObject<RuleItemElement[]>>;
        static loadComponentInstanceElementByParentElementAsync(context: SchemeElementPerformerContext, parentElement: FamilyInstanceElement, element: ContentInstanceElement): Promise<ResultObject<ComponentInstanceElement>>;
    }
}
declare module "sk/rule/data/rule/slidingdoor/SlidingDoorLayoutPreviewBuilder" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class SlidingDoorLayoutData {
        canvasWidth: number;
        canvasHeight: number;
        leftFrameWidth: number;
        rightFrameWidth: number;
        topFrameWidth: number;
        buttomFrameWidth: number;
        centerFrameWidth: number;
        leafWidth: number;
        leafHeight: number;
        style: SlidingDoorStyle;
        protected _factor: number;
        layoutCorePlanks: Array<slidingDoorLayoutCorePlankContent>;
        constructor();
        getCanvasScaleValue(value: number): number;
        get scale(): number;
        set factor(value: number);
        get factor(): number;
    }
    export class slidingDoorLayoutCorePlankContent {
        visionHeight: number;
        unitType: string;
    }
    export class SlidingDoorStyle {
        frameColor: string;
        borderColor: string;
        corePlankColor: string;
        fontSize: number;
        constructor();
    }
    export class SlidingDoorLayoutPreviewBuilder {
        buildAsync(layoutData: SlidingDoorLayoutData): Promise<ResultObject<Blob>>;
        private drawRect;
        private drawCorePlankText;
    }
}
declare module "sk/rule/data/rule/slidingdoor/SlidingDoorLayoutPreviewUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SlidingDoorLayoutStructure } from 'sk/data/family/database/furniture/element/slidingdoor/SlidingDoorLayoutStructure';
    import { SlidingDoorLayoutData } from "sk/rule/data/rule/slidingdoor/SlidingDoorLayoutPreviewBuilder";
    export class SlidingDoorLayoutPreviewUtil {
        static buildLayoutPreviewAsync(layoutData: SlidingDoorLayoutData): Promise<ResultObject<Blob>>;
        static cellNumberChange(dataSource: any): any;
        static getSlidingDoorLayoutDataByLayoutStructure(structure: SlidingDoorLayoutStructure): SlidingDoorLayoutData;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleBathroomElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
    import { AssembleBathroomNode } from 'sk/data/scheme/database/pattern/node/AssembleBathroomNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleBathroomElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleBathroomElement): AssembleBathroomElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: AssembleBathroomElement, index: number, node: AssembleBathroomNode): ResultEnum;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleBeamElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { AssembleBeamNode } from 'sk/data/scheme/database/pattern/node/AssembleBeamNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleBeamElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleBeamElement): AssembleBeamNode;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingAreaElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingAreaElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingAreaElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingAreaElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingAreaElement): AssembleCeilingAreaElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingBaseElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingBaseElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingBaseElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingBaseElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingBaseElement): AssembleCeilingBaseElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingDecorateElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingDecorateElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingDecorateElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingDecorateElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingDecorateElement): AssembleCeilingDecorateElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingEdgeElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingEdgeElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingEdgeElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingEdgeElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingEdgeElement): AssembleCeilingEdgeElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingElement): AssembleCeilingElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingHangingElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingHangingElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingHangingElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingHangingElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingHangingElement): AssembleCeilingHangingElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingPlaneElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingPlaneElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingPlaneElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingPlaneElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingPlaneElement): AssembleCeilingPlaneElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCeilingSurfaceElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCeilingSurfaceElement } from 'sk/data/scheme/database/pattern/element/AssembleCeilingSurfaceElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCeilingSurfaceElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCeilingSurfaceElement): AssembleCeilingSurfaceElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleColumnElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleColumnElement } from 'sk/data/scheme/database/pattern/element/AssembleColumnElement';
    import { AssembleColumnNode } from 'sk/data/scheme/database/pattern/node/AssembleColumnNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleColumnElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleColumnElement): AssembleColumnNode;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleCompositeCeilingElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleCompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleCompositeCeilingElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleCompositeCeilingElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleCompositeCeilingElement): AssembleCompositeCeilingElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleDoorElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleDoorElement } from 'sk/data/scheme/database/pattern/element/AssembleDoorElement';
    import { AssembleDoorNode } from 'sk/data/scheme/database/pattern/node/AssembleDoorNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleDoorElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleDoorElement): AssembleDoorNode;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleFlatWallElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { AssembleFlatWallNode } from 'sk/data/scheme/database/pattern/node/AssembleFlatWallNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleFlatWallElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleFlatWallElement): AssembleFlatWallNode;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleFloorplanElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleFloorplanElement } from 'sk/data/scheme/database/pattern/element/AssembleFloorplanElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleFloorplanElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleFloorplanElement): AssembleFloorplanElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AssembleFloorplanElement): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleLevelingCeilingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleLevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingCeilingElement';
    import { AssembleLevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/AssembleLevelingCeilingNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleLevelingCeilingElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleLevelingCeilingElement): AssembleLevelingCeilingNode;
        computeProperty(context: SchemeElementPerformerContext, element: AssembleLevelingCeilingElement, index: number, node: AssembleLevelingCeilingNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleLevelingFloorElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleLevelingFloorElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingFloorElement';
    import { AssembleLevelingFloorNode } from 'sk/data/scheme/database/pattern/node/AssembleLevelingFloorNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleLevelingFloorElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleLevelingFloorElement): AssembleLevelingFloorNode;
        computeProperty(context: SchemeElementPerformerContext, element: AssembleLevelingFloorElement, index: number, node: AssembleLevelingFloorNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleLevelingWallElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleLevelingWallElement } from 'sk/data/scheme/database/pattern/element/AssembleLevelingWallElement';
    import { AssembleLevelingWallNode } from 'sk/data/scheme/database/pattern/node/AssembleLevelingWallNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleLevelingWallElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleLevelingWallElement): AssembleLevelingWallNode;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssemblePelmetElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssemblePelmetElement } from 'sk/data/scheme/database/pattern/element/AssemblePelmetElement';
    import { AssemblePelmetNode } from 'sk/data/scheme/database/pattern/node/AssemblePelmetNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssemblePelmetElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssemblePelmetElement): AssemblePelmetNode;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleRoomElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AssembleRoomPatternElement } from 'sk/data/family/database/pattern/element/AssembleRoomPatternElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { AssembleRoomElement } from 'sk/data/scheme/database/pattern/element/AssembleRoomElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleRoomElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AssembleRoomElement): AssembleRoomElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AssembleRoomElement): any;
        computeProperty(context: SchemeElementPerformerContext, element: AssembleRoomElement, index: number, node: AssembleRoomNode): ResultEnum;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): AssembleRoomPatternElement;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/AssembleWindowElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AssembleWindowElement } from 'sk/data/scheme/database/pattern/element/AssembleWindowElement';
    import { AssembleWindowNode } from 'sk/data/scheme/database/pattern/node/AssembleWindowNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class AssembleWindowElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: AssembleWindowElement): AssembleWindowNode;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomAreaElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomAreaElement } from 'sk/data/scheme/database/pattern/element/BathroomAreaElement';
    import { BathroomAreaNode } from 'sk/data/scheme/database/pattern/node/BathroomAreaNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomAreaElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomAreaElement): BathroomAreaElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomAreaElement, index: number, node: BathroomAreaNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomCeilingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomCeilingElement } from 'sk/data/scheme/database/pattern/element/BathroomCeilingElement';
    import { BathroomCeilingNode } from 'sk/data/scheme/database/pattern/node/BathroomCeilingNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomCeilingElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomCeilingElement): BathroomCeilingElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomCeilingElement, index: number, node: BathroomCeilingNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomClosestoolElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomClosestoolElement } from 'sk/data/scheme/database/pattern/element/BathroomClosestoolElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomClosestoolElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomClosestoolElement): BathroomClosestoolElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomConverElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomConverElement } from 'sk/data/scheme/database/pattern/element/BathroomConverElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomConverElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomConverElement): BathroomConverElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomDoorElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomDoorElement } from 'sk/data/scheme/database/pattern/element/BathroomDoorElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomDoorElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomDoorElement): BathroomDoorElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
    import { BathroomNode } from 'sk/data/scheme/database/pattern/node/BathroomNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomElement): BathroomElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomElement, index: number, node: BathroomNode): ResultEnum;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomFloorDrainElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDrainElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDrainElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomFloorDrainElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomFloorDrainElement): BathroomFloorDrainElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomFloorDryElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { BathroomFloorDryNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorDryNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomFloorDryElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomFloorDryElement): BathroomFloorDryElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: BathroomFloorDryElement): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomFloorDryElement, index: number, node: BathroomFloorDryNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomFloorDryPlankElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDryPlankElement } from 'sk/data/scheme/database/assemble/element/BathroomFloorDryPlankElement';
    import { BathroomFloorDryPlankNode } from 'sk/data/scheme/database/assemble/node/BathroomFloorDryPlankNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemePlaneElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemePlaneElementPerformer";
    export class BathroomFloorDryPlankElementPerformer extends SchemePlaneElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomFloorDryPlankElement): BathroomFloorDryPlankElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomFloorDryPlankElement, index: number, node: BathroomFloorDryPlankNode): ResultEnum;
        computeStructureAfterAsync(context: ElementPerformerContext, element: BathroomFloorDryPlankElement, node: BathroomFloorDryPlankNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomFloorElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorElement';
    import { BathroomFloorNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomFloorElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomFloorElement): BathroomFloorElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomFloorElement, index: number, node: BathroomFloorNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomFloorWetElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { BathroomFloorWetElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetElement';
    import { BathroomFloorWetNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorWetNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomFloorWetElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomFloorDryElement): BathroomFloorWetElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomFloorWetElement, index: number, node: BathroomFloorWetNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomFloorWetSlotElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { BathroomFloorWetSlotElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetSlotElement';
    import { BathroomFloorWetSlotNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorWetSlotNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomFloorWetSlotElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomFloorDryElement): BathroomFloorWetSlotElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomFloorWetSlotElement, index: number, node: BathroomFloorWetSlotNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomFloorWetWareElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
    import { BathroomFloorWetWareElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetWareElement';
    import { BathroomFloorWetWareNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorWetWareNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomFloorWetWareElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomFloorDryElement): BathroomFloorWetWareElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomFloorWetWareElement, index: number, node: BathroomFloorWetWareNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomHeaterElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomHeaterElement } from 'sk/data/scheme/database/pattern/element/BathroomHeaterElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomHeaterElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomHeaterElement): BathroomHeaterElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomShowerElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomShowerElement } from 'sk/data/scheme/database/pattern/element/BathroomShowerElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomShowerElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomShowerElement): BathroomShowerElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomSpliterElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomSpliterElement } from 'sk/data/scheme/database/pattern/element/BathroomSpliterElement';
    import { BathroomSpliterNode } from 'sk/data/scheme/database/pattern/node/BathroomSpliterNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomSpliterElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomSpliterElement): BathroomSpliterElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomSpliterElement, index: number, node: BathroomSpliterNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomWallCupboardElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomWallCupboardElement } from 'sk/data/scheme/database/pattern/element/BathroomWallCupboardElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomWallCupboardElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomWallCupboardElement): BathroomWallCupboardElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BathroomWallElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BathroomWallElement } from 'sk/data/scheme/database/pattern/element/BathroomWallElement';
    import { BathroomWallNode } from 'sk/data/scheme/database/pattern/node/BathroomWallNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BathroomWallElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BathroomWallElement): BathroomWallElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: BathroomWallElement, index: number, node: BathroomWallNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BedroomBedElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BedroomBedElement } from 'sk/data/scheme/database/pattern/element/BedroomBedElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BedroomBedElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BedroomBedElement): BedroomBedElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/BedroomWardrobeElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { BedroomWardrobeElement } from 'sk/data/scheme/database/pattern/element/BedroomWardrobeElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class BedroomWardrobeElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: BedroomWardrobeElement): BedroomWardrobeElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/CompositeCeilingElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CompositeCeilingElement } from 'sk/data/scheme/database/pattern/element/CompositeCeilingElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class CompositeCeilingElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CompositeCeilingElement): CompositeCeilingElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/CompositeWallElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CompositeWallElement } from 'sk/data/scheme/database/pattern/element/CompositeWallElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class CompositeWallElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CompositeWallElement): CompositeWallElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/DecorateLayerElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { DecorateLayerElement } from 'sk/data/scheme/database/pattern/element/DecorateLayerElement';
    import { DecorateLayerNode } from 'sk/data/scheme/database/pattern/node/DecorateLayerNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class DecorateLayerElementPerformer extends PatternInstanceElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: DecorateLayerElement): DecorateLayerNode;
        computeProperty(context: SchemeElementPerformerContext, element: DecorateLayerElement, index: number, node: DecorateLayerNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/FloorCupboardElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FloorCupboardElement } from 'sk/data/scheme/database/pattern/element/FloorCupboardElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class FloorCupboardElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: FloorCupboardElement): FloorCupboardElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/KitchenroomFloorCabinetElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { KitchenroomFloorCabinetElement } from 'sk/data/scheme/database/pattern/element/KitchenroomFloorCabinetElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class KitchenroomFloorCabinetElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: KitchenroomFloorCabinetElement): KitchenroomFloorCabinetElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/KitchenroomSurfaceElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { KitchenroomSurfaceElement } from 'sk/data/scheme/database/pattern/element/KitchenroomSurfaceElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class KitchenroomSurfaceElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: KitchenroomSurfaceElement): KitchenroomSurfaceElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/KitchenroomWallCabinetElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { KitchenroomWallCabinetElement } from 'sk/data/scheme/database/pattern/element/KitchenroomWallCabinetElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class KitchenroomWallCabinetElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: KitchenroomWallCabinetElement): KitchenroomWallCabinetElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/KitchenSinkElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { KitchenSinkElement } from 'sk/data/scheme/database/pattern/element/KitchenSinkElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class KitchenSinkElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: KitchenSinkElement): KitchenSinkElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/LevelingCeilingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { LevelingCeilingElement } from 'sk/data/scheme/database/pattern/element/LevelingCeilingElement';
    import { LevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/LevelingCeilingNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class LevelingCeilingElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: LevelingCeilingElement): LevelingCeilingElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: LevelingCeilingElement): LevelingCeilingNode;
        computeProperty(context: SchemeElementPerformerContext, element: LevelingCeilingElement, index: number, node: LevelingCeilingNode): ResultEnum;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/LevelingFloorElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { LevelingFloorNode } from 'sk/data/scheme/database/pattern/node/LevelingFloorNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class LevelingFloorElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: LevelingFloorElement): LevelingFloorElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: LevelingFloorElement): LevelingFloorNode;
        computeProperty(context: SchemeElementPerformerContext, element: LevelingFloorElement, index: number, node: LevelingFloorNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/LevelingWallElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { LevelingWallNode } from 'sk/data/scheme/database/pattern/node/LevelingWallNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class LevelingWallElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: LevelingWallElement): LevelingWallElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeShape(context: SchemeElementPerformerContext, element: LevelingWallElement, index: number, node: LevelingWallNode): ResultEnum;
        computeStructureShapeAsync(context: SchemeElementPerformerContext, element: LevelingWallElement, node: LevelingWallNode): Promise<ResultObject>;
        computeProperty(context: SchemeElementPerformerContext, element: LevelingWallElement, index: number, node: LevelingWallNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/PelmetElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PelmetElement } from 'sk/data/scheme/database/pattern/element/PelmetElement';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class PelmetElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PelmetElement): PelmetElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
    }
}
declare module "sk/rule/data/scehme/performer/assembler/ProxyCeilingElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ProxyCeilingElement } from 'sk/data/scheme/database/pattern/element/ProxyCeilingElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class ProxyCeilingElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ProxyCeilingElement): ProxyCeilingElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/assistant/SchemeAssistantElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AssistantElement } from 'sk/data/family/element/assistant/AssistantElement';
    import { AssistantNode } from 'sk/data/family/model/assistant/AssistantNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeBrepElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer";
    export class SchemeAssistantElementPerformer extends SchemeBrepElementPerformer {
        computeProperty(context: SchemeElementPerformerContext, element: AssistantElement, index: number, node: AssistantNode): ResultEnum;
        computeLocalMatrix(node: AssistantNode): void;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: AssistantElement, index: number, node: AssistantNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assistant/SchemeAnchorElementPerformer" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { AnchorElement } from 'sk/data/family/element/assistant/AnchorElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { AnchorNode } from 'sk/data/family/model/assistant/AnchorNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeAssistantElementPerformer } from "sk/rule/data/scehme/performer/assistant/SchemeAssistantElementPerformer";
    export class SchemeAnchorElementPerformer extends SchemeAssistantElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AnchorElement): AnchorElement;
        isTargetInstance(element: AnchorElement): boolean;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: AnchorElement): AnchorNode;
        computeElementProperty(context: ElementPerformerContext, source: AnchorElement, target: AnchorElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: AnchorElement, node: AnchorNode): void;
        computeLocalMatrix(node: AnchorNode): Matrix3d;
    }
}
declare module "sk/rule/data/scehme/performer/assistant/SchemeReferenceAxisElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ReferenceAxisElement } from 'sk/data/family/element/assistant/reference/ReferenceAxisElement';
    import { ReferenceAxisNode } from 'sk/data/family/model/assistant/reference/ReferenceAxisNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeAssistantElementPerformer } from "sk/rule/data/scehme/performer/assistant/SchemeAssistantElementPerformer";
    export class SchemeReferenceAxisElementPerformer extends SchemeAssistantElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: ReferenceAxisElement): ReferenceAxisElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: ReferenceAxisElement): ReferenceAxisNode;
        computeProperty(context: SchemeElementPerformerContext, element: ReferenceAxisElement, index: number, node: ReferenceAxisNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: ReferenceAxisElement, index: number, node: ReferenceAxisNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assistant/SchemeReferenceLineElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ReferenceLineElement } from 'sk/data/family/element/assistant/reference/ReferenceLineElement';
    import { ReferenceLineNode } from 'sk/data/family/model/assistant/reference/ReferenceLineNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeAssistantElementPerformer } from "sk/rule/data/scehme/performer/assistant/SchemeAssistantElementPerformer";
    export class SchemeReferenceLineElementPerformer extends SchemeAssistantElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: ReferenceLineElement): ReferenceLineElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: ReferenceLineElement): ReferenceLineNode;
        computeProperty(context: SchemeElementPerformerContext, element: ReferenceLineElement, index: number, node: ReferenceLineNode): ResultEnum;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: ReferenceLineElement, index: number, node: ReferenceLineNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assistant/SchemeReferencePlaneElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ReferencePlaneElement } from 'sk/data/family/element/assistant/reference/ReferencePlaneElement';
    import { ReferencePlaneNode } from 'sk/data/family/model/assistant/reference/ReferencePlaneNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeAssistantElementPerformer } from "sk/rule/data/scehme/performer/assistant/SchemeAssistantElementPerformer";
    export class SchemeReferencePlaneElementPerformer extends SchemeAssistantElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: ReferencePlaneElement): ReferencePlaneElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: ReferencePlaneElement): ReferencePlaneNode;
        computeProperty(context: SchemeElementPerformerContext, element: ReferencePlaneElement, index: number, node: ReferencePlaneNode): ResultEnum;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: ReferencePlaneElement, index: number, node: ReferencePlaneNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/assistant/SchemeUnderlayElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { HttpDeviceService } from 'cross/core/device/http/HttpDeviceService';
    import { UnderlayElement } from 'sk/data/family/element/assistant/UnderlayElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { UnderlayNode } from 'sk/data/family/model/assistant/UnderlayNode';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeBrepElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer";
    export class UnderlayElementPerformer extends SchemeBrepElementPerformer {
        protected _httpService: HttpDeviceService;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: UnderlayElement): UnderlayElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: UnderlayElement): UnderlayNode;
        prepareAsync(context: SchemeElementPerformerContext, containerElement: BrepElement, element: UnderlayElement): Promise<ElementPerformerResult>;
        computeProperty(context: SchemeElementPerformerContext, element: UnderlayElement, index: number, node: UnderlayNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeAreaElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { AreaElement } from 'sk/data/family/element/brep/AreaElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeBrepElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer";
    export class SchemeAreaElementPerformer extends SchemeBrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AreaElement): any;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeGroupElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    import { GroupElement } from 'sk/data/family/element/brep/GroupElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class SchemeGroupElementPerformer extends SchemeContentElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: ComponentElement, element: GroupElement): GroupNode;
        computeProperty(context: SchemeElementPerformerContext, element: GroupElement, index: number, node: GroupNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeObserverElementPerformer" {
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ObserverViewElement } from 'sk/data/family/element/brep/observer/ObserverViewElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeBrepElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer";
    export class SchemeObserverElementPerformer extends SchemeBrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ObserverViewElement): ObserverViewNode;
    }
}
declare module "sk/rule/data/scehme/performer/brep/SchemeStructureElementPerformer" {
    import { SchemeNestElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeNestElementPerformer";
    export class SchemeStructureElementPerformer extends SchemeNestElementPerformer {
    }
}
declare module "sk/rule/data/scehme/performer/family/SchemeFamilyAnchorElementPerformer" {
    import { AnchorElement } from 'sk/data/family/element/assistant/AnchorElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { AnchorNode } from 'sk/data/family/model/assistant/AnchorNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeAnchorElementPerformer } from "sk/rule/data/scehme/performer/assistant/SchemeAnchorElementPerformer";
    export class SchemeFamilyAnchorElementPerformer extends SchemeAnchorElementPerformer {
        isTargetInstance(element: AnchorElement): boolean;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: AnchorElement): AnchorNode;
    }
}
declare module "sk/rule/data/scehme/performer/family/SchemeFamilyContainerElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { FamilyContainerElement } from 'sk/data/family/element/instance/FamilyContainerElement';
    import { FamilyContainerNode } from 'sk/data/family/model/instance/FamilyContainerNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeFamilyContainerElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: FamilyContainerElement): FamilyContainerElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: FamilyContainerElement): FamilyContainerNode;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeBeamElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { BeamElement } from 'sk/data/scheme/database/floorplan/element/BeamElement';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class BeamElementCalculatorCache extends ElementCache {
    }
    export class SchemeBeamElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: BeamElement): BeamElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: BeamElement): BeamNode;
        computeTechnologyValid(context: SchemeElementPerformerContext, element: BeamElement, node: BeamNode): void;
        protected testWallValid(node: BeamNode): boolean;
        computeProperty(context: SchemeElementPerformerContext, element: BeamElement, index: number, node: BeamNode): ResultEnum;
        buildElementStructureAsync(context: SchemeElementPerformerContext, parentElement: BeamElement, structure: StructureElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeCeilingElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { CeilingElement } from 'sk/data/scheme/database/floorplan/element/CeilingElement';
    import { CeilingNode } from 'sk/data/scheme/database/floorplan/model/CeilingNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeCeilingElementPerformer extends SchemeInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: CeilingElement): CeilingElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: CeilingElement, index: number, node: CeilingNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeCeilingSurfaceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CeilingSurfaceElement } from 'sk/data/scheme/database/floorplan/element/CeilingSurfaceElement';
    import { CeilingSurfaceNode } from 'sk/data/scheme/database/floorplan/model/CeilingSurfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeCeilingSurfaceElementPerformer extends ContentInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: CeilingSurfaceElement): CeilingSurfaceNode;
        computeProperty(context: SchemeElementPerformerContext, element: CeilingSurfaceElement, index: number, node: CeilingSurfaceNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeColumnElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ColumnElement } from 'sk/data/scheme/database/floorplan/element/ColumnElement';
    import { ColumnNode } from 'sk/data/scheme/database/floorplan/model/ColumnNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class ColumnElementCalculatorCache extends ElementCache {
    }
    export class SchemeColumnElementPerformer extends FamilyInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: ColumnElement): ColumnElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: ColumnElement): ColumnNode;
        computeTechnologyValid(context: SchemeElementPerformerContext, element: ColumnElement, node: ColumnNode): void;
        protected testWallValid(node: ColumnNode): boolean;
        computeProperty(context: SchemeElementPerformerContext, element: ColumnElement, index: number, node: ColumnNode): ResultEnum;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        buildElementStructureAsync(context: SchemeElementPerformerContext, parentElement: ColumnElement, structure: StructureElement): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWallSurfaceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallSurfaceElement } from 'sk/data/scheme/database/floorplan/element/WallSurfaceElement';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeWallSurfaceElementPerformer extends SchemeInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeStructureReleation(context: ElementPerformerContext, element: WallSurfaceElement, node: WallSurfaceNode): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: WallSurfaceElement, index: number, node: WallSurfaceNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeCowallElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CowallElement } from 'sk/data/scheme/database/floorplan/element/CowallElement';
    import { CowallNode } from 'sk/data/scheme/database/floorplan/model/CowallNode';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeCowallElementPerformer extends SchemeInstanceElementPerformer {
        computeElement(context: ElementPerformerContext, element: CowallElement): ResultEnum;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeStructureNode(context: ElementPerformerContext, element: CowallElement, node: CowallNode): ResultEnum;
        computeStructureReleation(context: ElementPerformerContext, element: CowallElement, node: CowallNode): void;
        computeProperty(context: ElementPerformerContext, element: CowallElement, index: number, node: CowallNode): ResultEnum;
        computeShape(context: ElementPerformerContext, element: any, index: number, node: any): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeOpeningElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { OpeningElement } from 'sk/data/family/element/instance/OpeningElement';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeOpeningElementPerformer extends FamilyInstanceElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: OpeningElement, node: OpeningNode): Promise<ResultObject>;
        private computeProfileDataAsync;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeDoorElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { DoorElement } from 'sk/data/scheme/database/floorplan/element/DoorElement';
    import { DoorNode } from 'sk/data/scheme/database/floorplan/model/DoorNode';
    import { SchemeOpeningElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeOpeningElementPerformer";
    export class SchemeDoorElementPerformer extends SchemeOpeningElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: DoorElement): DoorElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: DoorElement): DoorNode;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeFlatWallElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { FlatWallPatternElement } from 'sk/data/family/database/pattern/element/FlatWallPatternElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FlatWallElement } from 'sk/data/scheme/database/pattern/element/FlatWallElement';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { PatternInstanceElementPerformer } from "sk/rule/data/performer/pattern/PatternInstanceElementPerformer";
    export class SchemeFlatWallElementPerformer extends PatternInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: FlatWallElement): FlatWallElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): FlatWallPatternElement;
        computeProperty(context: SchemeElementPerformerContext, element: FlatWallElement, index: number, node: FlatWallNode): ResultEnum;
        computeStructureAfter(context: SchemeElementPerformerContext, element: FlatWallElement, node: FlatWallNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeFlatWallGroupElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FlatWallGroupElement } from 'sk/data/scheme/database/pattern/element/FlatWallGroupElement';
    import { FlatWallGroupNode } from 'sk/data/scheme/database/pattern/node/FlatWallGroupNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeFlatWallGroupElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: FlatWallGroupElement): FlatWallGroupElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): FlatWallGroupElement;
        computeProperty(context: SchemeElementPerformerContext, element: FlatWallGroupElement, index: number, node: FlatWallGroupNode): ResultEnum;
        computeStructureAfter(context: SchemeElementPerformerContext, element: FlatWallGroupElement, node: FlatWallGroupNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeFloorElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { FloorElement } from 'sk/data/scheme/database/floorplan/element/FloorElement';
    import { FloorNode } from 'sk/data/scheme/database/floorplan/model/FloorNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeFloorElementPerformer extends SchemeInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: FloorElement): FloorElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: any): any;
        computeStructureAfter(context: SchemeElementPerformerContext, element: FloorElement, node: FloorNode): ResultEnum;
        computeProperty(context: SchemeElementPerformerContext, element: FloorElement, index: number, node: FloorNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/BaseboardElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { BaseboardElement } from 'sk/data/scheme/database/floorplan/element/BaseboardElement';
    import { BaseboardNode } from 'sk/data/scheme/database/floorplan/model/BaseboardNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { LinearElementPerformer } from "sk/rule/data/scehme/performer/instance/LinearElementPerformer";
    export class BaseboardElementPerformer extends LinearElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: BaseboardElement): BaseboardElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: BaseboardElement): BaseboardNode;
        computeProperty(context: SchemeElementPerformerContext, element: BaseboardElement, index: number, node: BaseboardNode): ResultEnum;
        computeLinear(context: SchemeElementPerformerContext, node: BaseboardNode): void;
        protected calBaseboardPath2(context: SchemeElementPerformerContext, node: BaseboardNode): void;
        protected calBaseboardPath(context: SchemeElementPerformerContext, node: BaseboardNode): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/CorniceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { CorniceElement } from 'sk/data/scheme/database/floorplan/element/CorniceElement';
    import { CorniceNode } from 'sk/data/scheme/database/floorplan/model/CorniceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { LinearElementPerformer } from "sk/rule/data/scehme/performer/instance/LinearElementPerformer";
    export class CorniceElementPerformer extends LinearElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: CorniceElement): CorniceElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: CorniceElement): CorniceNode;
        computeProperty(context: SchemeElementPerformerContext, element: CorniceElement, index: number, node: CorniceNode): ResultEnum;
        computeLinear(context: SchemeElementPerformerContext, node: CorniceNode): void;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeRoomElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeRoomElementPerformer extends SchemeInstanceElementPerformer {
        private isConnectedCowallInLine;
        private createCowallSurface;
        private copyCowallSurface;
        computeElement(context: ElementPerformerContext, element: RoomElement): ResultEnum;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: RoomElement): RoomNode;
        computeProperty(context: ElementPerformerContext, element: RoomElement, index: number, node: RoomNode): ResultEnum;
        computeStructureNode(context: ElementPerformerContext, element: RoomElement, node: RoomNode): ResultEnum;
        computeStructureReleation(context: ElementPerformerContext, element: RoomElement, node: RoomNode): ResultEnum;
        computeShape(context: ElementPerformerContext, element: RoomElement, index: number, node: RoomNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWallLinePerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallLineElement } from 'sk/data/scheme/database/floorplan/element/WallLineElement';
    import { WallLineNode } from 'sk/data/scheme/database/floorplan/model/WallLineNode';
    import { SchemeBrepElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer";
    export class SchemeWallLinePerformer extends SchemeBrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: WallLineElement): WallLineNode;
        computeStructureReleation(context: ElementPerformerContext, element: WallLineElement, node: WallLineNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWallPointPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallPointElement } from 'sk/data/scheme/database/floorplan/element/WallPointElement';
    import { WallPointNode } from 'sk/data/scheme/database/floorplan/model/WallPointNode';
    import { SchemeVertexElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeVertexElementPerformer";
    export class SchemeWallPointPerformer extends SchemeVertexElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: WallPointElement): WallPointNode;
        computeStructureReleation(context: ElementPerformerContext, element: WallPointElement, node: WallPointNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWallElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallElement } from 'sk/data/scheme/database/floorplan/element/WallElement';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeWallElementPerformer extends SchemeInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: WallElement): WallNode;
        computeProperty(context: ElementPerformerContext, element: WallElement, index: number, node: WallNode): ResultEnum;
        computeStructureNode(context: ElementPerformerContext, element: WallElement, node: WallNode): ResultEnum;
        computeStructureReleation(context: ElementPerformerContext, element: WallElement, node: WallNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWallJoinnerPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { VertexElement } from 'sk/data/family/element/brep/VertexElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallJoinnerElement } from 'sk/data/scheme/database/floorplan/element/WallJoinnerElement';
    import { WallJoinnerNode } from 'sk/data/scheme/database/floorplan/model/WallJoinnerNode';
    import { SchemeVertexElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeVertexElementPerformer";
    export class SchemeWallJoinnerPerformer extends SchemeVertexElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: WallJoinnerElement): WallJoinnerNode;
        computeStructureReleation(context: ElementPerformerContext, element: WallJoinnerElement, node: WallJoinnerNode): ResultEnum;
        computeElementProperty(context: ElementPerformerContext, source: VertexElement, target: VertexElement): void;
        computePropertyTransform(context: ElementPerformerContext, element: VertexElement, node: VertexNode): void;
        computeShape(context: ElementPerformerContext, element: WallJoinnerElement, index: number, node: WallJoinnerNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeFloorplanElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FloorplanElement } from 'sk/data/scheme/database/floorplan/element/FloorplanElement';
    import { FloorplanNode } from 'sk/data/scheme/database/floorplan/model/FloorplanNode';
    import { WallSurfaceNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeBrepElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeBrepElementPerformer";
    export class SchemeFloorplanElementPerformer extends SchemeBrepElementPerformer {
        createCache(context: ElementPerformerContext): ElementCache;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: FloorplanElement): FloorplanNode;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: FloorplanElement, index: number, node: FloorplanNode): ResultEnum;
        computeShapeMatrixImpl(context: SchemeElementPerformerContext, element: FloorplanElement, index: number, node: FloorplanNode, force: boolean): ResultEnum;
        computeStructure(context: SchemeElementPerformerContext, element: FloorplanElement, node: FloorplanNode): ResultEnum;
        computeFlatWallGroup(context: SchemeElementPerformerContext, floorplan: FloorplanElement): void;
        computeStructureAsync(context: SchemeElementPerformerContext, element: FloorplanElement, node: FloorplanNode, parameters?: any): Promise<ElementPerformerResult>;
        computeNativeShape(node: FloorplanNode): void;
        computeShape(context: SchemeElementPerformerContext, element: FloorplanElement, index: number, node: FloorplanNode): ResultEnum;
        private makeLevelingWallCode;
        private makeChestIdentifier;
        private makeFlatwallIdentifier;
        private makeFlatwallGroupIdentifier;
        private makePelmetIdentifier;
        private makeLevelingCeilingIdentifier;
        private makeOpenningsIdentifier;
        private makeHoleNodeIdentifier;
        private makeWallsurfaceIdentifier;
        private findCowall;
        protected computeWallSurface(context: ElementPerformerContext, floorplan: FloorplanNode): void;
        private connectSameSurface;
        protected calculateLinear(context: SchemeElementPerformerContext, surface: WallSurfaceNode): void;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeFloorplanNodePerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NodePerformer } from 'sk/data/family/performer/node/NodePerformer';
    import { NodePerformerContext } from 'sk/data/family/performer/node/NodePerformerContext';
    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';
    export class SchemeFloorplanNodePerformer extends NodePerformer {
        computeShape(context: NodePerformerContext, node: FloorplanNode): ResultEnum;
        protected computeWallSurface(floorplan: FloorplanNode): void;
        computeShapeMatrix(context: NodePerformerContext, node: FloorplanNode): ResultEnum;
        protected connectSameSurface(cowall1: CowallNode, cowall2: CowallNode, joinner: WallJoinnerNode, cacheMap: any): void;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeFloorplanPerformerUtil" {
    export class SchemeFloorplanPerformerUtil {
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeFloorSurfaceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FloorSurfaceElement } from 'sk/data/scheme/database/floorplan/element/FloorSurfaceElement';
    import { FloorSurfaceNode } from 'sk/data/scheme/database/floorplan/model/FloorSurfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeFloorSurfaceElementPerformer extends ContentInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: FloorSurfaceElement): FloorSurfaceNode;
        computeProperty(context: SchemeElementPerformerContext, element: FloorSurfaceElement, index: number, node: FloorSurfaceNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeHoleElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { HoleElement } from 'sk/data/scheme/database/floorplan/element/HoleElement';
    import { HoleNode } from 'sk/data/scheme/database/floorplan/model/HoleNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeOpeningElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeOpeningElementPerformer";
    export class SchemeHoleElementPerformer extends SchemeOpeningElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: HoleElement): HoleElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: HoleElement): HoleNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemePolygonRoomElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PolygonRoomElement } from 'sk/data/scheme/database/floorplan/element/PolygonRoomElement';
    import { PolygonRoomNode } from 'sk/data/scheme/database/floorplan/model/PolygonRoomNode';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class SchemePolygonRoomElementPerformer extends BrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PolygonRoomElement): PolygonRoomNode;
        computeShapeMatrix(context: ElementPerformerContext, element: PolygonRoomElement, index: number, node: PolygonRoomNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemePolygonWallLineElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AreaLineElement } from 'sk/data/family/element/brep/area/AreaLineElement';
    import { AreaLineNode } from 'sk/data/family/model/brep/area/AreaLineNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PolygonWallElement } from 'sk/data/scheme/database/floorplan/element/PolygonWallElement';
    import { PolygonWallNode } from 'sk/data/scheme/database/floorplan/model/PolygonWallNode';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class SchemePolygonWallLineElementPerformer extends BrepElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PolygonWallElement): PolygonWallNode;
        computeShape(context: ElementPerformerContext, element: PolygonWallElement, index: number, node: PolygonWallNode): ResultEnum;
        computeShapeMatrix(context: ElementPerformerContext, element: AreaLineElement, index: number, node: AreaLineNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemePolygonWallPointElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AreaPointElement } from 'sk/data/family/element/brep/area/AreaPointElement';
    import { AreaPointNode } from 'sk/data/family/model/brep/area/AreaPointNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PolygonWallPointElement } from 'sk/data/scheme/database/floorplan/element/PolygonWallPointElement';
    import { PolygonWallPointNode } from 'sk/data/scheme/database/floorplan/model/PolygonWallPointNode';
    import { VertexElementPerformer } from "sk/rule/data/performer/brep/VertexElementPerformer";
    export class SchemePolygonWallPointElementPerformer extends VertexElementPerformer {
        constructor();
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PolygonWallPointElement): PolygonWallPointNode;
        computeShapeMatrix(context: ElementPerformerContext, element: AreaPointElement, index: number, node: AreaPointNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeProfileElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ProfileElement } from 'sk/data/family/element/brep/ProfileElement';
    import { ProfileNode } from 'sk/data/family/model/brep/ProfileNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class SchemeProfileElementPerformer extends SchemeContentElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ProfileElement): ProfileElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: ProfileElement): ProfileNode;
        getProfilePointsASync(context: ElementPerformerContext, profileId: string, profileParameters: any, node: any): void;
        getProfilePointsAsync(context: ElementPerformerContext, profileId: string, profileParameters: any, node: any): Promise<void>;
        computeElementProperty(context: ElementPerformerContext, source: ProfileElement, target: ProfileElement): void;
        buildElementAsync(context: ElementPerformerContext, containerElement: BrepElement, element: ProfileElement, parameters?: any): Promise<ResultObject>;
        computePropertyAsync(context: ElementPerformerContext, element: ProfileElement, index: number, node: ProfileNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeSpatialSurfaceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SpatialSurfaceElement } from 'sk/data/family/element/instance/SpatialSurfaceElement';
    import { SpatialSurfaceNode } from 'sk/data/family/model/instance/SpatialSurfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class SchemeSpatialSurfaceElementPerformer extends SchemeContentElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: SpatialSurfaceElement): SpatialSurfaceElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: any): any;
        computeProperty(context: SchemeElementPerformerContext, element: SpatialSurfaceElement, index: number, node: SpatialSurfaceNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWallLinePointPerformer" {
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallLinePointElement } from 'sk/data/scheme/database/floorplan/element/WallLinePointElement';
    import { WallLinePointNode } from 'sk/data/scheme/database/floorplan/model/WallLinePointNode';
    import { SchemeVertexElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeVertexElementPerformer";
    export class SchemeWallLinePointPerformer extends SchemeVertexElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: WallLinePointElement): WallLinePointNode;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWallSurfaceSpatialElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { WallSurfaceSpatialElement } from 'sk/data/scheme/database/floorplan/element/WallSurfaceSpatialElement';
    import { WallSurfaceSpatialNode } from 'sk/data/scheme/database/floorplan/model/WallSurfaceSpatialNode';
    import { SchemeInstanceElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeInstanceElementPerformer";
    export class SchemeWallSurfaceSpatialElementPerformer extends SchemeInstanceElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: any): any;
        computeProperty(context: ElementPerformerContext, element: WallSurfaceSpatialElement, index: number, node: WallSurfaceSpatialNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/floorplan/SchemeWindowElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ProfileDocumentService } from 'sk/data/family/structure/profile/ProfileDocumentService';
    import { WindowElement } from 'sk/data/scheme/database/floorplan/element/WindowElement';
    import { WindowNode } from 'sk/data/scheme/database/floorplan/model/WindowNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeOpeningElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeOpeningElementPerformer";
    export class SchemeWindowElementPerformer extends SchemeOpeningElementPerformer {
        protected _profileDocumentService: ProfileDocumentService;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: WindowElement): WindowElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: WindowElement): WindowNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        computeShape(context: SchemeElementPerformerContext, element: WindowElement, index: number, node: WindowNode): ResultEnum;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: WindowElement, node: WindowNode): Promise<ResultObject<any>>;
    }
}
declare module "sk/rule/data/scehme/util/SpaceNodePerformerUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentPlaceTypeEnum } from 'foundation/data/common/enumeration/ContentPlaceTypeEnum';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    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 { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { Computor, ComputorValue } from 'sk/data/family/util/ComputeUtil';
    import { ChestNodeData, PropertyChestViewString, ChestPlankViewData } from 'sk/data/scheme/database/floorplan/model/util/ChestNodeData';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { SpaceNode } from 'sk/data/scheme/database/furniture/model/SpaceNode';
    export type SpacePropertyComputorMap = {
        left: Computor;
        bottom: Computor;
        back: Computor;
        width: Computor;
        height: Computor;
        depth: Computor;
    };
    export class PropertyInfo {
        fieldName: PropertyChestViewString;
        data: ChestNodeData;
        property: ComputorValue;
        addition: ComputorValue;
        constructor(data: ChestNodeData, fieldName: PropertyChestViewString, property: ComputorValue, addition?: ComputorValue);
        isReverse(): boolean;
        toComputor(): Computor;
    }
    export class SpaceNodePerformerUtil {
        static isPlankVertical(plank: PlankNode, vector: Vector3): any;
        static isPlankParallel(plank: PlankNode, vector: Vector3): any;
        static getViewPlaceCd(data: ChestNodeData, node: ContentInstanceNode | ContentInstanceElement): ContentPlaceTypeEnum;
        static isParallel(v1: Vector3, v2: Vector3): boolean;
        static getSymbolProperty(data: ChestNodeData, fieldName: "width" | "height" | "depth", node: ContentInstanceNode | ContentInstanceElement): FormulaProperty;
        static getComputorByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode): Computor;
        static getPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode | ContentInstanceElement): PropertyInfo;
        static getFrontPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode | ContentInstanceElement): PropertyInfo;
        static getBackPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode | ContentInstanceElement): PropertyInfo;
        static getLeftPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode | ContentInstanceElement): PropertyInfo;
        static getRightPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode | ContentInstanceElement): PropertyInfo;
        static getTopPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode | ContentInstanceElement): PropertyInfo;
        static getBottomPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode | ContentInstanceElement): PropertyInfo;
        static getSymbolString(fieldName: PropertyChestViewString): "width" | "height" | "depth";
        static getPropertyComputorMapBySpaceNode(space: SpaceNode): SpacePropertyComputorMap;
        static computeEntityInfo(data: ChestNodeData, entity: FamilyInstanceNode): ChestPlankViewData;
        private static roundValue;
        static getBackPlank(data: ChestNodeData, polygon: Array<Vector2>, startDepth: number): PlaneNode;
        static computePlanksInfo(data: ChestNodeData): void;
        static computeDepthList(data: ChestNodeData): void;
        static computeSpacePolygons(data: ChestNodeData, depth: number): any;
        private static canWareCutSpace;
        private static canWareInsideCutSpace;
        private static findWareBackPlank;
        static reComposeFormula(formula: FormulaProperty, variableCodes?: string[]): string;
    }
}
declare module "sk/rule/data/scehme/util/ChestSpaceNodeCreator" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { ChestNodeData } from 'sk/data/scheme/database/floorplan/model/util/ChestNodeData';
    type Polygon = Vector2[];
    export class ChestSpaceNodeCreator {
        chest: WareNode;
        constructor(chest: WareNode);
        createAutoSpaceByView(viewType: ObserverModeEnum): void;
        static splitPolygonInfo(polygonInfo: {
            polygon: Vector2[];
            startDepth: number;
            endDepth: number;
            box: Box2;
        }): {
            polygon: Vector2[];
            startDepth: number;
            endDepth: number;
            box: Box2;
        }[];
        static splitPolygonSorter(a: number, b: number): boolean;
        static splitPolygon(polygon: Polygon): Polygon[];
        isAutoPolygon(polygonBox: Box2, startDepth: number, data: ChestNodeData): boolean;
        createSpacesByView(viewType: ObserverModeEnum, startDepth?: number): void;
        private clearSpaceNode;
    }
}
declare module "sk/rule/data/scehme/util/ChestNodeUtil" {
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    import { AssemblyPlaneElement } from 'sk/data/family/element/instance/AssemblyPlaneElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { AssemblyNode } from 'sk/data/family/model/instance/AssemblyNode';
    import { AssemblyPlaneNode } from 'sk/data/family/model/instance/AssemblyPlaneNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { DoorDirectionEnum } from 'sk/data/family/enumeration/DoorDirectionEnum';
    import { Computor, ComputorValue } from 'sk/data/family/util/ComputeUtil';
    import { AroundPlankInfo, ChestNodeData, ChestPlankViewData, PropertyChestViewString } from 'sk/data/scheme/database/floorplan/model/util/ChestNodeData';
    import { SpaceNode } from 'sk/data/scheme/database/furniture/model/SpaceNode';
    import { PropertyInfo, SpacePropertyComputorMap } from "sk/rule/data/scehme/util/SpaceNodePerformerUtil";
    export const ChestViewDataCode = "view.data";
    export type DirectionString = 'left' | 'right' | 'top' | 'bottom' | 'back' | 'front';
    export class ChestNodeUtil {
        private static getChestView;
        static getChestViewData(chest: WareNode, viewType?: ObserverModeEnum): ChestNodeData;
        static dirtyChestViewData(chest: WareNode): void;
        static dirtyChildrenChestViewData(wareNode: WareNode): void;
        static clearChestSpace(chest: AssemblyNode): void;
        static computeSpaceByView(chest: WareNode, viewType?: ObserverModeEnum, startDepth?: number): void;
        static computeChildrenSpaceByView(wareNode: WareNode, viewType?: ObserverModeEnum, startDepth?: number): void;
        static canComputeChildSpaceByView(referenceEle: ContentElement): boolean;
        static getDrawerSurfacePlane(drawer: AssemblyNode | AssemblyPlaneNode | AssemblyElement | AssemblyPlaneElement): AssemblyNode | AssemblyPlaneNode | AssemblyElement | AssemblyPlaneElement;
        static getComputorByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode): Computor;
        static getPropertyInfoByName(data: ChestNodeData, fieldName: PropertyChestViewString, node?: ContentInstanceNode): PropertyInfo;
        static setContentRotationBySpaceNode(element: ContentInstanceElement, space: SpaceNode, rotation?: Value3): void;
        static setContentPropertyBySpaceNode(space: SpaceNode, fieldName: PropertyChestViewString, localSpaceValue: ComputorValue, element: ContentInstanceElement, propertyComputorMap?: SpacePropertyComputorMap): void;
        static setContentSystemProperty(element: ContentInstanceElement, propertyComputorMap: SpacePropertyComputorMap): void;
        static setContentProperty(data: ChestNodeData, fieldName: PropertyChestViewString, value: ComputorValue, additionValue: number, element: ContentInstanceElement): void;
        static getEntityAroundPlanks(data: ChestNodeData, entity: FamilyInstanceNode | ChestPlankViewData, getClose?: boolean, closeDistance?: number, depthAdjacent?: boolean, getInside?: boolean): Array<AroundPlankInfo>;
        static getEntityAroundPlankArrays(data: ChestNodeData, entity: FamilyInstanceNode, getClose?: boolean, closeDistance?: number): Array<PlaneNode[]>;
        static getEntityAroundPlanksByDirection(data: ChestNodeData, entity: FamilyInstanceNode | ChestPlankViewData, direction: DirectionString, getClose?: boolean, closeDistance?: number): PlaneNode[];
        static getPropertyComputorMapBySpaceNode(space: SpaceNode): SpacePropertyComputorMap;
        static computeChestNodeData(data: ChestNodeData): void;
        static isDimensionIdentifyChanged(name: string): boolean;
        static setDoorParametersBySpace(spaceNode: SpaceNode, element: ContentInstanceElement, doorDirection?: DoorDirectionEnum): void;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeChestElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { StringBuffer } from 'cross/runtime/lang/StringBuffer';
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { ChestElement } from 'sk/data/scheme/database/furniture/element/ChestElement';
    import { ChestNode } from 'sk/data/scheme/database/furniture/model/ChestNode';
    import { SpaceNode } from 'sk/data/scheme/database/furniture/model/SpaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeChestElementPerformer extends FamilyInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: ChestElement): ChestElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: ChestElement): ChestNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        computeShape(context: any, element: any, index: number, node: ChestNode): ResultEnum;
        computeStructureAfter(context: SchemeElementPerformerContext, element: Element, node: ChestNode): ResultEnum;
        protected computeDimensionIdentify(node: ChestNode): StringBuffer;
        protected computePlankDemensionIdentify(plank: PlaneNode): StringBuffer;
        computeSpaceNode(context: SchemeElementPerformerContext, node: DataNode): void;
        processSpaceNodeProperty(spaceNode: SpaceNode): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeSurfaceElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SurfaceComponentElement } from 'sk/data/family/element/component/SurfaceComponentElement';
    import { SurfaceElement } from 'sk/data/family/element/instance/SurfaceElement';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeSurfaceElementPerformer extends ContentInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: SurfaceComponentElement): Element;
        computeElementProperty(context: SchemeElementPerformerContext, source: SurfaceComponentElement, target: SurfaceElement): void;
        protected getFamilyFeaturesByCodeAsync(context: SchemeElementPerformerContext, element: SurfaceComponentElement, featureName: string): Promise<any>;
        setSurfaceNodeFromDecorateValueAsync(context: SchemeElementPerformerContext, node: SurfaceNode, decorateValue: DecorateValueStructure): Promise<void>;
        getDecorateInfoIdAsync(context: any, node: SurfaceNode, structure: DecorateValueStructure): Promise<ResultObject>;
        protected getDecorateVariableInfoIdAsync(context: any, structure: DecorateValueStructure): Promise<ResultObject>;
        getDecorateVariableInfoId(context: any, node: SurfaceNode, structure: DecorateValueStructure): string;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: SurfaceElement, node: SurfaceNode): Promise<ResultObject>;
        protected setNodeMaterialRotation(node: SurfaceNode, features: any): void;
        protected setSurfaceInfoFromFamilyInfoAsync(context: SchemeElementPerformerContext, node: SurfaceNode, infoId: string): Promise<void>;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeEdgeSurfaceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { EdgeSurfaceComponentElement } from 'sk/data/family/element/component/EdgeSurfaceComponentElement';
    import { EdgeSurfaceElement } from 'sk/data/family/element/instance/EdgeSurfaceElement';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeSurfaceElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeSurfaceElementPerformer";
    export class SchemeEdgeSurfaceElementPerformer extends SchemeSurfaceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: EdgeSurfaceComponentElement): Element;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: EdgeSurfaceElement): EdgeSurfaceNode;
        protected testIsSkipCompute(context: SchemeElementPerformerContext, element: EdgeSurfaceElement, defaultValue?: boolean): boolean;
        computeShape(context: SchemeElementPerformerContext, element: EdgeSurfaceElement, index: number, node: EdgeSurfaceNode): ResultEnum;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: EdgeSurfaceElement, index: number, node: EdgeSurfaceNode): ResultEnum;
        buildElementAsync(context: SchemeElementPerformerContext, element: EdgeSurfaceElement, componentElement: EdgeSurfaceComponentElement, parameter?: any): Promise<ResultObject>;
        computeStructureRuleAsync(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode): Promise<ResultObject>;
        buildElementReleation(context: SchemeElementPerformerContext, element: EdgeSurfaceElement): void;
        computeProperty(context: SchemeElementPerformerContext, element: EdgeSurfaceElement, index: number, node: EdgeSurfaceNode): ResultEnum;
        protected applyEdgeMaterial(node: EdgeSurfaceNode): void;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: EdgeSurfaceElement, node: EdgeSurfaceNode): Promise<ResultObject>;
        protected setNodeMaterialRotation(node: EdgeSurfaceNode, features: any): void;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeFramedDoorElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FramedDoorElement } from 'sk/data/scheme/database/furniture/element/FramedDoorElement';
    import { FramedDoorNode } from 'sk/data/scheme/database/furniture/model/FramedDoorNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeFramedDoorElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: FramedDoorElement): FramedDoorElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: FramedDoorElement): FramedDoorNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeFurnitureCountertopElementPerformer" {
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { FurnitureCountertopElement } from 'sk/data/scheme/database/furniture/element/FurnitureCountertopElement';
    import { FurnitureCountertopNode } from 'sk/data/scheme/database/furniture/node/FurnitureCountertopNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeFurnitureCountertopElementPerformer extends FamilyInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: FurnitureCountertopElement): FurnitureCountertopElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: FurnitureCountertopElement): FurnitureCountertopNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: FurnitureCountertopElement, element: FurnitureCountertopElement, parameters?: any): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeOperateLineElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { OperateLineElement } from 'sk/data/family/element/assistant/operate/OperateLineElement';
    import { OperateLineNode } from 'sk/data/family/model/assistant/operate/OperateLineNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { AssistantElementPerformer } from "sk/rule/data/performer/reference/AssistantElementPerformer";
    export class SchemeOperateLineElementPerformer extends AssistantElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: OperateLineElement): OperateLineElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: OperateLineElement): OperateLineNode;
        computeProperty(context: SchemeElementPerformerContext, element: OperateLineElement, index: number, node: OperateLineNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemePlaneSurfaceElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    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 { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PlaneSurfaceComponentElement } from 'sk/data/family/element/component/PlaneSurfaceComponentElement';
    import { PlaneSurfaceElement } from 'sk/data/family/element/instance/PlaneSurfaceElement';
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeSurfaceElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeSurfaceElementPerformer";
    export class PlaneSurfaceComponentCache extends ElementCache {
        materialId: string;
        materialVersion: string;
    }
    export class SchemePlaneSurfaceElementPerformer extends SchemeSurfaceElementPerformer {
        constructor();
        createCache(context: SchemeElementPerformerContext): ElementCache;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: PlaneSurfaceComponentElement): Element;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: PlaneSurfaceElement): PlaneSurfaceNode;
        computeProperty(context: SchemeElementPerformerContext, element: PlaneSurfaceElement, index: number, node: PlaneSurfaceNode): ResultEnum;
        buildElementStructureProperty(context: SchemeElementPerformerContext, instanceElement: PlaneSurfaceElement, componentElement: PlaneSurfaceComponentElement): ResultEnum;
        buildElementAsync(context: SchemeElementPerformerContext, element: PlaneSurfaceElement, componentElement: PlaneSurfaceComponentElement, parameter?: any): Promise<ResultObject>;
        onPrepareAsync(context: SchemeElementPerformerContext, containerElement: BrepElement, element: PlaneSurfaceElement): Promise<ElementPerformerResult>;
        protected setNodeMaterialRotation(node: PlaneSurfaceNode, features?: any): void;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeSchemeSlidingDoorElementPerformer" {
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { SlidingDoorElement } from 'sk/data/scheme/database/furniture/element/SlidingDoorElement';
    import { SlidingDoorNode } from 'sk/data/scheme/database/furniture/model/SlidingDoorNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeSlidingDoorElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: SlidingDoorElement): SlidingDoorElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: SlidingDoorElement): SlidingDoorNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: FamilyInstanceElement, element: SlidingDoorElement, parameters?: any): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeSectionSurfaceElementPerformer" {
    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 { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { SectionSurfaceComponentElement } from 'sk/data/family/element/component/SectionSurfaceComponentElement';
    import { ComponentNode } from 'sk/data/family/model/component/ComponentNode';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeSurfaceElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeSurfaceElementPerformer";
    export class SchemeSectionSurfaceElementPerformer extends SchemeSurfaceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: SectionSurfaceComponentElement): Element;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: SectionSurfaceComponentElement): ComponentNode;
        buildElementAsync(context: SchemeElementPerformerContext, element: SectionSurfaceComponentElement, componentElement: SectionSurfaceComponentElement, parameter?: any): Promise<ResultObject>;
        buildElementReleation(context: SchemeElementPerformerContext, element: SectionSurfaceComponentElement): void;
        onPrepareAsync(context: SchemeElementPerformerContext, containerElement: BrepElement, element: SectionSurfaceComponentElement): Promise<ElementPerformerResult>;
    }
}
declare module "sk/rule/data/scehme/performer/furniture/SchemeSplitterElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SplitterElement } from 'sk/data/family/element/instance/SplitterElement';
    import { SplitterNode } from 'sk/data/family/model/instance/SplitterNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class SchemeSplitterElementPerformer extends SchemeContentElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: SplitterElement): SplitterNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/ArrayContainerElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ComponentElement } from 'sk/data/family/element/component/ComponentElement';
    import { ArrayContainerElement } from 'sk/data/family/element/instance/ArrayContainerElement';
    import { ArrayContainerNode } from 'sk/data/family/model/instance/ArrayContainerNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ContentElementPerformer } from "sk/rule/data/performer/brep/ContentElementPerformer";
    export class ArrayContainerElementPerformer extends ContentElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: ArrayContainerElement): ArrayContainerElement;
        createNode(context: ElementPerformerContext, containerElement: ComponentElement, element: ArrayContainerElement): ArrayContainerNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/AssemblyElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { AssemblyElement } from 'sk/data/family/element/instance/AssemblyElement';
    import { AssemblyNode } from 'sk/data/family/model/instance/AssemblyNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class AssemblyElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: Element): AssemblyElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AssemblyElement): AssemblyNode;
        computeProperty(context: SchemeElementPerformerContext, element: AssemblyElement, index: number, node: AssemblyNode): ResultEnum;
        computePropertyTransform(context: SchemeElementPerformerContext, element: AssemblyElement, node: AssemblyNode): void;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/AssemblyPlaneElementPerformer" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { AssemblyPlaneElement } from 'sk/data/family/element/instance/AssemblyPlaneElement';
    import { AssemblyPlaneNode } from 'sk/data/family/model/instance/AssemblyPlaneNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemePlaneElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemePlaneElementPerformer";
    export class AssemblyPlaneElementPerformer extends SchemePlaneElementPerformer {
        private _isOpen;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: Element): AssemblyPlaneElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AssemblyPlaneElement): AssemblyPlaneNode;
        computeProperty(context: SchemeElementPerformerContext, element: AssemblyPlaneElement, index: number, node: AssemblyPlaneNode): ResultEnum;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
        computePropertyTransform(context: SchemeElementPerformerContext, element: AssemblyPlaneElement, node: AssemblyPlaneNode): void;
        getVariableValueByCode(context: SchemeElementPerformerContext, element: AssemblyPlaneElement, node: AssemblyPlaneNode, code: string, direct?: boolean): number;
        buildPropertyByFamilyDocument(context: SchemeElementPerformerContext, element: AssemblyPlaneElement, componentInstanceElement: ComponentInstanceElement, familyDocument: FamilyDocument): ResultEnum;
        appendPropertyAsync(context: SchemeElementPerformerContext, element: AssemblyPlaneElement, componentInstanceElement: ComponentInstanceElement, familyDocument: FamilyDocument, newElements: Types<Element>): Promise<ResultEnum>;
    }
}
declare module "sk/rule/data/scehme/performer/instance/BathroomLayoutAreaElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BathroomLayoutAreaElement } from 'sk/data/family/element/instance/BathroomLayoutAreaElement';
    import { BathroomLayoutAreaNode } from 'sk/data/family/model/instance/BathroomLayoutAreaNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class BathroomLayoutAreaElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: BathroomLayoutAreaElement): BathroomLayoutAreaElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: BathroomLayoutAreaElement): BathroomLayoutAreaNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/CountertopElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { CountertopElement } from 'sk/data/scheme/database/furniture/element/CountertopElement';
    import { CountertopNode } from 'sk/data/scheme/database/furniture/model/CountertopNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class CountertopElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: CountertopElement): CountertopElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: CountertopElement): CountertopNode;
        computeProperty(context: SchemeElementPerformerContext, element: CountertopElement, index: number, node: CountertopNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeWareElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { WareElement } from 'sk/data/family/element/instance/WareElement';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeWareElementPerformer extends FamilyInstanceElementPerformer {
        testElementBuild(calculatorTypeCd: string, element: WareElement): boolean;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: Element): WareElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: WareElement): WareNode;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/DynamicWareElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { DynamicWareElement } from 'sk/data/family/element/instance/DynamicWareElement';
    import { DynamicWareNode } from 'sk/data/family/model/instance/DynamicWareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeWareElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeWareElementPerformer";
    export class DynamicWareElementPerformer extends SchemeWareElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: DynamicWareElement): DynamicWareElement;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: DynamicWareElement): DynamicWareNode;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
        computeStructureAfter(context: ElementPerformerContext, element: DynamicWareElement, node: DynamicWareNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/FragmentElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FragmentElement } from 'sk/data/family/element/instance/FragmentElement';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class FragmentElementPerformer extends FamilyInstanceElementPerformer {
        testElementBuild(calculatorTypeCd: string, element: FragmentElement): boolean;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: Element): FragmentElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: FragmentElement): WareNode;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/FurnitureProfileWareElementPerformer" {
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { FurnitureProfileWareElement } from 'sk/data/scheme/database/furniture/element/FurnitureProfileWareElement';
    import { FurnitureProfileWareNode } from 'sk/data/scheme/database/furniture/node/FurnitureProfileWareNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class FurnitureProfileWareElementPerformer extends ContentInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: FurnitureProfileWareElement): FurnitureProfileWareElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: FurnitureProfileWareElement): FurnitureProfileWareNode;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: FurnitureProfileWareElement, element: FurnitureProfileWareElement, parameters?: any): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/instance/LayoutElementPerformer" {
    import { UniqueTypes } from 'cross/runtime/lang/collection/UniqueTypes';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { VisionModelElement } from 'sk/data/family/element/brep/vision/VisionModelElement';
    import { MaterialLayoutNode } from 'sk/data/family/model/instance/layout/MaterialLayoutNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { LayoutElement } from 'sk/data/family/element/instance/LayoutElement';
    import { LayoutNode } from 'sk/data/family/model/instance/LayoutNode';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { LayoutInfo } from "sk/rule/data/base/element/brep/LayoutPerformerUtil";
    import { NestElementCache } from "sk/rule/data/performer/NestElementPerformer";
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeLayoutElementPerformerCache extends NestElementCache {
        constructor();
        getInstanceElements(): UniqueTypes<any>;
        layoutElementsInfos: Array<{
            info: LayoutInfo;
            element: FamilyInstanceElement | VisionModelElement;
        }>;
    }
    export abstract class LayoutElementPerformer extends FamilyInstanceElementPerformer {
        constructor();
        createCache(context: SchemeElementPerformerContext): SchemeLayoutElementPerformerCache;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: LayoutElement): LayoutElement;
        computeShapeMatrix(context: SchemeElementPerformerContext, element: LayoutElement, index: number, node: LayoutNode): ResultEnum;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: LayoutElement): LayoutNode;
        buildElementStructureAsync(context: SchemeElementPerformerContext, layoutElement: LayoutElement, structure: StructureElement): Promise<ResultObject>;
        computeStructureBefore(context: SchemeElementPerformerContext, element: LayoutElement, node: LayoutNode): ResultEnum;
        computeProperty(context: SchemeElementPerformerContext, element: LayoutElement, index: number, node: LayoutNode): ResultEnum;
        private setNodePolygon;
        computeStructureChildrenAsync(context: SchemeElementPerformerContext, element: LayoutElement, node: LayoutNode): Promise<ElementPerformerResult>;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: LayoutElement, node: MaterialLayoutNode): Promise<ResultObject>;
        protected createOrSetNewElementByInfoAsync(context: SchemeElementPerformerContext, layoutElement: LayoutElement, layoutnode: LayoutNode, info: LayoutInfo, newElement?: any): Promise<ResultObject<FamilyInstanceElement | VisionModelElement>>;
        protected createOrSetDefaultElementByInfo(context: SchemeElementPerformerContext, layoutElement: LayoutElement, layoutnode: LayoutNode, info: LayoutInfo, newElement?: any): ResultObject<FamilyInstanceElement | VisionModelElement>;
        computeLayoutSizeData(element: LayoutElement, node: LayoutNode): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/LayoutTileElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LayoutTileElement } from 'sk/data/family/element/instance/LayoutTileElement';
    import { LayoutTileNode } from 'sk/data/family/model/instance/LayoutTileNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class LayoutTileElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: LayoutTileElement): LayoutTileElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: LayoutTileElement): LayoutTileNode;
        computeProperty(context: SchemeElementPerformerContext, element: LayoutTileElement, index: number, node: LayoutTileNode): ResultEnum;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: LayoutTileElement, node: LayoutTileNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/instance/LinearLineCurve3dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LinearLineCurve3dElement } from 'sk/data/family/element/instance/LinearLineCurve3dElement';
    import { LinearLineCurve3dNode } from 'sk/data/family/model/instance/LinearLineCurve3dNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class LinearLineCurve3dElementPerformer extends BrepElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LinearLineCurve3dElement): LinearLineCurve3dElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LinearLineCurve3dElement): LinearLineCurve3dNode;
        computeElementProperty(context: ElementPerformerContext, source: LinearLineCurve3dElement, target: LinearLineCurve3dElement): void;
        computeProperty(context: SchemeElementPerformerContext, element: LinearLineCurve3dElement, index: number, node: LinearLineCurve3dNode): ResultEnum;
        computeShape(context: ElementPerformerContext, element: LinearLineCurve3dElement, index: number, node: LinearLineCurve3dNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/LinearPathCurve3dElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LinearPathCurve3dElement } from 'sk/data/family/element/instance/LinearPathCurve3dElement';
    import { LinearPathCurve3dNode } from 'sk/data/family/model/instance/LinearPathCurve3dNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { BrepElementPerformer } from "sk/rule/data/performer/brep/BrepElementPerformer";
    export class LinearPathCurve3dElementPerformer extends BrepElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LinearPathCurve3dElement): LinearPathCurve3dElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LinearPathCurve3dElement): LinearPathCurve3dNode;
        computeElementProperty(context: ElementPerformerContext, source: LinearPathCurve3dElement, target: LinearPathCurve3dElement): void;
        computeProperty(context: SchemeElementPerformerContext, element: LinearPathCurve3dElement, index: number, node: LinearPathCurve3dNode): ResultEnum;
        computeShape(context: SchemeElementPerformerContext, element: LinearPathCurve3dElement, index: number, node: LinearPathCurve3dNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/MaterialLayoutElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { VisionModelElement } from 'sk/data/family/element/brep/vision/VisionModelElement';
    import { MaterialLayoutElement } from 'sk/data/family/element/instance/layout/MaterialLayoutElement';
    import { MaterialLayoutNode } from 'sk/data/family/model/instance/layout/MaterialLayoutNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { LayoutNode } from 'sk/data/family/model/instance/LayoutNode';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { LayoutInfo } from "sk/rule/data/base/element/brep/LayoutPerformerUtil";
    import { LayoutElementPerformer } from "sk/rule/data/scehme/performer/instance/LayoutElementPerformer";
    export class MaterialLayoutElementPerformer extends LayoutElementPerformer {
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: MaterialLayoutElement): MaterialLayoutNode;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: MaterialLayoutElement): MaterialLayoutElement;
        computeProperty(context: SchemeElementPerformerContext, element: MaterialLayoutElement, index: number, node: MaterialLayoutNode): ResultEnum;
        buildElementStructureAsync(context: SchemeElementPerformerContext, layoutElement: MaterialLayoutElement, structure: StructureElement): Promise<ResultObject>;
        computeStructureChildrenAsync(context: SchemeElementPerformerContext, element: MaterialLayoutElement, node: MaterialLayoutNode, parameters?: any): Promise<ElementPerformerResult>;
        computeStructureBeforeAsync(context: SchemeElementPerformerContext, element: MaterialLayoutElement, node: MaterialLayoutNode, parameters?: any): Promise<ResultObject<any>>;
        protected createOrSetDefaultTileElementByInfo(context: SchemeElementPerformerContext, layoutElement: MaterialLayoutElement, layoutNode: LayoutNode, info: LayoutInfo, newElement?: any): ResultObject<FamilyInstanceElement | VisionModelElement>;
    }
}
declare module "sk/rule/data/scehme/performer/instance/MaterialLayoutTileElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { MaterialLayoutTileElement } from 'sk/data/family/element/instance/layout/MaterialLayoutTileElement';
    import { MaterialLayoutTileNode } from 'sk/data/family/model/instance/layout/MaterialLayoutTileNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class MaterialLayoutTileElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: MaterialLayoutTileElement): MaterialLayoutTileElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: MaterialLayoutTileElement): MaterialLayoutTileNode;
        computeProperty(context: SchemeElementPerformerContext, element: MaterialLayoutTileElement, index: number, node: MaterialLayoutTileNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/pattern/SchemePatternElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AlgorithmItemElement } from 'sk/data/family/algorithm/element/instance/AlgorithmItemElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { PatternWareElement } from 'sk/data/family/element/instance/PatternWareElement';
    import { PatternContainerElement } from 'sk/data/family/element/pattern/PatternContainerElement';
    import { PatternElement } from 'sk/data/family/element/pattern/PatternElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { AlgorithmService } from "sk/rule/data/algorithm/AlgorithmService";
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemePatternElementPerformer extends ContentInstanceElementPerformer {
        protected _algorithmService: AlgorithmService;
        computeElementProperty(context: ElementPerformerContext, source: Element, target: Element): void;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: PatternElement): PatternContainerElement;
        buildElementAsync(context: SchemeElementPerformerContext, instanceElement: ContentInstanceElement, element: PatternElement | PatternWareElement, parameter?: any): Promise<ResultObject>;
        processAlgorithmAsync(context: SchemeElementPerformerContext, algorithmItemElement: AlgorithmItemElement, param: any): Promise<ResultObject>;
        buildElementDocumentAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement, patternDocument: PatternDocument, buildChild?: boolean): Promise<ResultObject>;
        buildElementStructureAsync(context: SchemeElementPerformerContext, element: ContentInstanceElement, structure: StructureElement): Promise<ResultObject>;
        buildElementStructureProperty(context: SchemeElementPerformerContext, instanceElement: ContentInstanceElement, patternElement: PatternElement): ResultEnum;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/pattern/SchemePatternLineElementPerformer" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { PatternLineElement } from 'sk/data/family/element/pattern/layout/line/PatternLineElement';
    import { PatternPointElement } from 'sk/data/family/element/pattern/layout/point/PatternPointElement';
    import { AlgorithmItemElement } from 'sk/data/family/algorithm/element/instance/AlgorithmItemElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemePatternElementPerformer } from "sk/rule/data/scehme/performer/instance/pattern/SchemePatternElementPerformer";
    export class SchemePatternLineElementPerformer extends SchemePatternElementPerformer {
        buildChildElementAsync(context: SchemeElementPerformerContext, instanceElement: ContentInstanceElement, patternElement: PatternLineElement): Promise<ResultObject>;
        buildChildElementByPointsAsync(context: SchemeElementPerformerContext, points: Vector3[], instanceElement: ContentInstanceElement, pointElement: PatternPointElement): Promise<ResultObject<Types<Element>>>;
        processAlgorithmAsync(context: SchemeElementPerformerContext, algorithm: AlgorithmItemElement, param: {
            begin: Vector3;
            end: Vector3;
        }): Promise<ResultObject<Vector3[]>>;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/pattern/SchemePatternPointElementPerformer" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemePatternElementPerformer } from "sk/rule/data/scehme/performer/instance/pattern/SchemePatternElementPerformer";
    export class SchemePatternPointElementPerformer extends SchemePatternElementPerformer {
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/PlaneComponentElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { PlaneComponentElement } from 'sk/data/family/element/component/PlaneComponentElement';
    import { PlaneElement } from 'sk/data/family/element/instance/PlaneElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class PlaneComponentElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: PlaneComponentElement): PlaneElement;
        computeProperty(context: SchemeElementPerformerContext, element: PlaneElement, index: number, node: PlaneNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeLightElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { LightComponentElement } from 'sk/data/family/element/component/LightComponentElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { LightElement } from 'sk/data/family/element/instance/LightElement';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeLightElementPerformer extends FamilyInstanceElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: LightElement): FamilyInstanceElement;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: LightElement): LightNode;
        computeStructureAsync(context: SchemeElementPerformerContext, element: LightElement, node: LightNode): Promise<ElementPerformerResult>;
        computeProperty(context: SchemeElementPerformerContext, element: LightElement, index: number, node: LightNode): ResultEnum;
        computeElementProperty(context: ElementPerformerContext, source: LightComponentElement, target: LightElement): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeAreaLightElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { AreaLightComponentElement } from 'sk/data/family/database/light/element/AreaLightComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { AreaLightElement } from 'sk/data/scheme/database/light/element/AreaLightElement';
    import { AreaLightNode } from 'sk/data/scheme/database/light/model/AreaLightNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeLightElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeLightElementPerformer";
    export class SchemeAreaLightElementPerformer extends SchemeLightElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: AreaLightElement): FamilyInstanceElement;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: AreaLightElement): AreaLightNode;
        computeStructureAsync(context: SchemeElementPerformerContext, element: AreaLightElement, node: AreaLightNode): Promise<ElementPerformerResult>;
        computeProperty(context: SchemeElementPerformerContext, element: AreaLightElement, index: number, node: AreaLightNode): ResultEnum;
        computeElementProperty(context: ElementPerformerContext, source: AreaLightComponentElement, target: AreaLightElement): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeContainerElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ContainerElement } from 'sk/data/family/element/instance/ContainerElement';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeContainerElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: ContainerElement): ContainerElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: ContainerElement): ContainerNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeHardwareElementPerformer" {
    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 { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { HardwareElement } from 'sk/data/family/element/instance/HardwareElement';
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeWareElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeWareElementPerformer";
    export class SchemeHardwareElementPerformer extends SchemeWareElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: HardwareElement): HardwareElement;
        testCreateElementAsync(context: ElementPerformerContext, element: ComponentInstanceElement): Promise<ResultObject>;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: HardwareElement): HardwareNode;
        findStructureElement(context: ElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeLinearComponentElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { LinearComponentElement } from 'sk/data/family/element/component/LinearComponentElement';
    import { LinearElement } from 'sk/data/family/element/instance/LinearElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeLinearComponentElementPerformer extends ContentInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: LinearComponentElement): LinearElement;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemePatternInstanceElementPerformer" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    import { PatternComponentInstanceElement } from 'sk/data/family/element/component/PatternComponentInstanceElement';
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { PatternDocument } from 'sk/data/family/pattern/PatternDocument';
    import { PatternDocumentService } from 'sk/data/family/pattern/PatternDocumentService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemePatternInstanceElementPerformer extends ContentInstanceElementPerformer {
        rootStructureCd: string;
        protected _patternDocumentService: PatternDocumentService;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: PatternInstanceElement): PatternInstanceNode;
        computeStructureBuildAsync(context: SchemeElementPerformerContext, element: PatternInstanceElement, node: BrepNode, parameters?: any): Promise<ResultObject>;
        buildElementAsync(context: SchemeElementPerformerContext, instanceElement: PatternInstanceElement, componentElement: PatternComponentInstanceElement | PatternInstanceElement, parameters?: any): Promise<ResultObject>;
        buildPropertyByPatternDocument(context: SchemeElementPerformerContext, element: PatternInstanceElement, componentInstanceElement: ComponentInstanceElement, familyDocument: PatternDocument): ResultEnum;
        appendPropertyAsync(context: SchemeElementPerformerContext, element: PatternInstanceElement, componentInstanceElement: ComponentInstanceElement, familyDocument: PatternDocument, newElements: Types<Element>): Promise<ResultEnum>;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemePipeElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PipeComponentElement } from 'sk/data/family/database/plumbing/element/PipeComponentElement';
    import { PipeNode } from 'sk/data/family/database/plumbing/model/PipeNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { PipeElement } from 'sk/data/scheme/database/plumbing/element/PipeElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { LinearElementPerformer } from "sk/rule/data/scehme/performer/instance/LinearElementPerformer";
    export class SchemePipeElementPerformer extends LinearElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PipeElement | PipeComponentElement): PipeElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: PipeElement): PipeNode;
        computeProperty(context: SchemeElementPerformerContext, element: PipeElement, index: number, node: PipeNode): ResultEnum;
        protected onComputeStructureAfterAsync(context: SchemeElementPerformerContext, element: PipeElement, node: PipeNode): Promise<void>;
        processPathCurveProperty(context: SchemeElementPerformerContext, node: PipeNode): void;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemePlugInterfaceElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { PlugInterfaceElement } from 'sk/data/family/element/instance/PlugInterfaceElement';
    import { PlugInterfaceNode } from 'sk/data/family/model/instance/PlugInterfaceNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemePlugInterfaceElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: PlugInterfaceElement): PlugInterfaceElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: PlugInterfaceElement): PlugInterfaceNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemePointLightElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { PointLightComponentElement } from 'sk/data/family/database/light/element/PointLightComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { PointLightElement } from 'sk/data/scheme/database/light/element/PointLightElement';
    import { PointLightNode } from 'sk/data/scheme/database/light/model/PointLightNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeLightElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeLightElementPerformer";
    export class SchemePointLightElementPerformer extends SchemeLightElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: PointLightElement): FamilyInstanceElement;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: PointLightElement): PointLightNode;
        computeStructureAsync(context: SchemeElementPerformerContext, element: PointLightElement, node: PointLightNode): Promise<ElementPerformerResult>;
        computeProperty(context: SchemeElementPerformerContext, element: PointLightElement, index: number, node: PointLightNode): ResultEnum;
        computeElementProperty(context: ElementPerformerContext, source: PointLightComponentElement, target: PointLightElement): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeSectionSurfaceElementPerformer" {
    import { SectionSurfaceElement } from 'sk/data/family/structure/section/element/SectionSurfaceElement';
    import { SectionSurfaceNode } from 'sk/data/family/structure/section/model/SectionSurfaceNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SectionSurfaceComponentElement } from 'sk/data/family/element/component/SectionSurfaceComponentElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeSectionSurfaceElementPerformer extends ContentInstanceElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: SectionSurfaceElement | SectionSurfaceComponentElement): SectionSurfaceElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: SectionSurfaceElement): SectionSurfaceNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeSocketInterfaceElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SocketInterfaceElement } from 'sk/data/family/element/instance/SocketInterfaceElement';
    import { SocketInterfaceNode } from 'sk/data/family/model/instance/SocketInterfaceNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/FamilyInstanceElementPerformer";
    export class SchemeSocketInterfaceElementPerformer extends FamilyInstanceElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SocketInterfaceElement): SocketInterfaceElement;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: SocketInterfaceElement): SocketInterfaceNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeSpatialContainerElementPerformer" {
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { SpatialContainerElement } from 'sk/data/family/element/instance/SpatialContainerElement';
    import { SpatialContainerNode } from 'sk/data/family/model/instance/SpatialContainerNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class SchemeSpatialContainerElementPerformer extends SchemeContentElementPerformer {
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SpatialContainerElement): SpatialContainerElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: SpatialContainerElement): SpatialContainerNode;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeSpotLightElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { SpotLightComponentElement } from 'sk/data/family/database/light/element/SpotLightComponentElement';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { StructureElement } from 'sk/data/family/element/base/StructureElement';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { SpotLightElement } from 'sk/data/scheme/database/light/element/SpotLightElement';
    import { SpotLightNode } from 'sk/data/scheme/database/light/model/SpotLightNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeLightElementPerformer } from "sk/rule/data/scehme/performer/instance/SchemeLightElementPerformer";
    export class SchemeSpotLightElementPerformer extends SchemeLightElementPerformer {
        constructor();
        createElement(context: ElementPerformerContext, containerElement: NestElement, element: SpotLightElement): FamilyInstanceElement;
        findStructureElement(context: SchemeElementPerformerContext, structure: StructureElement): Element;
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: SpotLightElement): SpotLightNode;
        computeStructureAsync(context: SchemeElementPerformerContext, element: SpotLightElement, node: SpotLightNode): Promise<ElementPerformerResult>;
        computeProperty(context: SchemeElementPerformerContext, element: SpotLightElement, index: number, node: SpotLightNode): ResultEnum;
        computeElementProperty(context: ElementPerformerContext, source: SpotLightComponentElement, target: SpotLightElement): void;
    }
}
declare module "sk/rule/data/scehme/performer/instance/SchemeSubstrateElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DecorateValueStructure } from 'sk/data/family/element/config/decorate/DecorateValueStructure';
    import { Element } from 'sk/data/family/element/base/Element';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { SubstrateComponentElement } from 'sk/data/family/element/component/SubstrateComponentElement';
    import { SubstrateElement } from 'sk/data/family/element/instance/SubstrateElement';
    import { SubstrateNode } from 'sk/data/family/model/instance/SubstrateNode';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { ContentInstanceElementPerformer } from "sk/rule/data/scehme/performer/instance/ContentInstanceElementPerformer";
    export class SchemeSubstrateElementPerformer extends ContentInstanceElementPerformer {
        protected _familyConfigService: FamilyConfigService;
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: SubstrateComponentElement): Element;
        createNode(context: ElementPerformerContext, containerElement: BrepElement, element: SubstrateElement): SubstrateNode;
        buildElementAsync(context: SchemeElementPerformerContext, element: SubstrateElement, componentElement: SubstrateComponentElement, parameter?: any): Promise<ResultObject>;
        setSubstrateNodeFromDecorateValueAsync(context: SchemeElementPerformerContext, node: SubstrateNode, decorateValue: DecorateValueStructure): Promise<void>;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: SubstrateElement, node: SubstrateNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/structure/SchemeSpatialStructElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { BlueprintNode } from 'foundation/data/common/model/base/BlueprintNode';
    import { DataNode, DataNodeMap } from 'foundation/data/common/model/base/DataNode';
    import { Element } from 'sk/data/family/element/base/Element';
    import { SpatialStructureElement } from 'sk/data/family/element/brep/SpatialStructureElement';
    import { BoundaryNode } from 'sk/data/family/model/assistant/BoundaryNode';
    import { ElementCache } from 'sk/data/family/performer/element/ElementCache';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeStructureElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeStructureElementPerformer";
    export class SpatialStructElementCache extends ElementCache {
        boundaryNode: BoundaryNode;
        clearRemoveMap(node: DataNode, removeMap?: DataNodeMap): void;
    }
    export class SchemeSpatialStructElementPerformer extends SchemeStructureElementPerformer {
        createCache(context: ElementPerformerContext): SpatialStructElementCache;
        computeStructureBefore(context: ElementPerformerContext, element: Element, node: DataNode): ResultEnum;
        computeProperty(context: ElementPerformerContext, element: SpatialStructureElement, index: number, node: BlueprintNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/technology/SchemeTechnologyCavityElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { TechnologyCavityComponentElement } from 'sk/data/family/database/technology/element/TechnologyCavityComponentElement';
    import { TechnologyCavityNode } from 'sk/data/family/database/technology/model/TechnologyCavityNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { TechnologyCavityElement } from 'sk/data/scheme/database/technology/element/TechnologyCavityElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeTechnologyElementPerformer } from "sk/rule/data/scehme/performer/technology/SchemeTechnologyElementPerformer";
    export class SchemeTechnologyCavityElementPerformer extends SchemeTechnologyElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: BrepElement, element: TechnologyCavityElement | TechnologyCavityComponentElement): TechnologyCavityElement;
        createNode(context: SchemeElementPerformerContext, containerElement: BrepElement, element: TechnologyCavityElement): TechnologyCavityNode;
        computeProperty(context: SchemeElementPerformerContext, element: TechnologyCavityElement, index: number, node: TechnologyCavityNode): ResultEnum;
    }
}
declare module "sk/rule/data/scehme/performer/technology/SchemeTechnologyGrooveElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { TechnologyGrooveComponentElement } from 'sk/data/family/database/technology/element/TechnologyGrooveComponentElement';
    import { TechnologyGrooveNode } from 'sk/data/family/database/technology/model/TechnologyGrooveNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyGrooveElement } from 'sk/data/scheme/database/technology/element/TechnologyGrooveElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeTechnologyElementPerformer } from "sk/rule/data/scehme/performer/technology/SchemeTechnologyElementPerformer";
    export class SchemeTechnologyGrooveElementPerformer extends SchemeTechnologyElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyGrooveElement | TechnologyGrooveComponentElement): TechnologyGrooveElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyGrooveElement): TechnologyGrooveNode;
        computePropertyAsync(context: SchemeElementPerformerContext, element: TechnologyGrooveElement, index: number, node: TechnologyGrooveNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/technology/SchemeTechnologyHoleElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { TechnologyHoleComponentElement } from 'sk/data/family/database/technology/element/TechnologyHoleComponentElement';
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyHoleElement } from 'sk/data/scheme/database/technology/element/TechnologyHoleElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeTechnologyElementPerformer } from "sk/rule/data/scehme/performer/technology/SchemeTechnologyElementPerformer";
    export class SchemeTechnologyHoleElementPerformer extends SchemeTechnologyElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyHoleElement | TechnologyHoleComponentElement): TechnologyHoleElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyHoleElement): TechnologyHoleNode;
        computePropertyAsync(context: SchemeElementPerformerContext, element: TechnologyHoleElement, index: number, node: TechnologyHoleNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/technology/SchemeTechnologyMillingElementPerformer" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { TechnologyMillingComponentElement } from 'sk/data/family/database/technology/element/TechnologyMillingComponentElement';
    import { TechnologyMillingNode } from 'sk/data/family/database/technology/model/TechnologyMillingNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyMillingElement } from 'sk/data/scheme/database/technology/element/TechnologyMillingElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeTechnologyElementPerformer } from "sk/rule/data/scehme/performer/technology/SchemeTechnologyElementPerformer";
    export class SchemeTechnologyMillingElementPerformer extends SchemeTechnologyElementPerformer {
        constructor();
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyMillingElement | TechnologyMillingComponentElement): TechnologyMillingElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyMillingElement): TechnologyMillingNode;
        computePropertyAsync(context: SchemeElementPerformerContext, element: TechnologyMillingElement, index: number, node: TechnologyMillingNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/technology/SchemeTechnologyMillingTrackElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { TechnologyMillingTrackComponentElement } from 'sk/data/family/database/technology/element/TechnologyMillingTrackComponentElement';
    import { TechnologyMillingTrackNode } from 'sk/data/family/database/technology/model/TechnologyMillingTrackNode';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { TechnologyMillingTrackElement } from 'sk/data/scheme/database/technology/element/TechnologyMillingTrackElement';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeTechnologyElementPerformer } from "sk/rule/data/scehme/performer/technology/SchemeTechnologyElementPerformer";
    export class SchemeTechnologyMillingTrackElementPerformer extends SchemeTechnologyElementPerformer {
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyMillingTrackElement | TechnologyMillingTrackComponentElement): TechnologyMillingTrackElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: TechnologyMillingTrackElement): TechnologyMillingTrackNode;
        computeProperty(context: SchemeElementPerformerContext, element: TechnologyMillingTrackElement, index: number, node: TechnologyMillingTrackNode): ResultEnum;
        buildElementAsync(context: SchemeElementPerformerContext, parentElement: TechnologyMillingTrackElement, element: BrepElement): Promise<ResultObject>;
        buildElementReleation(context: SchemeElementPerformerContext, element: TechnologyMillingTrackElement): void;
    }
}
declare module "sk/rule/data/scehme/performer/vision/SchemeVisionModelElementPerformer" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { VisionModelNode } from 'foundation/data/common/model/brep/vision/VisionModelNode';
    import { VisionModelElement } from 'sk/data/family/element/brep/vision/VisionModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { ElementPerformerResult } from 'sk/data/family/performer/element/ElementPerformerResult';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeContentElementPerformer } from "sk/rule/data/scehme/performer/brep/SchemeContentElementPerformer";
    export class SchemeVisionModelElementPerformer extends SchemeContentElementPerformer {
        protected _modelDocumentService: ModelDocumentService;
        protected _familyConfigService: FamilyConfigService;
        createElement(context: SchemeElementPerformerContext, containerElement: NestElement, element: VisionModelElement): VisionModelElement;
        createNode(context: SchemeElementPerformerContext, containerElement: NestElement, element: VisionModelElement): VisionModelNode;
        onPrepareAsync(context: SchemeElementPerformerContext, containerElement: BrepElement, element: VisionModelElement): Promise<ElementPerformerResult>;
        computeContentLengthX(element: VisionModelElement, node: VisionModelNode): number;
        computeContentLengthY(element: VisionModelElement, node: VisionModelNode): number;
        computeContentLengthZ(element: VisionModelElement, node: VisionModelNode): number;
        computeProperty(context: SchemeElementPerformerContext, element: VisionModelElement, index: number, node: VisionModelNode): ResultEnum;
        computeStructureAfterAsync(context: SchemeElementPerformerContext, element: VisionModelElement, node: VisionModelNode): Promise<ResultObject>;
    }
}
declare module "sk/rule/data/scehme/performer/technology/SchemeTechnologyVisionModelElementPerformer" {
    import { VisionModelNode } from 'foundation/data/common/model/brep/vision/VisionModelNode';
    import { VisionModelElement } from 'sk/data/family/element/brep/vision/VisionModelElement';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { SchemeVisionModelElementPerformer } from "sk/rule/data/scehme/performer/vision/SchemeVisionModelElementPerformer";
    export class SchemeTechnologyVisionModelElementPerformer extends SchemeVisionModelElementPerformer {
        createNode(context: ElementPerformerContext, containerElement: NestElement, element: VisionModelElement): VisionModelNode;
    }
}
declare module "sk/rule/data/scehme/util/OperateLinePerformerUtil" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    type PlankCrevice = {
        from: Vector3;
        to: Vector3;
        matrix: Matrix4;
        planks: {
            content: PlankNode;
            type: "left" | "right";
        }[];
        mergeList?: PlankCrevice[];
    };
    export class OperateLinePerformerUtil {
        static DEFAULT_CREVICE_LEFT_RELATION_CODE: string;
        static DEFAULT_CREVICE_RIGHT_RELATION_CODE: string;
        static createOperateLinesByPlanksContainer(containerNode: DataNode, tolerance?: number): void;
        static removeAllOperateLineElements(containerNode: DataNode): void;
        private static createOperateLineByPlankCrevices;
        protected static getSameLineCrevicesList(crevices: PlankCrevice[], tolerance: number): PlankCrevice[][];
        protected static getLappedMap(crevices: PlankCrevice[], tolerance: number): Map<PlankCrevice, PlankCrevice[]>;
        protected static getMergeLinesList(map: Map<PlankCrevice, PlankCrevice[]>): PlankCrevice[][];
        protected static mergeCrevices(crevices: PlankCrevice[]): PlankCrevice;
        private static mergeAllCrevices;
        private static isReverse;
        private static getPlankCrevicesByPlank;
    }
}
declare module "sk/rule/data/scehme/util/OperateLinePerformerUtil1" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    export type PlankCrevice = {
        from: Vector3;
        to: Vector3;
        planks: {
            content: PlankNode;
            type: "left" | "right";
        }[];
        mergeList?: PlankCrevice[];
    };
    export class OperateLinePerformerUtil1 {
        static DEFAULT_CREVICE_LEFT_RELATION_CODE: string;
        static DEFAULT_CREVICE_RIGHT_RELATION_CODE: string;
        static createOperateLinesByPlanksContainer(containerNode: DataNode, tolerance?: number): void;
        static calculateGapLinesByPlanksContainer(containerNode: DataNode, outline: Line2[], outPoints: Vector2[], tolerance?: number): PlankCrevice[];
        static removeAllOperateLineElements(containerNode: DataNode): void;
        private static createOperateLineByPlankCrevices;
        protected static getSameLineCrevicesList(crevices: PlankCrevice[], tolerance: number): PlankCrevice[][];
        static divideList(list: PlankCrevice[][]): void;
        static isSameLine(point1: Value2, point2: Value2, point3: Value2, point4: Value2, tolerance?: number): boolean;
        protected static getLappedMap(crevices: PlankCrevice[], tolerance: number): Map<PlankCrevice, PlankCrevice[]>;
        static isSegmentsOverlapped(point1: Value2, point2: Value2, point3: Value2, point4: Value2, tolerance?: number): boolean;
        protected static getMergeLinesList(map: Map<PlankCrevice, PlankCrevice[]>): PlankCrevice[][];
        protected static mergeCrevices(crevices: PlankCrevice[]): PlankCrevice;
        private static mergeAllCrevices;
        private static isReverse;
        private static getPlankCrevicesByPlank;
        private static dealWithOutline;
        protected static isNearlyCollinear(line1From: Vector2, line1To: Vector2, line2From: Vector2, line2To: Vector2, tolerance: number): boolean;
        private static checkPointBetweenLine;
    }
}
declare module "sk/rule/data/scehme/util/ReferenceLinePerformerUtil" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ReferenceAxisNode } from 'sk/data/family/model/assistant/reference/ReferenceAxisNode';
    export class ReferenceLinePerformerUtil {
        static removeAllReferenceLineElements(containerNode: DataNode): void;
        static createReferenceLine(containerNode: DataNode, begin: Vector3, end: Vector3): void;
        static createArrayReferenceLines(referenceLineNode: ReferenceAxisNode, count: number, gap: number): void;
    }
}
declare module "sk/rule/data/scehme/util/SchemeExplodedUtil" {
    import { SchemeDataDocument } from 'sk/data/scheme/model/SchemeDataDocument';
    export class SchemeExplodedUtil {
        static computeIdBydocument(document: SchemeDataDocument): void;
        private static computeOpenningsId;
        private static findBindValue;
        private static computeDynamicWareAndMoreId;
        private static computeLevelingCeilingId;
        private static computeLevelingFloorId;
        private static computeLevelingWallId;
        private static getWallIdentifier;
        private static computeWallSurfaceId;
        private static getRoomValidSurface;
        private static computeRoomAndAreaId;
        private static loopNode;
        private static buildStringByNumber;
        private static initIdentifier;
    }
}
declare module "sk/rule/data/scehme/util/SchemeStructureDocumentUtil" { }
declare module "sk/rule/data/validator/AssembleBeamValidatorUtilOld" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { AssembleDoorElement } from 'sk/data/scheme/database/pattern/element/AssembleDoorElement';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { AssembleLinkCodeEnum } from 'sk/data/scheme/database/pattern/element/AssembleLinkCodeEnum';
    import { AssembleWindowElement } from 'sk/data/scheme/database/pattern/element/AssembleWindowElement';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { AssembleBeamNode } from 'sk/data/scheme/database/pattern/node/AssembleBeamNode';
    export class AssembleBeamValidatorUtilOld {
        static rules: ({
            desc: string;
            target: typeof AssembleBeamElement;
            process: typeof AssembleBeamValidatorUtilOld.computeTechnologyValidForAssembleBeamLevelingWall;
            params?: undefined;
        } | {
            desc: string;
            target: typeof AssembleWindowElement;
            process: typeof AssembleBeamValidatorUtilOld.computeTechnologyValidForAssembleWindow2;
            params: {
                distance: number;
                inner_distance?: undefined;
                outer_distance?: undefined;
                height?: undefined;
            };
        } | {
            desc: string;
            target: typeof AssembleDoorElement;
            process: typeof AssembleBeamValidatorUtilOld.computeTechnologyValidForAssembleDoor;
            params: {
                distance: number;
                inner_distance?: undefined;
                outer_distance?: undefined;
                height?: undefined;
            };
        } | {
            desc: string;
            target: typeof AssembleFlatWallElement;
            process: typeof AssembleBeamValidatorUtilOld.computeTechnologyValidForAssembleFlatWall;
            params: {
                inner_distance: number;
                outer_distance: number;
                distance?: undefined;
                height?: undefined;
            };
        } | {
            desc: string;
            target: typeof LevelingFloorElement;
            process: typeof AssembleBeamValidatorUtilOld.computeTechnologyValidForLevelingFloor;
            params?: undefined;
        } | {
            desc: string;
            target: typeof AssembleWindowElement;
            process: typeof AssembleBeamValidatorUtilOld.computeTechnologyValidForAssembleWindow3;
            params?: undefined;
        } | {
            desc: string;
            target: typeof LevelingWallElement;
            process: typeof AssembleBeamValidatorUtilOld.computeTechnologyValidForLevelingWallNode;
            params: {
                height: number;
                distance?: undefined;
                inner_distance?: undefined;
                outer_distance?: undefined;
            };
        })[];
        static computeOptionTechnologyValidForAssembleBeamNodes(assembleBeamNodes: Array<AssembleBeamNode>): void;
        static computeOptionTechnologyValidForAssembleBeamNode(assembleBeamNode: AssembleBeamNode): void;
        private static getRulesByPatternInstanceNode;
        private static updateLinkElementOptionTechnologyValid;
        private static computeTechnologyValidForAssembleBeamLevelingWall;
        private static computeTechnologyValidForAssembleWindow2;
        private static computeTechnologyValidForAssembleDoor;
        private static computeTechnologyValidForAssembleFlatWall;
        private static computeTechnologyValidForAssembleWindow3;
        private static computeTechnologyValidForLevelingWallNode;
        private static computeTechnologyValidForAssembleBeam1;
        private static computeTechnologyValidForAssembleBeam2;
        private static computeTechnologyValidForAssembleBeam3;
        private static computeTechnologyValidForLevelingFloor;
        private static processRule;
        protected static computeAssembleOpeningToLevelingWallDistance(opening: PatternInstanceElement, linkCode: AssembleLinkCodeEnum, params?: any): boolean;
    }
}
declare module "sk/rule/data/validator/AssembleFloorValidatorUtil" {
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { LevelingFloorNode } from 'sk/data/scheme/database/pattern/node/LevelingFloorNode';
    export class AssembleFloorValidatorUtil {
        private static patternInstanceElementValidMap;
        static rules: ({
            desc: string;
            target: typeof LevelingFloorElement;
            process: typeof AssembleFloorValidatorUtil.computeTechnologyValidForLevelingFloorNodeParameter;
            params: {
                height: number;
                lengthX?: undefined;
                lengthY?: undefined;
                width?: undefined;
                name?: undefined;
            };
        } | {
            desc: string;
            target: typeof LevelingFloorElement;
            process: typeof AssembleFloorValidatorUtil.computeTechnologyValidForLevelingFloorNodeParameter;
            params: {
                lengthX: number;
                height?: undefined;
                lengthY?: undefined;
                width?: undefined;
                name?: undefined;
            };
        } | {
            desc: string;
            target: typeof LevelingFloorElement;
            process: typeof AssembleFloorValidatorUtil.computeTechnologyValidForLevelingFloorNodeParameter;
            params: {
                lengthY: number;
                height?: undefined;
                lengthX?: undefined;
                width?: undefined;
                name?: undefined;
            };
        } | {
            desc: string;
            target: typeof LevelingFloorElement;
            process: typeof AssembleFloorValidatorUtil.computeTechnologyValidForPlankNodeParameter;
            params: {
                width: number;
                height?: undefined;
                lengthX?: undefined;
                lengthY?: undefined;
                name?: undefined;
            };
        } | {
            desc: string;
            target: typeof LevelingFloorElement;
            process: typeof AssembleFloorValidatorUtil.computeTechnologyValidHasContainer;
            params: {
                name: string;
                height?: undefined;
                lengthX?: undefined;
                lengthY?: undefined;
                width?: undefined;
            };
        })[];
        static computeOptionTechnologyValidForAssembleFloorNode(LevelingFloorNode: LevelingFloorNode): void;
        private static computeTechnologyValidForLevelingFloorNodeParameter;
        private static computeTechnologyValidHasContainer;
        private static computeTechnologyValidContainerHasChild;
        private static computeTechnologyValidForPlankNodeParameter;
        private static processRule;
        private static getRulesByPatternInstanceNode;
    }
}
declare module "sk/rule/data/validator/AssembleRoomValidatorUtil" {
    import { PatternInstanceElement } from 'sk/data/family/element/instance/PatternInstanceElement';
    import { AssembleBeamElement } from 'sk/data/scheme/database/pattern/element/AssembleBeamElement';
    import { AssembleDoorElement } from 'sk/data/scheme/database/pattern/element/AssembleDoorElement';
    import { AssembleFlatWallElement } from 'sk/data/scheme/database/pattern/element/AssembleFlatWallElement';
    import { AssembleLinkCodeEnum } from 'sk/data/scheme/database/pattern/element/AssembleLinkCodeEnum';
    import { AssembleWindowElement } from 'sk/data/scheme/database/pattern/element/AssembleWindowElement';
    import { LevelingFloorElement } from 'sk/data/scheme/database/pattern/element/LevelingFloorElement';
    import { LevelingWallElement } from 'sk/data/scheme/database/pattern/element/LevelingWallElement';
    import { AssembleRoomNode } from 'sk/data/scheme/database/pattern/node/AssembleRoomNode';
    export class AssembleRoomValidatorUtil {
        static rules: ({
            desc: string;
            target: typeof AssembleWindowElement;
            process: typeof AssembleRoomValidatorUtil.computeTechnologyValidForAssembleWindow1;
            params?: undefined;
        } | {
            desc: string;
            target: typeof AssembleWindowElement;
            process: typeof AssembleRoomValidatorUtil.computeTechnologyValidForAssembleWindow2;
            params: {
                distance: number;
                inner_distance?: undefined;
                outer_distance?: undefined;
                height?: undefined;
            };
        } | {
            desc: string;
            target: typeof AssembleDoorElement;
            process: typeof AssembleRoomValidatorUtil.computeTechnologyValidForAssembleDoor;
            params: {
                distance: number;
                inner_distance?: undefined;
                outer_distance?: undefined;
                height?: undefined;
            };
        } | {
            desc: string;
            target: typeof AssembleFlatWallElement;
            process: typeof AssembleRoomValidatorUtil.computeTechnologyValidForAssembleFlatWall;
            params: {
                inner_distance: number;
                outer_distance: number;
                distance?: undefined;
                height?: undefined;
            };
        } | {
            desc: string;
            target: typeof LevelingFloorElement;
            process: typeof AssembleRoomValidatorUtil.computeTechnologyValidForLevelingFloor;
            params?: undefined;
        } | {
            desc: string;
            target: typeof LevelingWallElement;
            process: typeof AssembleRoomValidatorUtil.computeTechnologyValidForLevelingWallNode;
            params: {
                height: number;
                distance?: undefined;
                inner_distance?: undefined;
                outer_distance?: undefined;
            };
        } | {
            desc: string;
            target: typeof AssembleBeamElement;
            process: typeof AssembleRoomValidatorUtil.computeTechnologyValidForAssembleBeam1;
            params?: undefined;
        })[];
        private static computeTechnologyValidForAssembleWindow1;
        private static computeTechnologyValidForAssembleWindow2;
        private static computeTechnologyValidForAssembleDoor;
        private static computeTechnologyValidForAssembleFlatWall;
        private static computeTechnologyValidForAssembleWindow3;
        private static computeTechnologyValidForLevelingWallNode;
        private static computeTechnologyValidForAssembleBeam1;
        private static computeTechnologyValidForAssembleBeam2;
        private static computeTechnologyValidForAssembleBeam3;
        private static computeTechnologyValidForLevelingFloor;
        static computeOptionTechnologyValidForAssembleRoomNode(assembleRoomNode: AssembleRoomNode): void;
        static computeOptionTechnologyValidForAssembleRoomNodes(assembleRoomNodes: Array<AssembleRoomNode>): void;
        private static updateLinkElementOptionTechnologyValid;
        private static processRule;
        private static getRulesByPatternInstanceNode;
        protected static computeAssembleOpeningToLevelingWallDistance(opening: PatternInstanceElement, linkCode: AssembleLinkCodeEnum, params?: any): boolean;
    }
}
declare module "sk/rule/data/validator/drawing/content/DrawingDocumentContentValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { DimensionNode } from 'sk/data/family/model/assistant/dimension/DimensionNode';
    import { LeaderNode } from 'sk/data/family/model/assistant/leader/LeaderNode';
    import { Text2dNode } from 'sk/data/family/model/assistant/text/Text2dNode';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export type DataValidateStructure = {
        curves: Curve2dNode[];
        texts: Text2dNode[];
        dimensions: DimensionNode[];
        leaders: LeaderNode[];
    };
    export class DrawingDocumentContentValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
        protected handleDocumentContentValidator(context: ValidateContext, blueprint: DataNode): void;
    }
}
declare module "sk/rule/data/validator/drawing/content/DrawingDocumentContentUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    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 { DimensionNode } from 'sk/data/family/model/assistant/dimension/DimensionNode';
    import { LeaderNode } from 'sk/data/family/model/assistant/leader/LeaderNode';
    import { Text2dNode } from 'sk/data/family/model/assistant/text/Text2dNode';
    import { DataValidateStructure } from "sk/rule/data/validator/drawing/content/DrawingDocumentContentValidator";
    export class CollisionInfo {
        polygon: Vector2[];
        message: string;
    }
    export class DrawingDocumentContentUtil {
        static repeatCurvesValidator(context: ValidateContext, curves: Curve2dNode[]): void;
        static repeatTextValidator(context: ValidateContext, texts: Text2dNode[]): void;
        static repeatDimemsionValidator(context: ValidateContext, dimensions: DimensionNode[]): void;
        static repeatLeadValidator(context: ValidateContext, leaders: LeaderNode[]): void;
        static dimensionCollisionValidator(context: ValidateContext, dims: DimensionNode[], leaders: LeaderNode[], texts: Text2dNode[]): void;
        private static getTextsBoxFromNodes;
        private static contentRepeatValidator;
        private static createValidatorMessage;
        private static textCompare;
        private static leaderCompare;
        private static dimensionCompare;
        private static curvesCompare;
        static spliteDataByType(blueprint: DataNode, dvs: DataValidateStructure): void;
        static handleNodesByType(node: BrepNode, type: any, collections: BrepNode[]): void;
    }
}
declare module "sk/rule/data/validator/drawing/DrawingTreeValidateFactory" {
    import { ValidateFactory } from 'foundation/core/module/validate/ValidateFactory';
    export class DrawingTreeValidateFactory extends ValidateFactory {
        constructor();
    }
}
declare module "sk/rule/data/validator/drawing/DrawingValidateFactory" {
    import { ValidateFactory } from 'foundation/core/module/validate/ValidateFactory';
    export class DrawingValidateFactory extends ValidateFactory {
        constructor();
    }
}
declare module "sk/rule/data/validator/drawing/structure/DrawingDocumentStructureUtil" {
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class DrawingDocumentStructureUtil {
        static excuteDocumentLinesNodeValidate(context: ValidateContext, node: DataNode): void;
    }
}
declare module "sk/rule/data/validator/drawing/structure/DrawingDocumentStructureValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { BlueprintNode } from 'foundation/data/common/model/base/BlueprintNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class DrawingDocumentStructureValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
        protected handleDataPropertyValidator(context: ValidateContext, blueprint: DataNode): void;
        protected handleCompleteStructureValidator(context: ValidateContext, blueprint: BlueprintNode): boolean;
    }
}
declare module "sk/rule/data/validator/drawing/tree/DrawingTreeStructureValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataValidator } from 'foundation/data/common/validator/DataValidator';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class DrawingTreeStructureValidator extends DataValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleBeamValidator" {
    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 AssembleBeamValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleDoorValidator" {
    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 AssembleDoorValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleFlatWallValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class HardwareType {
        static verticalKeel: string;
        static heavenEarthKeel: string;
        static stullKeel: string;
        static pierceKeel: string;
        static strengthKeel: string;
        static hardwareHorizontalKeel: string;
        static openingComponent: string;
        static enClosedComponent: string;
    }
    export class AssembleFlatWallValidator extends DataDocumentValidator {
        private referenceElement;
        processAsync(context: ValidateContext, document: SchemeDocument): Promise<ResultObject<ResultEnum>>;
        private technolongyCheck;
        private supportOpeningProcess;
        private baseProcess;
        private plankEdgePos;
        private getPlankPointUnique;
        private isStandard;
        private isEdgePerpendicular;
        private layerProcess;
        private hardWareValidTest;
        private getHardwareComponents;
        private heavenKeelLengthTest;
        private keelConflictTest;
        private hardwareHorizontalKeelConflictTest;
        private componentConflictTest;
        private hardWareHoleConflictTest;
        private hardWareBeamConflictTest;
        private objArrayConflictTest;
        protected findChildrenContainerByName(node: DataNode, name: string): ContainerNode;
        private nailatthegrassrootsleve;
        private resinBoitFim;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleLappedCeilingValidator" {
    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 AssembleLevelingLappedCeilingValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleLevelingCeilingPreCalculateValidator" {
    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 AssembleLevelingCeilingPreCalculateValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/ValidatorUtil" {
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    export class ValidatorUtil {
        static addNodeMessage(context: ValidateContext, node: BrepNode, text: string): void;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/LevelingCeilingValidatorUtil" {
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataNode, DataNodeCollection } from 'foundation/data/common/model/base/DataNode';
    export class LevelingCeilingValidatorUtil {
        static allowExistValidate(node: DataNode, structNodes: StructureValidateNode[]): StructureValidateNode;
        static structureExistValidate(structNode: StructureValidateNode, nodes: DataNodeCollection): boolean;
        static compareValidate(node: DataNode, structNode: StructureValidateNode): boolean;
        static sizeValidate(context: ValidateContext, node: DataNode, structNode: StructureValidateNode): boolean;
        static structureValidate(context: ValidateContext, node: DataNode, structNode: StructureValidateNode): boolean;
    }
    export class VNExistEnum {
        static Must: string;
        static Maybe: string;
    }
    export class StructureValidateNode {
        childs: StructureValidateNode[];
        clazz: any;
        name: string;
        showName: string;
        existType: VNExistEnum;
        minCount: number;
        maxCount: number;
        minSizeX: number;
        minSizeY: number;
        minSizeZ: number;
        maxSizeX: number;
        maxSizeY: number;
        maxSizeZ: number;
        validFunctions: Function[];
        constructor(clazz?: any, name?: string, showName?: string, existType?: VNExistEnum, minCount?: number, maxCount?: number);
        protected static _validateNode: StructureValidateNode;
        static getAny(): StructureValidateNode;
        setSizeValid(minSizeX?: number, maxSizeX?: number, minSizeY?: number, maxSizeY?: number, minSizeZ?: number, maxSizeZ?: number): void;
        setAllowAnyChild(): void;
        isAny(): boolean;
    }
    export class NodeValidateItemBase {
        description: string;
        processFunctions: Function;
        process(): boolean;
    }
    export class NodeSizeValidate extends NodeValidateItemBase {
        minSizeX: number;
        minSizeY: number;
        minSizeZ: number;
        maxSizeX: number;
        maxSizeY: number;
        maxSizeZ: number;
    }
    export class NodeExistValidate extends NodeValidateItemBase {
        existType: VNExistEnum;
        minCount: number;
        maxCount: number;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleLevelingCeilingProxValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { AssembleLevelingCeilingNode } from 'sk/data/scheme/database/pattern/node/AssembleLevelingCeilingNode';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    import { StructureValidateNode } from "sk/rule/data/validator/scheme/assemble/LevelingCeilingValidatorUtil";
    export class AssembleLevelingCeilingProxValidator extends DataDocumentValidator {
        static structValidateNode: StructureValidateNode;
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
        static createValidData(parent?: StructureValidateNode): StructureValidateNode;
        processLevelingCeilingProx(context: ValidateContext, ceiling: AssembleLevelingCeilingNode): boolean;
        static basePlankOutline(context: ValidateContext, ceiling: AssembleLevelingCeilingNode): boolean;
        static surfacePlankOutline(context: ValidateContext, ceiling: AssembleLevelingCeilingNode): boolean;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleLevelingCeilingValidator" {
    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 AssembleLevelingCeilingValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleLevelingFloorValidator" {
    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 AssembleLevelingFloorValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleLevelingWallValidator" {
    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 AssembleLevelingWallValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssemblePelmetValidator" {
    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 AssembleLevelingPelmetValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/AssembleRoomValidator" {
    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 AssembleRoomValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/assemble/BathroomValidator" {
    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 BathroomValidator extends DataDocumentValidator {
        static vlidateContext: any;
        static schemeDocument: any;
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
        processNodeAsync(node: any): Promise<void>;
    }
}
declare module "sk/rule/data/validator/scheme/base/CheckNode" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    export class CheckNode {
        name: string;
        element: ContentElement;
        node: ContentNode;
        validateCallback: Function;
        sucessCallback: Function;
        failureCallBack: Function;
        childs: Array<CheckNode>;
        parameters: Array<any>;
        constructor(name: string, validateCallback: Function, parameters?: [], sucessCallback?: Function, failureCallBack?: Function);
        push(checknode: CheckNode): void;
        process(node: ContentNode): ResultObject;
    }
}
declare module "sk/rule/data/validator/scheme/base/ValidateFunctionDeclare" {
    export class ValidateFunctionInfo {
        name: string;
        funtion: Function;
    }
    export function ValidateFunctionDeclare(name: string): (target: any, name: string) => void;
}
declare module "sk/rule/data/validator/scheme/base/ValidateFunctionService" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Service } from 'cross/runtime/module/Service';
    import { ValidateFunctionInfo } from "sk/rule/data/validator/scheme/base/ValidateFunctionDeclare";
    export class ValidateFunctionService extends Service {
        declares: TypeMap<string, ValidateFunctionInfo>;
        constructor();
        register(info: ValidateFunctionInfo): void;
        get(name: string): Function;
    }
}
declare module "sk/rule/data/validator/scheme/base/CheckProcessUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { CheckNode } from "sk/rule/data/validator/scheme/base/CheckNode";
    interface CheckInterface {
        name: string;
        validate: string;
        success: string;
        failure: string;
        childs: [];
        parameters: [];
    }
    export class CheckProcessUtil {
        static createCheckNode(data: CheckInterface): CheckNode;
        static processCheck(checkNode: CheckNode, node: ContentNode): ResultObject;
    }
}
declare module "sk/rule/data/validator/scheme/floorplan/BeamValidatorUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { BeamNode } from 'sk/data/scheme/database/floorplan/model/BeamNode';
    import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
    export class BeamValidatorUtil {
        static beamNodeValidTest(context: ValidateContext, node: BeamNode): boolean;
        protected static findBeamRooms(node: BeamNode): RoomNode[];
        static beamZValidTest(context: ValidateContext, node: BeamNode): boolean;
        protected static beamEndsEdgeValidTest(context: ValidateContext, node: BeamNode): boolean;
        protected static filterLines(beamLine: Line2, lines: Line2[]): Line2[];
        protected static isBeamWall(beamPoints: Vector2[], wallLines: Line2[], sideLine: Line2): boolean;
        protected static beamSideEdgeValidTest(context: ValidateContext, node: BeamNode): boolean;
        private static checkNearLine;
        static angleOrthogonalValidTest(context: ValidateContext, node: BeamNode): boolean;
    }
}
declare module "sk/rule/data/validator/scheme/floorplan/ColumnValidatorUtil" {
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { ColumnNode } from 'sk/data/scheme/database/floorplan/model/ColumnNode';
    export class ColumnValidatorUtil {
        static columnNodeValidTest(context: ValidateContext, node: ColumnNode): boolean;
        static beamColumnCloseValidTest(context: ValidateContext, node: ColumnNode, range: number[]): boolean;
        private static buildLines;
        protected static computeMinDistance(beamLines: Line2[], columnLines: Line2[]): number;
        protected static columnSideEdgeValidTest(node: ColumnNode, minDistance?: number): boolean;
        private static finSelfTest;
        private static columnWallEndsValidTest;
        static columnNotAloneTest(context: ValidateContext, node: ColumnNode): any;
        static columnNotIntersectionWallTest(context: ValidateContext, node: ColumnNode): boolean;
        static columnHeightTest(context: ValidateContext, node: ColumnNode): boolean;
    }
}
declare module "sk/rule/data/validator/scheme/floorplan/FloorplanValidatorUtil" {
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { WallJoinnerNode } from 'sk/data/scheme/database/floorplan/model/WallJoinnerNode';
    import { WallNode } from 'sk/data/scheme/database/floorplan/model/WallNode';
    import { FlatWallNode } from 'sk/data/scheme/database/pattern/node/FlatWallNode';
    export class FloorplanValidatorUtil {
        static flatWallNodeValidTest(context: ValidateContext, node: FlatWallNode): boolean;
        static wallValidTest(context: ValidateContext, wall: WallNode): boolean;
        protected static wallHeightValidTest(node: WallNode): boolean;
        static wallJoinnerValidTest(context: ValidateContext, node: WallJoinnerNode): boolean;
        static wallLineValidTest(wall: WallNode, validValue: number): boolean;
    }
}
declare module "sk/rule/data/validator/scheme/floorplan/OpeningValidatorUtil" {
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { DoorNode } from 'sk/data/scheme/database/floorplan/model/DoorNode';
    export class OpeningValidatorUtil {
        static openingValidTest(context: ValidateContext, node: OpeningNode): boolean;
        static doorNodeValidTest(context: ValidateContext, node: DoorNode): boolean;
        static windowNodeValidTest(context: ValidateContext, windowNode: OpeningNode): boolean;
        static openingRelationValidTest(context: ValidateContext, node: OpeningNode): boolean;
    }
}
declare module "sk/rule/data/validator/scheme/floorplan/FloorplanValidator" {
    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 FloorplanValidator extends DataDocumentValidator {
        private context;
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
        private processFloorplan;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleValidateDataSet" {
    export class AssembleValidateDataSet {
        static data: {
            name: string;
            validate: string;
            target: string[];
            parameters: (string | number)[];
            childs: {
                name: string;
                validate: string;
                parameters: (string | number)[];
                childs: any[];
            }[];
        }[];
        static levelingData: {
            name: string;
            validate: string;
            target: string[];
            parameters: (string | number)[];
            childs: any[];
        }[];
        static levelingBeamData: {
            name: string;
            validate: string;
            target: string[];
            parameters: (string | number)[];
            childs: any[];
        }[];
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleBeamValidator" {
    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 AssembleBeamValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/ContentValidatorUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class ContentValidatorUtil {
        static isOverThreshhold(node: ContentNode, parameters: Array<any>): ResultObject;
        static isLessThreshhold(node: ContentNode, parameters: Array<any>): ResultObject;
        static isHasContainer(node: ContentNode, parameters: Array<any>): ResultObject;
        static isHasDecorateContainer(node: ContentNode): ResultObject;
        static isContainerHasChild(node: ContentNode, parameters: Array<any>): ResultObject;
        static isContanerHasSlimPlank(node: ContentNode, parameters: Array<any>): ResultObject;
        static isContainerPlankLessThresh(node: ContentNode, parameters: Array<any>): ResultObject;
        static isPlankDeformaity(node: ContentNode, parameters: Array<any>): ResultObject;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleBeamValidatorUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class AssembleBeamValidatorUtil {
        static hasContainerBeam(node: ContentNode, parameters: Array<any>): ResultObject;
        static isContainerPlankLessThreshBeam(node: ContentNode, parameters: Array<any>): ResultObject;
        private static getContainerChildByNameBeam;
        private static filterAssembleLevelingWallNode;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleDoorValidator" {
    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 AssembleDoorValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleFlatWallValidator" {
    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 AssembleFlatWallValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
        private flatwallProcess;
        private getFlatWallPlane;
        private findExpansionElement;
        private flatWallTStructTest;
        private samePointWallInvalidTtest;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleFloorValidatorSetUtil" {
    export class AssembleFloorValidatorSetUtil {
        private static isFloorPlankLessThresh;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleLappedCeilingValidateDataSet" {
    export class AssembleLappedCeilingValidateDataSet {
        static data: {
            name: string;
            validate: string;
            target: string[];
            parameters: (string | number)[];
            childs: any[];
        }[];
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleLappedCeilingValidator" {
    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 AssembleLappedCeilingValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleLevelingCeilingValidator" {
    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 AssembleLevelingCeilingValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleLevelingFloorValidateDataSet" {
    export class AssembleLevelingFloorValidateDataSet {
        static data: {
            name: string;
            validate: string;
            target: string[];
            parameters: (string | number)[];
            childs: any[];
        }[];
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleLevelingFloorValidator" {
    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 AssembleLevelingFloorValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleLevelingLappedCeilingUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    export class AssembleLevelingLappedCeilingUtil {
        static isInRange(node: ContentNode, value: number, min: number, max: number): ResultObject;
        static checkNodeChildIsInRange(node: ContentNode, min: number, max: number, axis: string, typeName?: string): ResultObject;
        static isInRange2(node: ContentNode, value: Value2, min: Value2, max: Value2): ResultObject;
        static checkLength(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkPlaneViceKeelLength(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkPlankSize(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkMGRGHeight(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkEdgeWidth(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkOppositeEdgeTotalWidth(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkViceKeelOnHangingPlank(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkViceKeelOnClipKeel(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkClipKeelInterval(node: ContentNode, paramters: Array<any>): ResultObject;
        static checkViceKellModule(node: ContentNode, paramters: Array<any>): ResultObject;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleLevelingWallValidator" {
    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 AssembleLevelingWallValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssemblePelmetValidator" {
    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 AssembleLevelingPelmetValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/AssembleRoomValidator" {
    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 AssembleRoomValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/ChestValidateUtil" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { ChestNode } from 'sk/data/scheme/database/furniture/model/ChestNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class ChestValidateUtil {
        protected static _schemeConfigService: SchemeConfigService;
        protected static _familyDocumentService: FamilyDocumentService;
        static isSymbolValidAsync(context: ValidateContext, chest: ChestNode): Promise<ResultObject<ResultEnum>>;
        static isStructureValidAsync(context: ValidateContext, chest: ChestNode): Promise<ResultObject<boolean>>;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/PlankValidateUtil" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class PlankValidateUtil {
        protected static _schemeConfigService: SchemeConfigService;
        static isSymbolValid(context: ValidateContext, chest: PlankNode): boolean;
        static isChildNodeValid(context: ValidateContext, plank: PlankNode): boolean;
        static isFamilyInfoValidAsync(context: ValidateContext, plank: PlankNode): Promise<ResultObject<boolean>>;
        static isDecoratorValid(context: ValidateContext, plank: PlankNode): ResultObject<boolean>;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/ChestValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataDocumentValidator } from 'foundation/data/common/validator/DataDocumentValidator';
    import { ChestNode } from 'sk/data/scheme/database/furniture/model/ChestNode';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
    export class ChestValidator extends DataDocumentValidator {
        processAsync(context: ValidateContext, content: SchemeDocument): Promise<ResultObject<ResultEnum>>;
        validateChestAsync(context: ValidateContext, chest: ChestNode): Promise<ResultObject<ResultEnum>>;
        validatePlankAsync(context: ValidateContext, plank: PlankNode): Promise<ResultObject<ResultObject>>;
        findChest(node: DataNode, list?: ChestNode[]): Array<ChestNode>;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/editor/floor/LevelingFloorValidatorUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    import { LevelingFloorNode } from 'sk/data/scheme/database/pattern/node/LevelingFloorNode';
    export class LevelingFloorValidatorUtil {
        static validate(context: ValidateContext, floor: LevelingFloorNode): void;
        static planksCollisionCheck(context: ValidateContext, floor: LevelingFloorNode): void;
        static supportsCollisionCheck(context: ValidateContext, floor: LevelingFloorNode): void;
        static collisionPlankCheck(plank1: PlankNode, plank2: PlankNode): boolean;
        static collision(polygon1: Array<Vector2>, polygon2: Array<Vector2>, border?: boolean): boolean;
        static collisionBoxCheck(content1: ContentNode, content2: ContentNode): boolean;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/FurniturePlankCollisionValidator" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { ValidateContext } from 'foundation/core/module/validate/ValidateContext';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { DataValidator } from 'foundation/data/common/validator/DataValidator';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    export class FurniturePlankCollisionValidator extends DataValidator {
        processAsync(context: ValidateContext, content: FamilyInstanceElement): Promise<ResultObject<ResultEnum>>;
        static computeNodesIntersection(node1: GeometricNode, node2: GeometricNode): BoxSolid;
        static isOptionCollisionAsync(context: SchemeElementPerformerContext, plank: PlaneNode): Promise<ResultObject<boolean>>;
    }
}
declare module "sk/rule/data/validator/scheme/scheme/PlaneNodeValidator" {
    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 PlaneNodeValidator extends DataDocumentValidator {
        process(context: ValidateContext, document: SchemeDocument): ResultEnum;
        private planeValidTest;
        private planePropTest;
        private edgeCheck;
        private planeSurfaceTest;
        private surfaceCheck;
        private planeOriginPointsTest;
        private planeOriginalShapeTest;
        private planeTrueShapeTest;
        private addErrorInfo;
    }
}
declare module "sk/rule/data/workflow/plain/DeclareElementStructurePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    export class DeclareElementStructurePlain extends WorkflowPlainAsyncProcess {
        protected _calculatorService: CalculatorService;
        protected _familyConfigService: FamilyConfigService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/DesignTechniqueCollisionPlain" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { NodePerformerContext } from 'sk/data/family/performer/node/NodePerformerContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleProcessDocumentService } from 'sk/data/family/rule/RuleProcessDocumentService';
    import { RuleService } from 'sk/data/family/rule/RuleService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigRuleInfo } from 'sk/data/scheme/config/SchemeConfigRuleInfo';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    type FilterMaps = {
        familyTypeFilterMap: Dictionary<ContentNode[]>;
        familyCategoryFilterMap: Dictionary<ContentNode[]>;
        familyFeatureFilterMap: Dictionary<ContentNode[]>;
        elementTypeFilterMap: Dictionary<ContentNode[]>;
    };
    export class DesignTechniqueCollisionPlain extends WorkflowPlainAsyncProcess {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        protected _ruleProcessDocumentService: RuleProcessDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        protected _schemeConfigService: SchemeConfigService;
        protected _ruleService: RuleService;
        protected static RULE_CODES: string[];
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
        removeDirtyTechnologyNodes(node: DataNode): void;
        initFilterMapAsync(context: SchemeElementPerformerContext, node: DataNode, maps: FilterMaps): Promise<void>;
        processRuleAsync(context: SchemeElementPerformerContext, nodePerformerContext: NodePerformerContext, ruleInfo: SchemeConfigRuleInfo, element: NestElement, node: DataNode, maps: FilterMaps, dirtyAttack: boolean): Promise<ResultObject>;
        computeShapeByDefenses(context: SchemeElementPerformerContext, nodePerformerContext: NodePerformerContext, defenses: ContentNode[]): void;
        computeShapeByAttacks(context: SchemeElementPerformerContext, nodePerformerContext: NodePerformerContext, attacks: TechnologyNode[]): void;
        process(): WorkflowPlainResult;
        setRuleInputOutputByDirtyNodesAsync(context: SchemeElementPerformerContext, ruleInfo: SchemeConfigRuleInfo, element: NestElement, node: DataNode, maps: FilterMaps, dirtyAttack: boolean): Promise<ResultObject>;
        computeDataNode(performerContext: NodePerformerContext, node: DataNode): void;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyDocumentValidatePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    export class FamilyDocumentValidatePlain {
        protected _calculatorService: CalculatorService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyDocumentValidateRulePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class FamilyDocumentValidateRulePlain {
        protected _calculatorService: CalculatorService;
        protected _familyConfigService: FamilyConfigService;
        protected _schemeConfigService: SchemeConfigService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyDocumentVisionPlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    export class FamilyDocumentVisionPlain {
        protected _schemeDocumentService: SchemeDocumentService;
        protected _familyConfigService: FamilyConfigService;
        protected _schemeConfigService: SchemeConfigService;
        protected _calculatorService: CalculatorService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementBuildPlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    export class FamilyElementBuildPlain extends WorkflowPlainAsyncProcess {
        protected _calculatorService: CalculatorService;
        protected _familyConfigService: FamilyConfigService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
        private buildElementAsync;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementConditionPlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementConditionPlain extends WorkflowPlainProcess implements IElementTraversal {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementConfigurePlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementConfigurePlain extends WorkflowPlainProcess implements IElementTraversal {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementElementPlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementElementPlain extends WorkflowPlainProcess implements IElementTraversal {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementMoldingPlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementMoldingPlain extends WorkflowPlainProcess implements IElementTraversal {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementPreparePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementPreparePlain extends WorkflowPlainAsyncProcess {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementPropertyPlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementPropertyPlain extends WorkflowPlainProcess implements IElementTraversal {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementRelationPlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { IElementTraversal } from 'sk/data/family/performer/element/IElementTraversal';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class FamilyElementRelationPlain extends WorkflowPlainProcess implements IElementTraversal {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        processElement(context: ElementPerformerContext, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementStructurePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    export class FamilyElementStructurePlain extends WorkflowPlainAsyncProcess {
        protected _calculatorService: CalculatorService;
        protected _familyConfigService: FamilyConfigService;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
        getNodeByElement(performerContext: ElementPerformerContext, document: FamilyDocument, element: Element): DataNode;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyElementVisionModelPlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { NodePerformerContext } from 'sk/data/family/performer/node/NodePerformerContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    export class FamilyElementVisionModelPlain extends WorkflowPlainAsyncProcess {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        protected _familyConfigService: FamilyConfigService;
        computeDataNode(performerContext: NodePerformerContext, node: DataNode): void;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/FamilyPlankMaterialPlain" {
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    export class FamilyPlankMaterialPlain extends WorkflowPlainAsyncProcess {
        protected _schemeConfigService: SchemeConfigService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/ModelElementStructurePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
    import { ModelDocument } from 'sk/data/resource/model/model/ModelDocument';
    export class ResourceElementStructurePlain extends WorkflowPlainAsyncProcess {
        protected _calculatorService: CalculatorService;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
        getNodeByElement(performerContext: ElementPerformerContext, document: ModelDocument, element: Element): DataNode;
    }
}
declare module "sk/rule/data/workflow/plain/PatternBuildStructurePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyStructureService } from 'sk/data/family/library/FamilyStructureService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    export class PatternBuildStructurePlain extends WorkflowPlainAsyncProcess {
        protected _calculatorService: CalculatorService;
        protected _familyStructureService: FamilyStructureService;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
        buildRelation(context: SchemeElementPerformerContext, element: Element): void;
    }
}
declare module "sk/rule/data/workflow/plain/RuleParameterValidatePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { FamilyStructureService } from 'sk/data/family/library/FamilyStructureService';
    import { RuleTypeDocumentService } from 'sk/data/family/rule/RuleTypeDocumentService';
    export class RuleParameterValidatePlain {
        protected _calculatorService: CalculatorService;
        protected _familyStructureService: FamilyStructureService;
        protected _ruleTypeDocumentService: RuleTypeDocumentService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
    }
}
declare module "sk/rule/data/workflow/plain/SchemeBuildPatternPlain" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { NestElement } from 'sk/data/family/element/base/NestElement';
    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 { PatternRuleService } from 'sk/data/family/pattern/PatternRuleService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeLibraryPatternDocumentService } from 'sk/data/scheme/config/SchemeLibraryPatternDocumentService';
    export class SchemeBuildPatternPlain extends WorkflowPlainAsyncProcess {
        protected _calculatorService: CalculatorService;
        protected _schemeLibraryPatternDocumentService: SchemeLibraryPatternDocumentService;
        protected _patternRuleService: PatternRuleService;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
        computeRuleByPatternInstanceElementAsync(context: SchemeElementPerformerContext, element: NestElement): Promise<ResultObject>;
        protected computePatternRuleAsync(context: SchemeElementPerformerContext, element: PatternInstanceElement): Promise<ResultObject>;
        protected addErrorResult(context: ElementPerformerContext, element: ContentElement, errorResult: ResultObject): void;
        protected isNeedCompute(context: SchemeElementPerformerContext, element: PatternInstanceElement): boolean;
    }
}
declare module "sk/rule/data/workflow/plain/SchemeTechniquePlain" {
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { WorkflowPlainAsyncProcess } from 'foundation/data/common/workflow/base/WorkflowPlainAsyncProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleProcessDocumentService } from 'sk/data/family/rule/RuleProcessDocumentService';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    export class SchemeTechniquePlain extends WorkflowPlainAsyncProcess {
        document: FamilyDocument;
        protected _calculatorService: CalculatorService;
        protected _familyConfigService: FamilyConfigService;
        protected _ruleProcessDocumentService: RuleProcessDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        processAsync(context: WorkflowPlainContext): Promise<WorkflowPlainResult>;
        process(): WorkflowPlainResult;
    }
}