@roomle/web-sdk 2.90.0 → 2.91.0-alpha.10

package/lib/definitions/packages/typings/planner-kernel-container.d.ts

@@ -0,0 +1,378 @@
+import type { ConfiguratorKernelClass, KernelAddOnSpot, KernelComponent, KernelConfiguration, KernelDockPairToLine, KernelDockPairToPoint, KernelEnum, KernelParameter, KernelParameterGroup, KernelParameterValue, KernelParamKeyValuePair, KernelPart, KernelPartListParameter, KernelPlanObject, KernelPossibleChild, KernelRange, KernelVariable, KernelVariant, KernelVector2f, KernelVector3f } from './kernel';
+import type { PlanInteractionHandler, WallSide } from './planner';
+import * as ems from './ems';
+import type { Enumify } from '../common-core/src/types';
+declare const EmsArray: typeof ems.EmsArray, EmsList: typeof ems.EmsList, EmsSet: typeof ems.EmsSet;
+export declare class PlanObjectList extends EmsList<PlanObjectPtr> {
+}
+export declare class KernelPlanObjectList extends EmsList<KernelPlanObject> {
+}
+declare class ConstructionObjectSet extends EmsSet<ConstructionObject> {
+}
+declare class PlanObjectObjectSet extends EmsSet<PlanObjectPtr> {
+}
+declare class ExternalReference {
+    getJsObject(): any;
+    setJsObject(jsObject: any): void;
+    getReference(): number;
+    setReference(reference: number): void;
+    setSelfPtr(ptr: any): void;
+    getSelfPtrRef(): any;
+    clearSelfRef(): void;
+}
+declare class EMSReference {
+    jsObject: any;
+    static ptrFromRaw(ptr: number): number;
+    getVoidReference(): number;
+    setVoidReference(reference: number): void;
+    getSelfPtrRef(): number;
+    setSelfPtr(ptr: number): void;
+    clearSelfReference(): void;
+}
+export declare class EMSConstant {
+    value: number;
+}
+declare abstract class AbstractModel {
+    extRef: number;
+    abstract getId(): number;
+}
+declare class AbstractModelWrapper extends AbstractModel {
+    getId(): number;
+}
+declare abstract class PlanElement extends AbstractModelWrapper {
+    isLocked: boolean;
+    isValid: boolean;
+    getType(): PlanElementType;
+    getCenter(): KernelVector3f;
+}
+declare abstract class ObjectGroup extends PlanElement {
+    getObjects(): PlanObjectPtr;
+}
+declare abstract class PlanText extends PlanElement {
+    getText(): string;
+}
+declare abstract class PlanImage extends PlanElement {
+    url: string;
+    size: KernelVector2f;
+    rotation: KernelVector3f;
+    center: KernelVector3f;
+}
+declare abstract class PlanMeasure extends PlanElement {
+    getPoint1(): KernelVector3f;
+    getPoint2(): KernelVector3f;
+}
+declare abstract class Node extends PlanElement {
+    getNumberOfConnectedWalls(): number;
+    getMaxWallHeight(): number;
+}
+declare class CatalogItemPtrList extends EmsList<CatalogItem> {
+}
+export declare class CatalogItem extends AbstractModelWrapper {
+    size: KernelVector3f;
+    layer: number;
+    type: string;
+    configuration: string;
+    orderable: boolean;
+    scaleable: boolean;
+    flipable: boolean;
+}
+declare class PlanObjectPtrList extends EmsList<PlanObjectPtr> {
+}
+declare class PlanObjectPtrVector extends EmsArray<PlanObjectPtr> {
+}
+declare abstract class PlanObjectPtr extends AbstractModelWrapper {
+    rotation: KernelVector3f;
+    customColor: number;
+    level: number;
+    flipX: boolean;
+    flipY: boolean;
+    fixedZ: boolean;
+    size: KernelVector3f;
+    getCatalogItemId(): string;
+    getConfigurationRuntimeId(): number;
+    getObjectType(): string;
+    hasConfiguration(): boolean;
+    isConfigurationLoaded(): boolean;
+}
+declare abstract class ConstructionObject extends PlanObjectPtr {
+    getAttachedWall(): Wall;
+}
+declare class Wall extends PlanObjectPtr {
+    readonly thickness: number;
+    readonly height: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    readonly leftMaterial: WallMaterial;
+    readonly rightMaterial: WallMaterial;
+    getFrom(): Node;
+    getTo(): Node;
+    getCornerFromLeft(): KernelVector3f;
+    getCornerFromRight(): KernelVector3f;
+    getCornerToLeft(): KernelVector3f;
+    getCornerToRight(): KernelVector3f;
+    getAngle(): number;
+    getLength(): number;
+    getPreferredSide(): {
+        value: Enumify<typeof WALL_SIDES>;
+    };
+    getAttachedObjects(): PlanObjectObjectSet;
+    getCenter(): KernelVector3f;
+    getHeightAt(aPoint: KernelVector3f): number;
+    getPointWithHeight(aHeight: number): KernelVector3f;
+}
+declare abstract class Floor extends PlanElement {
+    area: number;
+    material: FloorMaterial;
+    getCorners(): typeof EmsArray<KernelVector3f>;
+    getTriangulationIndices(): typeof EmsArray<number>;
+    getNumberOfTriangles(): number;
+    getRandomPointInside(): KernelVector3f;
+}
+export declare abstract class BaseMaterial {
+    catalogItemId: string;
+    materialId: string;
+    rgbValue: number;
+    getCatalogItemId(): string;
+    getSourceType(): KernelEnum;
+}
+declare abstract class FloorMaterial extends BaseMaterial {
+    uvScale(): KernelVector3f;
+    rotation(): KernelVector3f;
+}
+declare abstract class WallMaterial extends BaseMaterial {
+}
+interface KernelCube {
+    origin: KernelVector3f;
+    size: KernelVector3f;
+}
+declare abstract class Plan extends AbstractModelWrapper {
+    defaultParapetHeight: number;
+    defaultWallColor: number;
+    defaultWallHeight: number;
+    defaultWallThickness: number;
+    increaseLockLevels(): void;
+    getPlanXML(): string;
+    getPlanXMLWithNormalizedLockLevels(): string;
+    getBounds(): KernelCube;
+    getPlanObjects(): PlanObjectPtrVector;
+    getWallCount(): number;
+    getImageCount(): number;
+    isEmpty(): boolean;
+    getTotalFloorArea(): number;
+    applySettings(aRoomHeight: number, aParapetHeight: number): void;
+    syncToView(): void;
+}
+declare abstract class PlanModelViewHelper {
+    static requestMesh3d(aPlanElement: PlanElement): void;
+    static requestPlanMesh3d(aPlanElement: PlanElement, includeCeiling: boolean): void;
+    static requestWallMesh2d(aWall: Wall): void;
+    static requestFloorMesh2d(aFloor: Floor): void;
+    static getCeilingHeight(aFloor: Floor): number;
+    static getMaxDistToBorderForPlanObject(aPlanObject: PlanObjectPtr): number;
+    static getDistToNextWallOnSide(anObject: PlanObjectPtr, aSide: PlanObjectSide, maxDist: number): number;
+    static getDistAlongWallOnSide(anObject: ConstructionObject, aSide: PlanObjectSide, aWallSide: WallSide): number;
+    static setDrawHiddenWallCaps(drawHiddenWallCaps: boolean): void;
+}
+declare class PointArray extends EmsArray<KernelVector3f> {
+}
+declare class SizeTArray extends EmsArray<number> {
+}
+export declare const enum PlanElementType {
+    NODE = 0,
+    WALL = 1,
+    OBJECT = 2,
+    FLOOR = 3,
+    TEXT = 4,
+    MEASURE = 5,
+    IMAGE = 6,
+    CEILING = 7
+}
+export declare const enum PlanObjectSide {
+    Back = 0,
+    Front = 1,
+    Left = 2,
+    Right = 3
+}
+export declare const WALL_SIDES: {
+    readonly LEFT: 0;
+    readonly RIGHT: 1;
+    readonly MIDDLE: 2;
+};
+export interface WallExtensionType {
+    ExtendBegin: EMSConstant;
+    ExtendEnd: EMSConstant;
+    ExtendBoth: EMSConstant;
+}
+export declare const enum MaterialSourceType {
+    None = 0,
+    CatalogItem = 1,
+    Material = 2,
+    RgbValue = 3
+}
+export declare const enum DrawingType {
+    CONTINOUS = 0,
+    CLICK_PER_CLICK = 1
+}
+export declare const enum SnapMode {
+    OFF = 0,
+    ON_COLLISION = 1,
+    ON_COLLISION_ROTATE_WITHIN_DISTANCE = 2,
+    WITHIN_SNAP_DISTANCE = 3
+}
+export declare const enum ResizingAnchor {
+    Center = 0,
+    BackLeft = 1,
+    BackRight = 2,
+    FrontLeft = 3,
+    FrontRight = 4,
+    Back = 5,
+    Front = 6,
+    Left = 7,
+    Right = 8
+}
+declare class StringArray extends EmsArray<string> {
+}
+declare class Vector2fArray extends EmsArray<KernelVector2f> {
+}
+declare class LongArray extends EmsArray<number> {
+}
+declare class DockPairToPointArray extends EmsArray<KernelDockPairToPoint> {
+}
+declare class DockPairToLineArray extends EmsArray<KernelDockPairToLine> {
+}
+declare class ComponentArray extends EmsArray<KernelComponent> {
+}
+declare const enum Type {
+    UNKNOWN = 0,
+    INTEGRAL = 1,
+    DECIMAL = 2,
+    STRING = 3,
+    MATERIAL = 4
+}
+declare const enum UnitType {
+    LENGTH = 0,
+    AREA = 1,
+    ANGLE = 2,
+    COUNT = 3
+}
+declare class VariableArray extends EmsArray<KernelVariable> {
+}
+declare class RangeArray extends EmsArray<KernelRange> {
+}
+declare class ParameterValueArray extends EmsArray<KernelParameterValue> {
+}
+declare class ParameterArray extends EmsArray<KernelParameter> {
+}
+declare class ParameterGroupArray extends EmsArray<KernelParameterGroup> {
+}
+declare class PartListParameterArray extends EmsArray<KernelPartListParameter> {
+}
+declare class ConfigurationArray extends EmsArray<KernelConfiguration> {
+}
+declare class PartArray extends EmsArray<KernelPart> {
+}
+declare class PossibleChildArray extends EmsArray<KernelPossibleChild> {
+}
+declare class AddOnSpotArray extends EmsArray<KernelAddOnSpot> {
+}
+declare class ParamKeyValuePairArray extends EmsArray<KernelParamKeyValuePair> {
+}
+declare class VariantArray extends EmsArray<KernelVariant> {
+}
+declare class IntArray extends EmsArray<number> {
+}
+declare const enum Unit {
+    InchFeet = 0,
+    MM = 1,
+    CM = 2
+}
+declare const enum UnitStringType {
+    NoUnitString = 0,
+    LongUnitString = 1,
+    ShortUnitString = 2
+}
+declare class UnitMeasureFormatter {
+    init(mmLabel: string, cmLabel: string, ftShortLabel: string, ftLongLabel: string, inchShortLabel: string, inchLongLabel: string, sqMLabel: string, sqftLabel: string, showExactValue: boolean, maxPrecision: number, showFractionalUnitString: boolean): void;
+    showExactValues(shouldeI: boolean): void;
+    formatMMValueToUnitString(aValue: number, aUnit: Unit, aStringType: UnitStringType): string;
+    formatMMValueWithReqMaxLength(aValue: number, aUnit: Unit, reqMaxSize: number): string;
+    parseMMValueFromUnitString(aString: string, aUnit: Unit): number;
+    formatSquareMMValueToUnitString(aValue: number, aUnit: Unit): string;
+    parseSquareMMValueFromUnitString(aString: string, aUnit: Unit): number;
+    isParseableUnitString(aString: string, aUnit: Unit): boolean;
+    parseNumber(aString: string): number;
+    formatNumber(aValue: number, digit: number): string;
+    isParseableNumber(aString: string): boolean;
+}
+export interface PlannerKernelContainer {
+    PointArray: PointArray;
+    SizeTArray: SizeTArray;
+    ConstructionObjectSet: ConstructionObjectSet;
+    PlanObjectObjectSet: PlanObjectObjectSet;
+    ExternalReference: ExternalReference;
+    EMSReference: EMSReference;
+    AbstractModel: AbstractModel;
+    PlanElementType: PlanElementType;
+    PlanElement: PlanElement;
+    ObjectGroup: ObjectGroup;
+    PlanText: PlanText;
+    PlanImage: PlanImage;
+    PlanMeasure: PlanMeasure;
+    Node: Node;
+    CatalogItemPtrList: CatalogItemPtrList;
+    CatalogItem: CatalogItem;
+    PlanObjectSide: PlanObjectSide;
+    toPlanObjectSide: (a: number) => PlanObjectSide;
+    PlanObjectPtrList: PlanObjectPtrList;
+    PlanObjectPtrVector: PlanObjectPtrVector;
+    PlanObject: PlanObjectPtr;
+    ConstructionObject: ConstructionObject;
+    ConstObjectPtr: ConstructionObject;
+    WallSide: WallSide;
+    toWallSide: (a: number) => WallSide;
+    WallExtensionType: WallExtensionType;
+    Wall: Wall;
+    Floor: Floor;
+    MaterialSourceType: MaterialSourceType;
+    BaseMaterial: BaseMaterial;
+    FloorMaterial: FloorMaterial;
+    WallMaterial: WallMaterial;
+    Plan: Plan;
+    DrawingType: DrawingType;
+    ResizingAnchor: ResizingAnchor;
+    toResizingAnchor: (a: number) => ResizingAnchor;
+    PlanInteractionHandler: PlanInteractionHandler;
+    PlanModelViewHelper: PlanModelViewHelper;
+    catalogItemLoaded: (aCatalogItem: CatalogItem) => void;
+    registerPlannerCallback: (callbacksObject: any) => void;
+    unregisterPlannerCallback: (callbacksObject: any) => void;
+    StringArray: StringArray;
+    Vector2fArray: Vector2fArray;
+    LongArray: LongArray;
+    DockPairToPointArray: DockPairToPointArray;
+    DockPairToLineArray: DockPairToLineArray;
+    ComponentArray: ComponentArray;
+    Type: Type;
+    UnitType: UnitType;
+    VariableArray: VariableArray;
+    RangeArray: RangeArray;
+    ParameterValueArray: ParameterValueArray;
+    ParameterArray: ParameterArray;
+    ParameterGroupArray: ParameterGroupArray;
+    PartListParameterArray: PartListParameterArray;
+    ConfigurationArray: ConfigurationArray;
+    PartArray: PartArray;
+    PossibleChildArray: PossibleChildArray;
+    AddOnSpotArray: AddOnSpotArray;
+    PlanObjectList: PlanObjectList;
+    ParamKeyValuePairArray: ParamKeyValuePairArray;
+    VariantArray: VariantArray;
+    IntArray: IntArray;
+    Kernel: ConfiguratorKernelClass;
+    Unit: Unit;
+    UnitStringType: UnitStringType;
+    toUnit: (enumIndex: number) => Unit;
+    toUnitFormat: (enumIndex: number) => UnitStringType;
+    UnitMeasureFormatter: UnitMeasureFormatter;
+}
+export {};

