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

package/packages/web-sdk/packages/planner-core/src/roomle-planner.d.ts

@@ -0,0 +1,516 @@
+import { default as RoomlePlannerUiCallback } from './roomle-planner-ui-callback';
+import { GlbViewer } from '../../glb-viewer-core/src/glb-viewer';
+import { ExternalEmbeddable, GlobalAPI, KernelUtilityForUi, RubensAPI, default as Main } from '../../common-core/src/main';
+import { Configurator } from '../../configurator-core/src/configurator';
+import { GlobalInitDataDefinition, InitDataDefinition } from '../../common-core/src/utils/shims';
+import { ConfigurationString, RapiConfiguration, RapiId, RapiItem, RapiPlan, RapiPlanSnapshotGetData, RapiPlanSnapshotGetDataWith3dUrls } from '../../typings/rapi-types';
+import { Context } from '../../common-core/src/di/context';
+import { CancelSelectionReasons, KernelObject, KernelWall, PlanInteractionHandler, PlanModelViewHelper, PlanOverview, KernelAttic, PlanObject, WallSide } from '../../typings/planner';
+import { KernelAccessCallbackI } from '../../common-core/src/kernel-access-callback';
+import { default as InitData } from '../../common-core/src/utils/init-data';
+import { CanvasOffset, Position3 } from '../../common-core/src/common-interfaces';
+import { PrepareImageOptions } from '../../common-core/src/webgl/image-renderer';
+import { KernelParameter, KernelPartList, KernelPartListPrice, KernelVector3, RuntimeId, UiPlanObject } from '../../typings/kernel';
+import { default as UnitFormatter } from '../../configurator-core/src/services/unit-formatter';
+import { default as RoomleConfigurator } from '../../configurator-core/src/roomle-configurator';
+import { EMSConstant, PlannerKernelContainer } from '../../typings/planner-kernel-container';
+import { Scene } from 'three';
+import { CameraParameter } from '../../common-core/src/cameracontrol/camera-control';
+import { default as PlanElementViewModel } from '../../common-core/src/view-model/plan-element-view-model';
+import { default as WallPlanElementViewModel } from './view-model/wall-plan-element-view-model';
+import { default as ConfiguratorContext } from '../../common-core/src/webgl/configurator-context';
+import { default as IdbManager } from '../../common-core/src/services/idb-manager';
+import { ExternalObjectAPI, ExternalObjectApiConfiguration } from './external-object-api';
+import { GlobalCallback } from '../../common-core/src/services/global-callback';
+import { ExternalGroupData, ExternalObject, ExtObjId } from '../../typings/external-objects';
+import { PluginName } from '../../configurator-core/src/utils/plugin-types';
+import { Nullable } from '../../typings/helper';
+import { MaybePromise } from '../../common-core/src/utils/common-utils';
+
+export type ID_TYPE = 'rml_id' | 'tc_id' | 'rml_serialized' | 'tc_serialized';
+export declare const EXT_OBJ_EXCEPTION = "Could not retrieve configuration for external object! Did you implement onGetConfigurationForExternalObject?";
+export interface RoomlePlannerCallback {
+    switchToConfigurator: () => Promise<Configurator>;
+    switchToViewer: () => Promise<GlbViewer>;
+    cancelSelection: (reason: CancelSelectionReasons) => void;
+    deleteSelection: () => void;
+    rotateSelection: (rotateBy: number) => void;
+}
+export interface WallDefinition {
+    from: Position3;
+    to: Position3;
+    props?: {
+        thickness?: number;
+        height?: number;
+    };
+}
+export interface InteractionOptions {
+    keepInteractionOpen?: boolean;
+}
+export interface SceneEvents {
+    /**
+     * walls and wall nodes
+     */
+    construction?: boolean;
+    /**
+     * static and configurable items
+     */
+    objects?: boolean;
+}
+export interface BatchPaintMaterial {
+    id?: RapiId;
+    materialId?: RapiId;
+    color?: string;
+    rgbValue?: number;
+    catalogItemId?: RapiId;
+}
+export interface InsertItemIdInfo {
+    id: RapiId | ExtObjId;
+    index: number;
+}
+export interface InsertItemResult {
+    runtimeId: RuntimeId;
+    originalIndex: number;
+}
+export default class RoomlePlanner<P extends readonly PluginName[] = readonly []> implements KernelAccessCallbackI, RoomlePlannerCallback, GlobalAPI, Context, KernelUtilityForUi, ExternalEmbeddable<RoomlePlannerUiCallback>, RubensAPI, ExternalObjectAPI {
+    _creator_: string;
+    private _activePlugins;
+    private _configuratorContext;
+    private _domHelper;
+    private _scriptLoader;
+    private _kernelAccessCallback;
+    private _plannerKernelAccess;
+    private _rapiAccess;
+    private _singlePromiseFactory;
+    private _roomlePlannerUiCallback;
+    private _lifeCycleManager;
+    private _dataSyncer;
+    protected _initData: InitData;
+    protected _idbManager: IdbManager;
+    private _globalInitData;
+    private _globalCallback;
+    private _unitFormatter;
+    private _planInteractionHandler;
+    private _sceneManager;
+    private _plan;
+    private _preloadPlanId;
+    private _kernelReadyCallback;
+    private _hscInstance;
+    private _glbInstance;
+    private _configurator;
+    private _currentMode;
+    constructor(creator: string, activePlugins?: P);
+    setEnvironmentMap(params: {
+        url?: string;
+        intensity?: number;
+        rotation?: number;
+        maxLightSources?: number;
+    }): void;
+    deleteSelection(): void;
+    /**
+     * rotates the selected item(s)
+     * @param rotateBy angle in rad
+     */
+    rotateSelection(rotateBy: number): void;
+    cancelSelection(reason?: CancelSelectionReasons): void;
+    init(element: HTMLElement, preloadPlanId?: string, options?: InitDataDefinition & GlobalInitDataDefinition): Promise<void>;
+    /**
+     * creates and loads a plan from a given object
+     * @param id
+     * @param position
+     * @param rotation
+     *
+     * return the object runtime id
+     */
+    createPlanFromObject(id: RapiId, position?: Position3, rotation?: number): Promise<number>;
+    loadPlanXml(xml: string, options?: InitDataDefinition & GlobalInitDataDefinition): Promise<void>;
+    loadPlan(id: string, options?: InitDataDefinition & GlobalInitDataDefinition): Promise<RapiPlan | RapiPlanSnapshotGetData>;
+    /**
+     * Set general configuration parameter
+     * @param initData
+     */
+    setOverrides(initData: InitDataDefinition & GlobalInitDataDefinition): void;
+    toggleConfigureInRoom(): void;
+    switch2D(): void;
+    switch3D(): void;
+    switchToFirstPerson(): void;
+    resetCameraPosition(): void;
+    exportGLB(): void;
+    importGLB(url: string): void;
+    private _initPromiseCallback;
+    isReady(): void;
+    showBenchmarks(): void;
+    getConfiguratorApi(): RoomleConfigurator<P>;
+    startViewing(): void;
+    startConfiguring(): void;
+    /**
+     * select an object in the scene based on its runtime id
+     * @param runtimeId
+     */
+    selectPlanObjectById(runtimeId: RuntimeId): Promise<void>;
+    /**
+     * Highlights one or more objects in the scene based on their runtime IDs.
+     * If `runtimeIds` is `null`, all highlighted objects will be unhighlighted.
+     *
+     * @param runtimeIds A single runtime ID, an array of runtime IDs, or null.
+     */
+    highlightPlanElements(runtimeIds: number | number[] | null): void;
+    backToPlanner(): void;
+    showGUI(): void;
+    switchToConfigurator(): Promise<Configurator>;
+    switchToViewer(): Promise<GlbViewer>;
+    switchToPlanner(id?: string): void;
+    updateSize(): void;
+    /**
+     * Return the main class which has access to lifecycle events and RapiAccess.
+     * Hidden because it's only useful for embedding API.
+     * Has to be overridden by main class.
+     * @hidden
+     */
+    getMain(): Main;
+    update(): void;
+    get callbacks(): RoomlePlannerUiCallback;
+    set callbacks(callback: RoomlePlannerUiCallback);
+    /**
+     * Check if the 3D scene contains only one room
+     * @returns {boolean} True if there is only one room, false otherwise
+     */
+    get hasSingleRoom(): boolean;
+    showStats(): void;
+    onCloseHSC(): void;
+    back(): void;
+    backTo(_cssClass: string): void;
+    getConfigurator(): Configurator;
+    getCurrentSkin(): Promise<import('../../typings/rapi-types').RapiSkin>;
+    /**
+     * Returns the runtime component id of the plan object with the given id
+     * @param planObjectId id of the plan object you want to get the runtime component id of the root component from
+     * @return number the number of the runtime id of the root component
+     */
+    getRuntimeComponentIdOfRootComponent(planObjectId: number): number;
+    /**
+     * This method is used for lifecycle tests only
+     * @hidden
+     */
+    resumeTest(element: HTMLElement): void;
+    /**
+     * This method is used for lifecycle tests only
+     * @hidden
+     */
+    pauseTest(): void;
+    syncCatalog(catalogId: string): Promise<void>;
+    loadError(error?: any): void;
+    getPlanInteractionHandler(): Promise<PlanInteractionHandler>;
+    getPlanModelViewHelper(): Promise<PlanModelViewHelper>;
+    /**
+     * Inserts the object into the scene (at a given position and rotation)
+     * @param id
+     * @param position x (left/right),y (up, down) and z(front, back) in meters
+     * @param rotation in radians
+     */
+    insertObject(id: RapiId | ExtObjId, position?: Position3, rotation?: number): Promise<RuntimeId>;
+    insertItemList(ids: Array<RapiId | ExtObjId>): Promise<RuntimeId[]>;
+    /**
+     * Inserts all of the items in the array into current plan
+     * @param itemList Array of items received from the Roomle API
+     */
+    insertItems(itemList: Array<RapiItem | RapiConfiguration | ExtObjId | ExternalObject>): Promise<RuntimeId[]>;
+    /**
+     * Duplicates all planObjects in the array and inserts them into the current plan
+     * @param itemList Array of PlanObjects
+     */
+    duplicateItems(itemList: PlanObject[]): PlanObject[];
+    getScene(): Scene;
+    updateScene(): void;
+    getCameraOffset(): CanvasOffset;
+    setCameraOffset(offset: CanvasOffset): void;
+    /**
+     * returns all objects found in the current plan
+     * this includes info about size, rotation, id and parts
+     */
+    getObjects(): Promise<UiPlanObject[]>;
+    /**
+     * get all info available for the current plan, including objects, rooms and walls
+     */
+    getPlanOverview(): Promise<PlanOverview>;
+    /**
+     * Generates a top image (birds eye view) and returns it as base64
+     * @param options
+     */
+    prepareTopImage(options?: PrepareImageOptions): Promise<import('../../common-core/src/common-interfaces').Base64Image>;
+    /**
+     * Generates a perspective image (slightly from the side) and returns it as base64
+     * @param options
+     @param isolationMode - defaults to false. Determines whether to generate a perspective image for the current configuration.
+     */
+    preparePerspectiveImage(options?: PrepareImageOptions, isolationMode?: boolean): Promise<import('../../common-core/src/common-interfaces').Base64Image>;
+    /**
+     * Enables rotation of selected elements
+     */
+    enableRotation(): void;
+    /**
+     * Disable rotation of selected elements
+     */
+    disableRotation(): void;
+    /**
+     * Enable the selection of multiple elements.
+     * Common parameters shared between those elements can then be changed at once
+     */
+    enableMultiselect(): void;
+    /**
+     * Disable the selection of multiple elements.
+     */
+    disableMultiselect(): void;
+    private _insertExternalObject;
+    dragInObject(idOrSerializedConfigString: string, dragEvent: DragEvent, type?: ID_TYPE): Promise<RuntimeId>;
+    /**
+     * enable snapping of object to object and object to wall
+     */
+    enableSnapping(): void;
+    /**
+     * disable all types of snapping
+     */
+    disableSnapping(): void;
+    /**
+     * enable docking of objects that fit together when objects are snapped in the plan
+     */
+    enableAdvancedDocking(): void;
+    /**
+     * disable docking of objects that fit together when objects are snapped in the plan
+     */
+    disableAdvancedDocking(): void;
+    /**
+     * returns true if interaction with the child components of a configuration object is enabled, and flashes otherwise
+     */
+    showsChildrenOfPlanObject(planElementViewModel: PlanElementViewModel): boolean;
+    /**
+     * enable interaction with child components of configurable objects in the plan
+     */
+    enableShowChildrenOfPlanObject(planElementViewModel: PlanElementViewModel): void;
+    /**
+     * disable interaction with child components of configurable objects in the plan
+     */
+    disableShowChildrenOfPlanObject(planElementViewModel: PlanElementViewModel): void;
+    /**
+     * get the Partlist of certain runtimeID
+     * can be used if partlist of a selected Item is needed
+     * @param id runtimeID of a configurable item
+     * @returns kernelPartlist with processed price, currency and RAL colors
+     */
+    getPartlistOf(id: number): Promise<KernelPartList | null>;
+    /**
+     * Returns the formatted value based on the parameter.unitType
+     *
+     * @param value
+     * @param parameter
+     */
+    formatValueToUnitString(value: number, parameter: KernelParameter): string | number;
+    /**
+     * Draws walls according to the wall definitions
+     * this can be used to create a room on the fly
+     */
+    drawWalls(wallDefinitions: WallDefinition[], interactionOptions?: InteractionOptions): KernelWall[];
+    removeElements(kernelPlanElements: KernelObject[], interactionOptions?: InteractionOptions): Promise<void>;
+    hasWalls(): boolean;
+    enableWallDrawing(): void;
+    disableWallDrawing(): void;
+    /**
+     * returns unit formatter for formatting input und output values in scene
+     */
+    getUnitFormatter(): UnitFormatter;
+    /**
+     * returns manager class to interface with indexedDB storage
+     */
+    getStorage(): IdbManager;
+    /**
+     * returns class containing configurator specific data properties
+     */
+    getConfiguratorContext(): ConfiguratorContext;
+    /**
+     * @returns an object which has all type constants from Roomle Core (C/C++)
+     */
+    get PlannerCoreTypes(): PlannerKernelContainer;
+    /**
+     * set which events are enabled in the scene, for example disable selection of walls and wall nodes
+     * @param sceneEvents
+     */
+    setSceneEvents(sceneEvents: SceneEvents): void;
+    /**
+     * Saves a snapshot of the external objects in the plan without walls and other objects
+     * Also contains the urls to the glb and usdz files
+     * @param parentPlanId id of the current plan, optional
+     * @returns the snapshot of the external objects if there are no external objects it returns null
+     */
+    saveExternalObjectSnapshot(parentPlanId?: RapiId): Promise<Nullable<RapiPlanSnapshotGetDataWith3dUrls>>;
+    private _savePlanSnapshotExternalObjects;
+    saveCurrentPlanSnapshot(parentPlanId?: RapiId, configurationHashOrGroupId?: string | string[]): Promise<RapiPlanSnapshotGetData>;
+    getPlanXmlFrom(plan: RapiPlan | RapiPlanSnapshotGetData): any;
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    createNewSerializedConfiguration(configurationRuntimeId: number): Promise<ConfigurationString>;
+    changeInteriorWallsMaterial(material: BatchPaintMaterial): void;
+    changeExteriorWallsMaterial(material: BatchPaintMaterial): void;
+    changeFloorsMaterial(material: BatchPaintMaterial): void;
+    /**
+     * Returns the wall angle in degrees relative to the camera
+     * @param wall a WallPlanElementViewModel instance
+     */
+    getWallAngleDegrees(wall: WallPlanElementViewModel): number;
+    calcPartsPriceSum(partList: KernelPartList): Promise<KernelPartListPrice>;
+    /**
+     * Swap two plan objects in the scene in the same position for example swap two object variants
+     * @param old this is the current selected plan object
+     * @param idOfNew the RAPI id of the new plan object
+     * returns runtime ID of the new object
+     */
+    swapObject(old: PlanElementViewModel, idOfNew: RapiId): Promise<number>;
+    exportImageFromCamera(filename?: string, shouldWaitForAssets?: boolean): Promise<void>;
+    exportCanvasScreenshot(quality?: number): Promise<string>;
+    /**
+     * Move the current selected element in the 3D space
+     * @param selectedElement this is the current selected plan object
+     * @param position new KernelVector3 position of the current selected element
+     * returns runtime ID of the new object
+     */
+    moveElementPosition(selectedElement: PlanElementViewModel, position: KernelVector3): void;
+    /**
+     * Moves the current multi-selected elements in the 3D space
+     * @param selectedElements this is the current selected plan object
+     * @param position new KernelVector3 position of the current selected element
+     * returns runtime ID of the new object
+     */
+    moveElementsPosition(selectedElements: PlanElementViewModel[], position: KernelVector3): void;
+    /**
+     * Generates a perspective image (slightly from the side) of a plan element by a
+     * given runtime-id and returns it as base64
+     * @param runtimeId runtime-id of the plan element, e.g.: a selected element
+     * @param options PrepareImageOptions
+     */
+    preparePerspectiveImageOf(runtimeId: RuntimeId, options?: PrepareImageOptions): Promise<import('../../common-core/src/common-interfaces').Base64Image>;
+    generateTCExport(planObjectIds?: string[]): Promise<any>;
+    enableMeasurementLineDrawing(): void;
+    disableMeasurementLineDrawing(): void;
+    setObjectToWallMeasurementLength(planElementId: number, measurementId: number, length: number): void;
+    setWallMeasurementLength(measurementId: number, length: number, wallDirection: EMSConstant): void;
+    setMeasurementLineLength(measurementId: number, length: number, wallDirection: string): void;
+    escapeDrawing(cancelDrawing: boolean): void;
+    isCurrentlyDrawing(): boolean;
+    /**
+     * Resolves a shortened URL.
+     *
+     * @param {string} shortUrl - The shortened URL to resolve.
+     * @returns {Promise<string>} - A promise that resolves to the URL.
+     */
+    resolveShortUrl(shortUrl: string): Promise<string>;
+    enableEvents(): void;
+    disableEvents(): void;
+    downloadHomagIxExportPoC(): Promise<any>;
+    configureExternalObjectApi(configurationJson: string | ExternalObjectApiConfiguration): Promise<void>;
+    loadExternalObjectLibrary(libraryJson: string | object): void;
+    loadExternalObjectGroup(groupData: ExternalGroupData, findFreeSpaceInPlan: boolean, verifyArrangement?: boolean, mergedGroups?: string[]): Promise<void>;
+    private _loadExternalObjectGroup;
+    private _loadExternalObjectGroupInConfigurator;
+    private _loadExternalObjectGroupInPlanner;
+    private _loadOrUpdateExternalObjectGroup;
+    private _createSerializedGroupCollection;
+    private _getFaceTheCameraAngle;
+    renderImagesOfExternalObjectGroup(groups: object): Promise<{
+        [key: string]: string;
+    }>;
+    removeExternalObjectGroup(groupId: string, wasMerged?: boolean): Promise<void>;
+    removeExternalObjectRootModule(rootModuleId: string): void;
+    selectExternalObjectGroup(groupId: string): Promise<void>;
+    selectExternalObjectRootModule(rootModuleId: string): Promise<void>;
+    selectExternalObjectSubModule(rootModuleId: string, subModuleId: string): Promise<void>;
+    openOrCloseGeometryOfExternalObject(groupIdOrRootModuleId: string, subModuleId: string | null, open: boolean, animate: boolean): Promise<void>;
+    private _selectKernelComponent;
+    _selectExternalObjectGroup(groupId: string, switchToPlanner: boolean): Promise<void>;
+    _selectExternalObjectModule(rootModuleId: string, subModuleId: string | null, selectPlanObject: boolean, switchToConfigurator: boolean, selectComponent: boolean, highlightSelection: boolean): Promise<void>;
+    private _selectPlanObject;
+    private _getSelectedPlanObjectComponent;
+    getExternalObjectGroups(): Promise<object[]>;
+    /**
+     * @internal
+     * Use this callbacks to hook in your functionality
+     */
+    get globalCallbacks(): GlobalCallback;
+    /**
+     * Handles interaction with the planner kernel, ensuring start and end interaction are tracked.
+     * @param action A function representing the action to perform.
+     * @returns The result of the action, if any.
+     */
+    private _executeWithInteraction;
+    /**
+     * Creates a sloping roof attic on a given wall.
+     * @param wall The wall to add an attic to.
+     * @param kneeHeight Height of the attic knee wall.
+     * @param width Width of the sloping roof.
+     * @param preferredSide The side where the attic should be added.
+     * @returns The newly created attic.
+     */
+    addAtticToWall(wall: KernelWall, kneeHeight: number, width: number, preferredSide?: WallSide): KernelAttic | null;
+    /**
+     * Removes an attic from a wall.
+     * @param attic The attic to be removed.
+     */
+    removeAttic(attic: KernelAttic): void;
+    /**
+     * Set the attic direction from a wall.
+     * @param attic The attic to be removed.
+     */
+    setAtticSide(attic: KernelAttic, side: WallSide): void;
+    /**
+     * Gets the attached attic from a wall.
+     * @param wall The wall to retrieve the attic from.
+     * @returns The first attached attic or null.
+     */
+    getAttachedAttic(wall: KernelWall): KernelAttic | null;
+    /**
+     * Updates the knee height of an attic.
+     * @param attic The attic to update.
+     * @param kneeHeight The new knee height value.
+     */
+    updateAtticKneeHeight(attic: KernelAttic, kneeHeight: number): void;
+    /**
+     * Updates the width of an attic.
+     * @param attic The attic to update.
+     * @param width The new width value.
+     */
+    updateAtticWidth(attic: KernelAttic, width: number): void;
+    /**
+     * Runs a given function with a call to start and end interaction in the planInteractionHandler,
+     *  this should be used when you want to add a history step after interacting with the plan.
+     * @param callback any function.
+     */
+    executeWithInteraction<T>(callback: MaybePromise<T>): Promise<T>;
+    /**
+     * Temporarily stops all input event listeners on the canvas.
+     */
+    pauseInputListeners(): void;
+    /**
+     * Resumes all input event listeners on the canvas.
+     */
+    resumeInputListeners(): void;
+    /**
+     * Enables experimental lights in the scene
+     * @hidden
+     */
+    turnLightsOn(): void;
+    /**
+     * Disables experimental lights in the scene
+     * @hidden
+     */
+    turnLightsOff(): void;
+    getPlanObjectForRuntimeId(runtimeId: number): Promise<PlanElementViewModel | null>;
+    rotateByRuntimeId(runtimeId: number, rotateBy: number): Promise<void>;
+    deleteByRuntimeId(runtimeId: number): Promise<void>;
+    moveByRuntimeId(runtimeId: number, position: KernelVector3): Promise<void>;
+    /**
+     * Undo last action
+     */
+    undo(): Promise<void>;
+    /**
+     * Redo last action
+     * only possible if undo was called before
+     */
+    redo(): Promise<void>;
+}

