@roomle/embedding-lib 5.24.0 → 5.25.0-alpha.10

package/packages/web-sdk/packages/typings/planner.d.ts

@@ -0,0 +1,381 @@
+import { ConfiguratorKernelClass, ExternalModuleInformation, KernelCatalogItem, KernelCube, KernelEnum, KernelObjectPtrList, KernelPlanObject, KernelPlanObjectComponent, KernelVector3, KernelVector3f, ObjectGroupPtr, RuntimeId } from './kernel';
+import { DrawingType, KernelPlanObjectList, PlanObjectList, ResizingAnchor, SnapMode, WALL_SIDES, EMSConstant } from './planner-kernel-container';
+import { Position2 } from '../common-core/src/common-interfaces';
+import { Enumify } from '../common-core/src/types';
+import { ConstructionObjectDoorArchArray } from 'roomle-core-hsc/src/embind/plannerCoreInterface';
+
+import * as ems from './ems';
+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;
+    createPlanXmlWithObjects(objectId: string | string[], includeRuntimeId: boolean, version: 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 ObjectFrontRotation {
+    lookAtSide: WallSide;
+    rotation: number;
+    rotationRoundTo90deg: number;
+}
+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;
+    getRotationToPreferredFront(): ObjectFrontRotation;
+}
+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;
+    getAttachedAttics(): KernelAtticArray;
+    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 ExternalObjectLoadConfiguration {
+    applyGlobalChildMode: boolean;
+    correctArrangement: boolean;
+    findFreeSpaceInPlan: boolean;
+    isVisible: boolean;
+}
+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 | string[], position: KernelVector3, rotationInRad: number, updateConfiguration: ExternalObjectLoadConfiguration, mergedGroupIds: string | string[]): 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;
+    resumeInteraction(): 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;
+    addAttic(wall: KernelWall, kneeHeight: number, width: number, side: WallSide | null | undefined): KernelAttic;
+    setAtticSide(attic: KernelAttic, side: WallSide): void;
+    setAtticKneeHeight(attic: KernelAttic, kneeHeight: number): void;
+    setAtticWidth(attic: KernelAttic, width: 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;
+    setRoomParapetHeight(floor: KernelFloor, parapetHeight: number): 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;
+    setFloorLabelObject(floor: KernelFloor, serializedLabelObject: string): void;
+    getContinuousDrawingManager(): ContinuousDrawingManager;
+    setSnapFeedbackWhileDrawing(enabled: boolean): void;
+    consistsOfMergedComponents(object: KernelObject): boolean;
+    getShowChildrenOfPlanObject(object: KernelObject): ChildEntityMode;
+    setShowChildrenOfPlanObject(object: KernelObject, mode: ChildEntityMode, switchChildModeOffForAllOtherObjects: boolean): void;
+    setShowChildrenOfExternalObject(objectId: string, 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 KernelObjectConfiguration {
+    runtimeId: number;
+    serializedDefinition: string;
+    uniqueId: string;
+}
+export declare class KernelObjectConfigurationArray extends EmsArray<KernelObjectConfiguration> {
+}
+export interface LightSourceConfiguration {
+    lightSourceAreaInSquareMeters: number;
+    minimumRoomSizeInSquareMeters: number;
+    maximumNumberOfLightSources: number;
+}
+export interface RoomLightSourceDistribution {
+    ceilingId: number;
+    floorId: number;
+    positionsInPlan: PointArray;
+    positionsRelativeToFloor: PointArray;
+}
+declare class RoomLightSourceDistributionArray extends EmsArray<RoomLightSourceDistribution> {
+}
+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;
+    getExternalObjectGroups(plan: Plan): KernelObjectConfigurationArray;
+    calculateLightSourceDistribution(plan: Plan, lightSourceConfiguration: LightSourceConfiguration): RoomLightSourceDistributionArray;
+}
+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,// has a floor on the right side but not on the left side
+    OuterWallRight = 2,// has a floor on the left side but not on the right side
+    InnerWall = 3
+}
+export interface KernelWall extends KernelObject {
+    getFrom(): Node;
+    getTo(): Node;
+    getAttachedAttics(): KernelAtticArray;
+    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 KernelRoomWall {
+    roomSide: WallSide;
+    wall: KernelWall;
+}
+declare class KernelAtticArray extends EmsArray<KernelAttic> {
+}
+export interface KernelAttic extends KernelObject {
+    getFrom(): NodePlanObject;
+    getTo(): NodePlanObject;
+    getAssociatedWall(): KernelWall;
+    get2dPolygon(): PointArray;
+    getRidgePoints(): PointArray;
+    getPointsWithHeight(height: number): PointArray;
+    readonly side: WallSide;
+    readonly kneeHeight: number;
+    readonly width: number;
+}
+export interface KernelFloor extends KernelObject {
+    area: number;
+    material: KernelFloorMaterial;
+    readonly parapetHeight: number;
+    getCenter: () => KernelVector3;
+    getRandomPointInside: () => KernelVector3;
+    getLabelPosition: () => KernelVector3;
+    getWallsOfRoom: () => KernelRoomWall[];
+    getLabelObject(): string;
+}
+export interface PlanObjectPosition {
+    runtimeIds: RuntimeId[];
+    position2d: Position2;
+}
+export type CancelSelectionReasons = 'swap_object' | 'dragIn' | 'click_outside' | 'select_other' | 'double_click_wall' | 'unknown' | 'dock_component' | 'delete_object' | 'selection_mode_changed' | 'dock_preview' | 'reset_scene' | 'delete_component' | 'isolation_mode_cancelled' | 'isolation_mode_started' | 'duplicate' | 'undo' | 'redo';
+export {};