@roomle/web-sdk 2.91.0-alpha.1 → 2.91.0-alpha.3

package/lib/definitions/packages/planner-core/src/roomle-planner-ui-callback.d.ts

@@ -0,0 +1,229 @@
+import { UiCallback } from '../../common-core/src/utils/ui-callback';
+import type { CancelSelectionReasons, PlanInteractionHandler, PlanObjectPosition } from '../../typings/planner';
+import type { ConfiguratorKernelClass, UiPlanObject } from '../../typings/kernel';
+import type { PlannerKernelContainer } from '../../typings/planner-kernel-container';
+import type { CAMERA_TYPE } from '../../common-core/src/cameracontrol/camera-type';
+import type { SELECTION_MODE } from '../../configurator-core/src/utils/selection-handler';
+import type { RapiComponent, RapiConfiguration, RapiItem } from '../../typings/rapi-types';
+import type { WallDimension, WallDimensionTransferable } from './view-model/wall-plan-element-view-model';
+import type PlanElementViewModel from '../../common-core/src/view-model/plan-element-view-model';
+import type { Enumify } from '../../common-core/src/types';
+import type { CallbackObjectType } from './utils/planner-scene-manager';
+import type { ObjectMeasurementsTransferable } from '../../common-core/src/view-model/plan-object-view-model';
+import type { MeasurementLineDimension, MeasurementLineDimensionTransferable } from './view-model/measurement-line-plan-element-view-model';
+import type { ConstructionMeasurementsTransferable } from './utils/measurements';
+import type { FloorAreaDataTransferable } from './view-model/floor-plan-element-view-model';
+import { type BASE_CONTEXT } from '../../common-core/src/main';
+import type { ExternalObjectGroup, ExternalObjectGroupAndModules, ExternalObjectGroupPosition, ExternalObjectUiCallback } from './external-object-api-callbacks';
+export interface SelectionPayload {
+    item?: RapiItem;
+    configuration?: RapiConfiguration;
+    component?: RapiComponent;
+    configurationRuntimeId?: number;
+    planElementId?: number;
+    wall?: WallDimension;
+    measurementLine?: MeasurementLineDimension;
+    staticItemRuntimeId?: number;
+}
+export declare const PLAN_ELEMENT_CHANGE_TYPES: {
+    readonly ADDED: "added";
+    readonly CHANGED: "changed";
+    readonly REMOVED: "removed";
+};
+export default class RoomlePlannerUiCallback extends UiCallback implements ExternalObjectUiCallback {
+    constructor(creator: string);
+    onItemsLoaded: () => void;
+    onCameraChanged: (type: Enumify<typeof CAMERA_TYPE>) => void;
+    onCameraIdle: () => void;
+    onTotalFloorAreaChanged: (totalFloorArea: number) => void;
+    onPlanInteractionHandlerCreated: (planInteractionHandler: PlanInteractionHandler) => void;
+    /**
+     * is called when the planner kernel is ready. It returns the container and the instance
+     * @param kernelContainer
+     * @param kernelInstance
+     */
+    onPlannerKernelIsReady: (kernelContainer: PlannerKernelContainer) => void;
+    /**
+     * is called when the configurator kernel is ready. It returns the container and the instance
+     * @param kernelContainer
+     * @param kernelInstance
+     */
+    onConfiguratorKernelIsReady: (kernelContainer: PlannerKernelContainer, kernelInstance: ConfiguratorKernelClass) => void;
+    /**
+     * When an item has been selected
+     * @param selectionMode
+     * @param objectType currently only static items and configurations are supported
+     * @param payload returns the data which is available immediately (sync), currently this is catalogItemId and/or configurationRuntimeId
+     * @param payloadPromise this promise resolves when the data of an object is fetched
+     * @param planElementViewModel the plan element view model used internally, WARNING: this is a reference, use with caution
+     */
+    onSelectionChange: (selectionMode: SELECTION_MODE, objectType: CallbackObjectType, payload: SelectionPayload, payloadPromise: Promise<SelectionPayload>, planElementViewModel: PlanElementViewModel) => void;
+    /**
+     * When an item selection has been canceled
+     */
+    onSelectionCancel: (reason: CancelSelectionReasons) => void;
+    /**
+     * When something in the plan has changed
+     */
+    onPlanChanged: () => void;
+    /**
+     * When an element in the plan has been added, removed or changed
+     * null if changed, added or removed object is not a item or configuration, such as a wall or construction element
+     */
+    onPlanElementChanged: (changeType: Enumify<typeof PLAN_ELEMENT_CHANGE_TYPES>, changedObject: UiPlanObject) => void;
+    /**
+     * When the plan has been completely loaded
+     */
+    onCompletelyLoaded: () => void;
+    /**
+     * When rotation mode has been canceled
+     */
+    onRotationCancel: () => void;
+    /**
+     * gets called if history changes
+     * @param undo true if undo is possible
+     * @param redo true if redo is possible
+     */
+    onHistoryChange: (undo: boolean, redo: boolean) => void;
+    /**
+     * This function gets called when the camera is no longer moving
+     * and the position of the wall dimensions can be calculated
+     * @param wallDimensions
+     */
+    onUpdateWallDimensions: (wallDimensions: WallDimensionTransferable[]) => void;
+    /**
+     * This function gets called when the camera is no longer moving
+     * and the position of the measurement line dimensions can be calculated
+     * @param measurementLineDimensions
+     */
+    onUpdateMeasurementLineDimensions: (measurementLineDimensions: MeasurementLineDimensionTransferable[]) => void;
+    /**
+     * This function gets called when the camera has stopped moving,
+     * allowing for the calculation of the dimensions of construction elements' positions.
+     * It is also called when an element is selected or dragged on the plan.
+     * @param constructionMeasurementsMeasurements The measurements of construction elements.
+     */
+    onUpdateConstructionElementsMeasurements: (constructionMeasurementsMeasurements: ConstructionMeasurementsTransferable) => void;
+    /**
+     * This function gets called when the camera has stopped moving,
+     * allowing for the calculation of the dimensions of plan element position.
+     * It is also called when the element is selected or dragged on the plan.
+     * @param objectMeasurements The measurements of plan element related to the walls plus object dimensions.
+     */
+    onUpdateObjectMeasurements: (objectMeasurements: ObjectMeasurementsTransferable) => void;
+    /**
+     * This function gets called when the camera is moving and thus the wall dimensions should not be shown
+     */
+    disableWallDimensions: () => void;
+    /**
+     * This function gets called when the camera is no longer moving
+     * it delivers all the positions of items in the plan normalized to the screen coordinates
+     * @param planObjectPositions
+     */
+    onUpdatePlanObjectPositions: (planObjectPositions: PlanObjectPosition[]) => void;
+    onDrawCancel: () => void;
+    /**
+     * This updates if the user started/stopped drawing a wall
+     * @param currentlyDrawing
+     */
+    onDrawingStateChanged: (currentlyDrawing: boolean) => void;
+    onHandlerSwitchedPlans: () => void;
+    /**
+     * This function gets called when a movable element begins to be dragged
+     */
+    onDragElementStart: () => void;
+    /**
+     * This function gets called when a movable element was being dragged before and is now released
+     */
+    onDragElementEnd: () => void;
+    /**
+     * This function gets called when a selectable element has been clicked on.
+     * An equivalent function for component clicks is onClickComponent in the configurator-ui-callback.ts
+     * @param planElement PlanElementViewModel instance of the clicked element
+     */
+    onClickElement: (planElement: PlanElementViewModel) => void;
+    onMultiSelectionChange: (selectedElements: PlanElementViewModel[]) => void;
+    onSelectionModeChange: (mode: SELECTION_MODE) => void;
+    onMeasurementLineStateChange: (isActive: boolean) => void;
+    /**
+     * Callback invoked when the dimensions of rooms are updated.
+     * It receives an array containing the computed areas of all rooms and related data, which may be used to display or process the area information of each room.
+     * @param floorAreasData An array of objects, each representing the area and related data for each room within the floor plan.
+     */
+    onFloorPlanAreasUpdated: (floorAreasData: FloorAreaDataTransferable[]) => void;
+    /**
+     * Callback invoked when the selection of a component has been canceled.
+     */
+    onComponentSelectionCancel: () => void;
+    /**
+     * Callback invoked when a plan snapshot is saved.
+     * @param planId The ID of the plan snapshot.
+     */
+    onPlanSnapshotCreated: (planId: string) => void;
+    /**
+     * Callback invoked when an object is started to be configured.
+     */
+    onStartConfiguring: () => Promise<void>;
+    /**
+     * Callback invoked when configuration is finished.
+     */
+    onBackToPlanner: () => Promise<void>;
+    /**
+     * This callback is invoked when the context of the planner changes
+     * For example when it switches from planner to configurator, or from planner to viewer
+     * @param context
+     */
+    onContextChanged: (context: BASE_CONTEXT) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onMergeExternalObjectGroup: (targetGroup: ExternalObjectGroupAndModules, sourceGroupId: string) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onSplitExternalObjectGroup: (originalGroup: ExternalObjectGroupAndModules, newGroupedRootModules: ExternalObjectGroupAndModules | ExternalObjectGroupAndModules[]) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onDeleteExternalObjectGroup: (groupIdToDelete: string) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onDeleteExternalObjectRootModule: (_remainingGroup: ExternalObjectGroupAndModules, _rootModuleIdToDelete: string, _splitOffGroups?: ExternalObjectGroupAndModules[]) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onDeleteExternalObjectSubModule: (rootModuleId: string, subModuleIdToDelete: string) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onDuplicateExternalObjectGroup: (sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onMovedExternalObjectGroup: (group: ExternalObjectGroup) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onExternalObjectEnvironmentChanged: (affectedGroupIds: string[]) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onExternalObjectGroupChanged: (stringifiedGroupData: string) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onExternalObjectGroupLoaded: (stringifiedGroupData: string) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onExternalObjectAttributeChanged: (rootModuleId: string, subModuleId: string | null, attributeId: string, value: string) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onExternalObjectModuleSelected: (groupId: string, rootModuleId: string | null, subModuleId: string | null) => void;
+    /**
+     * documented in interface ExternalObjectUiCallback
+     */
+    onExternalObjectSelectionCancel: () => void;
+}

package/lib/definitions/packages/planner-core/src/roomle-planner.d.ts

@@ -0,0 +1,381 @@
+import type RoomlePlannerUiCallback from './roomle-planner-ui-callback';
+import type { GlbViewer } from '../../glb-viewer-core/src/glb-viewer';
+import { type ExternalEmbeddable, type GlobalAPI, type KernelUtilityForUi, type RubensAPI } from '../../common-core/src/main';
+import type Main from '../../common-core/src/main';
+import type { Configurator } from '../../configurator-core/src/configurator';
+import type { GlobalInitDataDefinition, InitDataDefinition } from '../../common-core/src/utils/shims';
+import type { ConfigurationString, RapiConfiguration, RapiId, RapiItem, RapiPlan, RapiPlanSnapshotGetData } from '../../typings/rapi-types';
+import type { Context } from '../../common-core/src/di/context';
+import type { CancelSelectionReasons, KernelObject, KernelWall, PlanInteractionHandler, PlanModelViewHelper, PlanOverview } from '../../typings/planner';
+import type { KernelAccessCallbackI } from '../../common-core/src/kernel-access-callback';
+import type InitData from '../../common-core/src/utils/init-data';
+import type { CanvasOffset, Position3 } from '../../common-core/src/common-interfaces';
+import type { PrepareImageOptions } from '../../common-core/src/webgl/image-renderer';
+import type { KernelParameter, KernelPartList, KernelPartListPrice, KernelVector3, RuntimeId, UiPlanObject } from '../../typings/kernel';
+import type UnitFormatter from '../../configurator-core/src/services/unit-formatter';
+import RoomleConfigurator from '../../configurator-core/src/roomle-configurator';
+import type { EMSConstant, PlannerKernelContainer } from '../../typings/planner-kernel-container';
+import type { Scene } from 'three';
+import type { CameraParameter } from '../../common-core/src/cameracontrol/camera-control';
+import type PlanElementViewModel from '../../common-core/src/view-model/plan-element-view-model';
+import type WallPlanElementViewModel from './view-model/wall-plan-element-view-model';
+import type ConfiguratorContext from '../../common-core/src/webgl/configurator-context';
+import type { PlanObject } from '../../typings/planner';
+import type IdbManager from '../../common-core/src/services/idb-manager';
+import type { ExternalObjectAPI, ExternalObjectApiConfiguration } from './external-object-api';
+import type { GlobalCallback } from '../../common-core/src/services/global-callback';
+export type ID_TYPE = 'rml_id' | 'tc_id' | 'rml_serialized' | 'tc_serialized';
+export interface RoomlePlannerCallback {
+    switchToConfigurator: () => Promise<Configurator>;
+    switchToViewer: () => Promise<GlbViewer>;
+    cancelSelection: () => 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 default class RoomlePlanner implements KernelAccessCallbackI, RoomlePlannerCallback, GlobalAPI, Context, KernelUtilityForUi, ExternalEmbeddable<RoomlePlannerUiCallback>, RubensAPI, ExternalObjectAPI {
+    _creator_: string;
+    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);
+    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>;
+    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;
+    startViewing(): void;
+    startConfiguring(): void;
+    /**
+     * select an object in the scene based on its runtime id
+     * @param runtimeId
+     */
+    selectPlanObjectById(runtimeId: RuntimeId): Promise<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);
+    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, position?: Position3, rotation?: number): Promise<RuntimeId>;
+    insertItemList(ids: RapiId[]): 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>): 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;
+    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;
+    saveCurrentPlanSnapshot(parentPlanId?: RapiId, configurationHashOrGroupId?: 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;
+    configureExternalObjectApi(configurationJson: string | ExternalObjectApiConfiguration): Promise<void>;
+    loadExternalObjectLibrary(libraryJson: string | object): void;
+    loadExternalObjectGroup(groupJson: string | object, findFreeSpaceInPlan: boolean): Promise<void>;
+    private _loadExternalObjectGroup;
+    removeExternalObjectGroup(groupId: string): 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): Promise<void>;
+    /**
+     * @internal
+     * Use this callbacks to hook in your functionality
+     */
+    get globalCallbacks(): GlobalCallback;
+}