package/packages/web-sdk/packages/planner-core/src/services/planner-kernel-access.d.ts

@@ -0,0 +1,115 @@
+import { KernelComponent, KernelEnum, RuntimeId, PlanObject as ConfiguratorPlanObject } from '../../../typings/kernel';
+import { default as PlanObjectViewModel } from '../../../common-core/src/view-model/plan-object-view-model';
+import { KernelObject, Plan, PlanElement, PlanInteractionHandler, PlanModelViewHelper, PlanObject } from '../../../typings/planner';
+import { RapiConfiguration, RapiItem, RapiPlanSnapshotPostData } from '../../../typings/rapi-types';
+import { default as RoomlePlannerUiCallback } from '../roomle-planner-ui-callback';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { Position3 } from '../../../common-core/src/common-interfaces';
+import { default as ConfiguratorKernelAccess } from '../../../common-core/src/configurator-kernel-access';
+import { ExternalObjectApiConfiguration } from '../external-object-api';
+import { ExternalObjectGroup, ExternalObjectGroupPosition } from '../external-object-api-callbacks';
+
+export interface PlannerKernelCallbackI {
+    handlerSwitchedPlans(fromPlan: Plan, toPlan: Plan): void;
+    planCompletelyLoaded(plan: Plan): void;
+    beginPlanConstruction(plan: Plan): void;
+    addMesh(planElement: PlanElement, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    addPlanMesh(plan: Plan, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum): void;
+    endPlanConstruction(plan: Plan): void;
+    addPlanObjectToScene(planElementViewModel: PlanObjectViewModel): void;
+    removePlanObjectFromScene(planElementViewModel: PlanObjectViewModel): void;
+    planElementChanged(plan: Plan, planObject: PlanElementViewModel): void;
+    planElementRemoved(element: PlanElement): void;
+    planObjectConfigurationLoaded(plan: Plan, element: PlanElement, success: boolean): void;
+    planObjectConfigurationChanged(plan: Plan, element: PlanElementViewModel): void;
+    planBoundsChanged(): void;
+    planHistoryStateChanged(): void;
+    planCleared(): void;
+    startedDrawing(): void;
+    stoppedDrawing(): void;
+    requestCatalogItem(catalogItemId: string): void;
+}
+export default class PlannerKernelAccess extends ConfiguratorKernelAccess {
+    private _kernelAccessCallback;
+    private _roomlePlannerUiCallback;
+    private _planInteractionHandler;
+    private _plannerKernelCallbackListener;
+    get kernelContainer(): any;
+    constructor(creator: string);
+    protected _loadSuccess(): void;
+    protected _loadError(): void;
+    private _createPlanInteractionHandler;
+    addPlannerListener(listener: PlannerKernelCallbackI): void;
+    removePlannerListener(listener: PlannerKernelCallbackI): void;
+    isReady(): void;
+    protected _setupKernel(): void;
+    get callbacks(): RoomlePlannerUiCallback;
+    get planInteractionHandler(): PlanInteractionHandler;
+    get planModelViewHelper(): PlanModelViewHelper;
+    catalogItemLoaded(catalogItem: RapiItem): void;
+    insertItems(itemList: Array<RapiItem | RapiConfiguration>): Promise<RuntimeId[]>;
+    duplicateItems(planObjects: PlanObject[]): PlanObject[];
+    private _rapiItemToKernelItem;
+    planObjectDeleted(): void;
+    requestPlanObjectDimensions(): void;
+    cleanUpCallbacks(): void;
+    registerCallbacks(): void;
+    planElementRemoved(element: PlanElement): void;
+    handlerSwitchedPlans(fromPlan: Plan, toPlan: Plan): void;
+    planBoundsChanged(): void;
+    planCleared(): void;
+    planCompletelyLoaded(plan: Plan): void;
+    planElement3dMeshChanged(plan: Plan, element: PlanElement): void;
+    private _onStaticItemAdded;
+    private _onConfigurableItemAdded;
+    private _onConfigurableConstructionItemAdded;
+    planElementAdded(plan: Plan, element: PlanElement): Promise<void>;
+    planElementChanged(plan: Plan, element: PlanElement): void;
+    planHistoryStateChanged(): void;
+    planObjectConfigurationCreated(_plan: Plan, _element: PlanObject): void;
+    externalObjectConfigurationChanged(plan: Plan, planObject: PlanObject, configuration: string): void;
+    externalObjectConfigurationLoaded(plan: Plan, planObject: PlanObject, configuration: string): void;
+    externalObjectConfigurationDeleted(plan: Plan, planObject: PlanObject, uniqueId: string): void;
+    externalObjectComponentDeleted(plan: Plan, planObject: PlanObject, remainingGroupOrGroups: ExternalObjectGroup | ExternalObjectGroup[], deletedRootModuleId: string): void;
+    externalObjectConfigurationDuplicated(plan: Plan, planObject: PlanObject, sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): void;
+    externalObjectPlanChanged(plan: Plan, planObject: PlanObject, movedGroup: ExternalObjectGroup): void;
+    externalObjectConfigurationsMerged(plan: Plan, planObject: PlanObject, mergedGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], targetRootModuleId: string): void;
+    externalObjectComponentSplitOff(plan: Plan, planObject: PlanObject, splitGroups: ExternalObjectGroup[]): void;
+    externalObjectArrangementChanged(plan: Plan, planObject: PlanObject, changedGroup: ExternalObjectGroup): void;
+    planObjectConfigurationLoaded(plan: Plan, element: PlanElement, success: boolean): Promise<void>;
+    planObjectConfigurationChanged(plan: Plan, object: PlanObject): void;
+    requestCatalogItem(catalogItemId: string): void;
+    startedDrawing(): void;
+    stoppedDrawing(): void;
+    updateMesh2d(): void;
+    beginConstruction(): void;
+    addMesh(planElement: PlanElement, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    endConstruction(): void;
+    beginPlanConstruction(plan: Plan): void;
+    addPlanMesh(plan: Plan, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum): void;
+    endPlanConstruction(plan: Plan): void;
+    createPlanFromObject(rapiElement: RapiItem | RapiConfiguration, position?: Position3, rotation?: number): Plan;
+    addPlanObjectFromItem(rapiElement: RapiItem | RapiConfiguration, position?: Position3, rotation?: number): Promise<RuntimeId>;
+    coupleReferences(jsObject: any, coreReference: KernelObject): void;
+    private _decoupleReferences;
+    isConstructionPlanElement(planElement: PlanElement): boolean;
+    planObjectSelectionChanged(configurationRuntimeId: number, elementRuntimeId: number): void;
+    protected _componentSelectionChanged(planObject: ConfiguratorPlanObject, component: KernelComponent, planComponentSelection: boolean): void;
+    protected _externalObjectParameterChanged(objectOrComponentId: number, parameterKey: string, value: string): void;
+    protected _externalObjectConfigurationChanged(objectId: number, configuration: string): void;
+    protected _externalObjectConfigurationLoaded(objectId: number, configuration: string): void;
+    protected _externalObjectConfigurationDeleted(groupId: string): void;
+    protected _externalObjectComponentDeleted(remainingGroupOrGroups: ExternalObjectGroup | ExternalObjectGroup[], deletedRootModuleId: string): void;
+    _externalObjectConfigurationDuplicated(sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): void;
+    _externalObjectPlanChanged(movedGroup: ExternalObjectGroup): void;
+    _externalObjectConfigurationsMerged(mergedGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], targetRootModuleId: string): void;
+    _externalObjectComponentSplitOff(splitGroups: ExternalObjectGroup[]): void;
+    _externalObjectArrangementChanged(changedGroup: ExternalObjectGroup): void;
+    planSnapshotCreated(planSnapshot: RapiPlanSnapshotPostData): void;
+    requestDeleteComponents(componentIds: number[]): void;
+    requestDeleteComponent(componentId: number): void;
+    requestDeletePlanComponent(componentId: number): void;
+    private _externalPlanComponentDeleted;
+    dockExternalObjectComponent(parentId: number, parentDockId: number, childId: number, childDockId: number): void;
+    configureExternalObjectApi(externalObjectSettings?: ExternalObjectApiConfiguration): Promise<void>;
+}