package/lib/definitions/packages/typings/planner.d.ts

@@ -0,0 +1,315 @@
+import type { ConfiguratorKernelClass, ExternalModuleInformation, KernelCatalogItem, KernelCube, KernelEnum, KernelObjectPtrList, KernelPlanObject, KernelPlanObjectComponent, KernelVector3, KernelVector3f, ObjectGroupPtr, RuntimeId } from './kernel';
+import type { DrawingType, KernelPlanObjectList, PlanObjectList, ResizingAnchor, SnapMode, WALL_SIDES, EMSConstant } from './planner-kernel-container';
+import type { Position2 } from '../common-core/src/common-interfaces';
+import type { Enumify } from '../common-core/src/types';
+import * as ems from './ems';
+import type { ConstructionObjectDoorArchArray } from 'roomle-core-hsc/src/embind/plannerCoreInterface';
+declare const EmsArray: typeof ems.EmsArray;
+export interface EMSReference {
+    jsObject: any;
+    delete(): any;
+}
+export interface KernelObject {
+    extRef: EMSReference;
+    clone(): KernelObject;
+    delete(): void;
+    getId(): number;
+}
+export declare const INITIAL_SNAP_DISTANCE = 50;
+export interface Plan extends KernelObject {
+    defaultParapetHeight: number;
+    defaultWallHeight: number;
+    defaultWallThickness: number;
+    vectorWallThickness: number;
+    getPlanObjects(): any;
+    getBounds(): KernelCube;
+    getTotalFloorArea(): number;
+    getPlanXML(includeRuntimeId: boolean, xmlVersion: number /** current version is 2 */): string;
+    createPlanXmlWithSingleObject(object: PlanObject, includeRuntimeId: boolean, version: number): string;
+    createPlanXmlWithSingleObjectFromId(objectId: string, includeRuntimeId: boolean, version: number): string;
+    createObjWithPlanContours(levels: number[]): string;
+    getWallCount(): number;
+    getId(): number;
+}
+export interface PlanElement extends KernelObject {
+    getType(): any;
+    getCenter(): KernelVector3;
+    getMeshCenter(): KernelVector3;
+    getMeshOffsetRelativeToObject(): KernelVector3;
+    getId(): number;
+    readonly hidden: boolean;
+}
+export interface RectangleReferencePoints {
+    bottom: KernelVector3;
+    bottomLeft: KernelVector3;
+    bottomRight: KernelVector3;
+    center: KernelVector3;
+    left: KernelVector3;
+    right: KernelVector3;
+    top: KernelVector3;
+    topLeft: KernelVector3;
+    topRight: KernelVector3;
+}
+export interface ObjectToWallLine {
+    angle: number;
+    endPoint: KernelVector3;
+    length: number;
+    startPoint: KernelVector3;
+}
+declare class PointArray extends EmsArray<KernelVector3f> {
+}
+declare class ObjectToWallLineArray extends EmsArray<ObjectToWallLine> {
+}
+export interface Rectangle {
+    angle: number;
+    center: KernelVector3f;
+    cornerPoints: PointArray;
+    referencePoints: RectangleReferencePoints;
+    size: KernelVector3f;
+}
+export interface PlanObject extends PlanElement {
+    size: KernelVector3;
+    rotation: number;
+    customColor: number;
+    flipX: boolean;
+    flipY: boolean;
+    fixedZ: boolean;
+    boxForMeasurement: KernelCube;
+    hasConfiguration(): boolean;
+    isExternalObject(): boolean;
+    getConfigurationHash(): string;
+    getConfiguration(): string;
+    getCatalogItemId(): string;
+    getConfigurationRuntimeId(): number;
+    getObjectType(): string;
+    getWallDistances(): ObjectToWallLineArray;
+    getRectangle(): Rectangle;
+}
+export interface WallSide {
+    value: Enumify<typeof WALL_SIDES>;
+}
+export interface LeftOrRightWallSide {
+    value: Enumify<Pick<typeof WALL_SIDES, 'LEFT' | 'RIGHT'>>;
+}
+export interface WallMeasurementsFactors {
+    maxZoomedIn: number;
+    maxZoomedOut: number;
+    minPadding: number;
+    maxPadding: number;
+}
+export interface PlanMeasure extends PlanObject {
+    getPoint1(): KernelVector3f;
+    getPoint2(): KernelVector3f;
+}
+export interface WallPlanObject extends PlanObject {
+    getPreferredSide(): LeftOrRightWallSide;
+    getCornerFromLeft(): KernelVector3;
+    getCornerFromRight(): KernelVector3;
+    getCornerToLeft(): KernelVector3;
+    getCornerToRight(): KernelVector3;
+    getCenter(): KernelVector3;
+    getLength(preferredSide: WallSide): number;
+    getFrom(): NodePlanObject;
+    getTo(): NodePlanObject;
+    readonly thickness: number;
+    readonly height: number;
+}
+export interface ConstructionPlanObject extends PlanObject {
+    getAttachedWall(): WallPlanObject;
+    getPreferredSide(): LeftOrRightWallSide;
+    getCornerFromLeft(): KernelVector3;
+    getCornerFromRight(): KernelVector3;
+    getCornerToLeft(): KernelVector3;
+    getCornerToRight(): KernelVector3;
+    getDoorArches(): ConstructionObjectDoorArchArray;
+}
+export interface NodePlanObject extends PlanObject {
+    getNumberOfConnectedWalls(): number;
+    getMaxWallHeight(): number;
+}
+export interface ContinuousDrawingManager {
+    getStartPoint(): KernelVector3;
+    getDrawingAngle(): number;
+    getCircleRotation(): number;
+    shouldShowCircle(): boolean;
+    isCorridorValid(): boolean;
+    getCorridor(): any;
+    getDrawnPoints(): KernelObjectPtrList;
+    CIRCLE_RADIUS: number;
+}
+interface Anchor {
+    value: ResizingAnchor;
+}
+export declare const CORE_CHILD_ENTITY_MODE: {
+    readonly OFF: 0;
+    readonly GROUND_COMPONENTS: 1;
+    readonly ALL_COMPONENTS: 2;
+};
+export interface ChildEntityMode {
+    value: Enumify<typeof CORE_CHILD_ENTITY_MODE>;
+}
+export interface PlanInteractionHandler {
+    init(reference: PlanInteractionHandler, zoomFactor: number, viewSnapDist: number, wallSnapMode: any, objectSnapMode: any, shouldSnap: boolean, drawingType: any): PlanInteractionHandler;
+    getConfiguratorKernel(): ConfiguratorKernelClass;
+    loadPlanXML(xml: string): Plan;
+    createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan;
+    getPlan(): Plan;
+    moveElementTo(planObject: KernelObject, point: KernelVector3): void;
+    moveElementBy(planObject: KernelObject, distance: KernelVector3): void;
+    duplicatePlanObject(object: PlanObject, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
+    duplicatePlanObjects(objects: PlanObjectList, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
+    setElementVisibility(element: PlanElement, isVisible: boolean): void;
+    moveObjectsBy(planObjects: KernelObjectPtrList, distance: KernelVector3): void;
+    rotateObjectTo(planObject: KernelObject, angleInRad: number): void;
+    setObjectRotation(planObject: KernelObject, angleInRad: number): void;
+    addPlanObjects(list: KernelObjectPtrList, findFreeSpaceInPlan: boolean): PlanObject[];
+    addPlanObjectFromItem(object: KernelObject, position: KernelVector3, type: number, findFreeSpaceInPlan: boolean): PlanObject;
+    addOrUpdateExternalPlanObjects(serialzedConfiguration: string, position: KernelVector3, rotationInRad: number, findFreeSpaceInPlan: boolean, applyGlobalChildMode: boolean, isVisible: boolean): PlanObject[];
+    catalogItemLoaded(catalogItem: KernelCatalogItem): void;
+    removeElement(planObject: KernelObject): void;
+    removeObjectWithId(objectId: string): void;
+    groupObjects(planObjectPtrList: PlanObjectList): ObjectGroupPtr;
+    rotateObjectsBy(planObjectPtrList: PlanObjectList, anAngleInRad: number, aroundPoint: KernelVector3): void;
+    rotateGroupBy(group: ObjectGroupPtr, anAngleInRad: number, aroundPoint: KernelVector3): void;
+    deactivateAllSnappingActivity(): void;
+    reactivateAllSnappingActivity(): void;
+    isUndoPossible(): boolean;
+    isRedoPossible(): boolean;
+    startInteraction(): void;
+    endInteraction(): void;
+    undo(): void;
+    redo(): void;
+    isVectorPreviewModeEnabled(): boolean;
+    beginDrawing(point: {
+        x: number;
+        y: number;
+        z: number;
+    }, vectorPreviewMode: boolean): void;
+    endDrawing(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    cancelDrawing(): void;
+    addNode(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): PlanNode;
+    addWall(from: PlanNode, to: PlanNode): KernelWall;
+    setWallHeight(wall: KernelWall, height: number): void;
+    setLengthOfWall(wall: KernelWall, length: number, preferredSide: WallSide, direction: EMSConstant, moveOrthogonalWalls: boolean): void;
+    setWallThickness(wall: KernelWall, thickness: number): void;
+    currentDrawingPosition(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    forceNode(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    setDrawingType(aNewDrawingType: DrawingType): void;
+    setZoomFactor(pxPerMM: number): void;
+    setViewSnapDist(aDist: number): void;
+    setRotationSnapAngle(angleInRadians: number): void;
+    setDefaultWallThickness(wallThickness: number, applyToAll: boolean): void;
+    setDefaultWallHeight(wallHeight: number, applyToAll: boolean): void;
+    setDefaultParapetHeight(parapetHeight: number, applyToAll: boolean): void;
+    getDefaultExteriorWallMaterial(): KernelWallMaterial;
+    setDefaultExteriorWallMaterial(wallMaterial: KernelWallMaterial): void;
+    getDefaultInteriorWallMaterial(): KernelWallMaterial;
+    setDefaultInteriorWallMaterial(wallMaterial: KernelWallMaterial): void;
+    getDefaultFloorMaterial(): KernelFloorMaterial;
+    setDefaultFloorMaterial(floorMaterial: KernelFloorMaterial): void;
+    setWallLeftMaterial(wall: KernelWall, material: KernelWallMaterial): void;
+    setWallRightMaterial(wall: KernelWall, material: KernelWallMaterial): void;
+    setFloorMaterial(floor: KernelFloor, material: KernelFloorMaterial): void;
+    getContinuousDrawingManager(): ContinuousDrawingManager;
+    setSnapFeedbackWhileDrawing(enabled: boolean): void;
+    consistsOfMergedComponents(object: KernelObject): boolean;
+    getShowChildrenOfPlanObject(object: KernelObject): ChildEntityMode;
+    setShowChildrenOfPlanObject(object: KernelObject, mode: ChildEntityMode, switchChildModeOffForAllOtherObjects: boolean): void;
+    setObjectSize(anObject: KernelObject, aNewSize: KernelVector3, anAnchor: Anchor): void;
+    setObjectFlipX(anObject: KernelObject, shouldFlipX: boolean): void;
+    setObjectFlipY(anObject: KernelObject, shouldFlipY: boolean): void;
+    setObjectCustomColor(anObject: KernelObject, aCustomColor: number): void;
+    setObjectFixedZ(anObject: KernelObject, shouldFlipZ: boolean): void;
+    setMeasurePoint1(measure: PlanMeasure, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
+    setMeasurePoint2(measure: PlanMeasure, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
+    addMeasure(startPosition: KernelVector3f, endPosition: KernelVector3f): PlanMeasure;
+    setDiscardExternalObjectsOnLoad(discard: boolean): void;
+    unit: string;
+    enableRaster: boolean;
+    customRaster: number;
+    enableSnap: boolean;
+    enableDrawingSnap: boolean;
+    objectToWallSnapMode: SnapMode;
+    objectToObjectSnapMode: SnapMode;
+    dockWhenSnap: boolean;
+    unDockOnMove: boolean;
+    showChildrenOfPlanObjects: ChildEntityMode;
+}
+export interface PlanOverview {
+    area: number;
+    bounds: KernelCube;
+    objects: KernelPlanObjectList;
+    outsideWalls: PlanElement[];
+    rooms: PlanElement[];
+}
+export interface PlanModelViewHelper {
+    getPlanOverview(planObject: KernelObject): PlanOverview;
+    getPlanObject(plan: Plan, aRuntimeId: number): KernelPlanObject;
+    getRootPlanObjectId(plan: Plan, aRuntimeId: number): number;
+    getObjectComponent(plan: Plan, aComponentOrConfigurationId: number): KernelPlanObjectComponent;
+    getExternalObjectComponent(plan: Plan, groupId: string, moduleId: string): KernelPlanObjectComponent;
+    getExternalComponentModuleIdsForSelection(plan: Plan, groupOrRootModuleId: string, subModuleId: string): ExternalModuleInformation;
+    requestMesh3d(element: PlanElement): void;
+}
+export interface PlanNode extends KernelObject {
+    getMaxWallHeight(): number;
+    getNumberOfConnectedWalls(): number;
+}
+export interface KernelWallMaterial extends KernelObject {
+    catalogItemId: string;
+    materialId: string;
+    rgbValue: number;
+}
+export interface KernelFloorMaterial extends KernelObject {
+    catalogItemId: string;
+    materialId: string;
+    rgbValue: number;
+    rotation: number;
+}
+export declare const enum KernelWallType {
+    StandAloneWall = 0,
+    OuterWallLeft = 1,
+    OuterWallRight = 2,
+    InnerWall = 3
+}
+export interface KernelWall extends KernelObject {
+    readonly thickness: number;
+    readonly meshThickness: number;
+    readonly isVectorWall: boolean;
+    readonly height: number;
+    readonly leftMaterial: KernelWallMaterial;
+    readonly rightMaterial: KernelWallMaterial;
+    readonly wallType: KernelEnum;
+    readonly leftNormal: KernelVector3;
+    readonly rightNormal: KernelVector3;
+    getAngle: () => number;
+}
+export interface KernelFloor extends KernelObject {
+    area: number;
+    material: KernelFloorMaterial;
+    getCenter: () => KernelVector3;
+    getRandomPointInside: () => KernelVector3;
+    getLabelPosition: () => KernelVector3;
+}
+export interface PlanObjectPosition {
+    runtimeId: RuntimeId;
+    position2d: Position2;
+}
+export type CancelSelectionReasons = 'swap_object' | 'click_outside' | 'select_other' | 'double_click_wall' | 'unknown' | 'dock_component' | 'delete_object';
+export {};