package/packages/web-sdk/packages/planner-core/src/utils/dimensions-helper.d.ts

@@ -0,0 +1,13 @@
+import { Group } from 'three';
+import { default as UnitFormatter } from '../../../configurator-core/src/services/unit-formatter';
+import { default as RoomlePlannerUiCallback } from '../roomle-planner-ui-callback';
+import { default as PlannerSceneEventHandler } from '../webgl/planner-scene-event-handler';
+import { default as PlanViewModel } from '../view-model/plan-view-model';
+import { default as CameraBehaviour } from '../../../common-core/src/cameracontrol/camera-behaviour';
+import { default as DomHelper } from '../../../common-core/src/utils/dom-helper';
+
+export declare function sendWallDimensions(domHelper: DomHelper, cameraBehaviour: CameraBehaviour, roomlePlannerUiCallback: RoomlePlannerUiCallback, plannerSceneEventHandler: PlannerSceneEventHandler, viewModel: PlanViewModel, unitFormatter: UnitFormatter, debugSpheres: {
+    wallPoints: Group;
+    constructionElementsPoints: Group;
+    floorPoints: Group;
+}, isFixedWalls?: boolean, isDebug?: boolean): void;

package/packages/web-sdk/packages/planner-core/src/utils/global-definitions.d.ts

@@ -0,0 +1,14 @@
+import { default as RoomleGLBViewer } from '../../../glb-viewer-core/src/roomle-glb-viewer';
+import { default as RoomleConfigurator } from '../../../configurator-core/src/roomle-configurator';
+import { default as RoomlePlanner } from '../roomle-planner';
+import { PluginName } from '../../../configurator-core/src/utils/plugin-types';
+
+declare global {
+    interface Window {
+        RoomleCore: any;
+        ConfiguratorKernel: any;
+        RoomlePlanner: RoomlePlanner | RoomlePlanner<readonly PluginName[]>;
+        RoomleGLBViewer: RoomleGLBViewer;
+        RoomleConfigurator: RoomleConfigurator;
+    }
+}

package/packages/web-sdk/packages/planner-core/src/utils/injectables.d.ts

@@ -0,0 +1,3 @@
+import { DependencyInjectionAssignment } from '../../../common-core/src/di/container';
+
+export declare const INJECTABLES: DependencyInjectionAssignment[];

package/packages/web-sdk/packages/planner-core/src/utils/map-to-ui-plan-objects.d.ts

@@ -0,0 +1,5 @@
+import { UiPlanObject } from '../../../typings/kernel';
+import { default as PlannerKernelAccess } from '../services/planner-kernel-access';
+import { default as RapiAccess } from '../../../common-core/src/rapi-access';
+
+export declare const mapToUiPlanObjects: (planObjects: any, plannerKernelAccess: PlannerKernelAccess, rapiAccess: RapiAccess) => Promise<UiPlanObject[]>;