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

package/lib/definitions/packages/common-core/src/cameracontrol/camera-control.d.ts

@@ -0,0 +1,128 @@
+import type { Listener } from '../../../configurator-core/src/utils/event-dispatcher';
+import EventDispatcher from '../../../configurator-core/src/utils/event-dispatcher';
+import type DomHelper from '../utils/dom-helper';
+import type { InputEvent } from '../input/input-manager';
+import type InputManager from '../input/input-manager';
+import type { Context } from '../di/context';
+import type { Position2 } from '../common-interfaces';
+import type InitData from '../utils/init-data';
+import type { Box3, Object3D, OrthographicCamera } from 'three';
+import { PerspectiveCamera, Vector3 } from 'three';
+import type GlobalInitData from '../utils/global-init-data';
+export declare const enum CAMERA_EVENT {
+    ORBIT_START = 0,
+    ORBIT_MOVE = 1,
+    ORBIT_END = 2,
+    ZOOM_IN = 3,
+    ZOOM_OUT = 4,
+    ZOOM_CHANGE = 5,
+    KEYBOARD_PRESSED = 6,
+    MOVING = 7,
+    IDLE = 8
+}
+export interface CameraParameter {
+    /**
+     * Yaw of the camera in radians
+     */
+    yaw?: number;
+    /**
+     * pitch of the camera in radians
+     */
+    pitch?: number;
+    /**
+     * Distance to the target position in meters
+     */
+    distance?: number;
+    /**
+     * X position where the camera should look at (in meters)
+     * targetX: 0 -> is in the middle of the object
+     */
+    targetX?: number;
+    /**
+     * Y position where the camera should look at (in meters)
+     * targetY: 0 -> is in on the bottom of the object (ground level)
+     */
+    targetY?: number;
+    /**
+     * Z position where the camera should look at (in meters)
+     * targetZ: 0 -> is in the middle of the object
+     */
+    targetZ?: number;
+    /**
+     * Field of view of the camera (in degree)
+     */
+    fov?: number;
+    /**
+     * Near clipping plane of the camera
+     */
+    near?: number;
+    /**
+     * Far clipping plane of the camera
+     */
+    far?: number;
+    /**
+     * Should this camera movement block other camera movements?
+     */
+    blockOtherTweens?: boolean;
+}
+export declare const INITIAL_YAW = -30;
+export declare const INITIAL_PITCH = 10;
+export declare const INITIAL_CAMERA_DISTANCE = -1;
+export declare const DEBUG_CAMERA_POSITION = "debug_camera_position";
+type PerspectiveOrOrthographicCamera = PerspectiveCamera | OrthographicCamera;
+export default abstract class CameraControl extends EventDispatcher<any> implements Context {
+    _creator_: string;
+    protected _domHelper: DomHelper;
+    protected _initData: InitData;
+    protected _globalInitData: GlobalInitData;
+    protected _width: number;
+    protected _height: number;
+    protected _boundingBox: Box3;
+    protected _cameraPosition: Vector3;
+    protected _targetPosition: Vector3;
+    protected _tweenEnd: CameraParameter;
+    private _stateSaved;
+    private _cameraStandingStill;
+    protected _pitch: number;
+    protected _yaw: number;
+    protected _distance: number;
+    protected _locked: boolean;
+    private _inputManager;
+    protected _inputListeners: Array<Listener<InputEvent>>;
+    protected _lerpEnabled: boolean;
+    constructor(creator: string, inputManager: InputManager, initialCameraPosition?: Vector3);
+    getCamera(): PerspectiveOrOrthographicCamera;
+    protected abstract _getCamera(): PerspectiveOrOrthographicCamera;
+    abstract updateCamera(): void;
+    protected abstract _initInputListener(): void;
+    private _addInputListeners;
+    private _removeInputListeners;
+    cleanUp(): void;
+    animateCamera(delta: number): boolean;
+    protected getDebugCameraPosition(): CameraParameter;
+    protected saveDebugCameraPosition(): void;
+    private _dispatchCameraIdle;
+    protected _tweenCameraParameter(start: CameraParameter, end: CameraParameter, ignoreChecks?: boolean): Promise<void>;
+    protected _setCameraNear(): void;
+    getCurrentCameraParameters(): CameraParameter;
+    protected _setCurrentCameraParameters(cameraParameters: CameraParameter): void;
+    protected _rotateHorizontal(angle: number): void;
+    protected _rotateVertical(angle: number): void;
+    saveState(override: boolean): CameraParameter;
+    resetToState(): void;
+    setToState(start: CameraParameter, state: CameraParameter): void;
+    hasSavedState(): boolean;
+    lock(): void;
+    unlock(): void;
+    isLocked(): boolean;
+    getTargetPosition(): Vector3;
+    protected _saveYawAndPitch(): void;
+    getInputPosition(position: Position2): Vector3;
+    addLightContainer(container: Object3D): void;
+    checkNearFarDistance(point: Vector3): void;
+    setBounds(boundingBox: Box3): void;
+    get domHelper(): DomHelper;
+    protected abstract _update(overrideTarget?: Vector3, ignoreChecks?: boolean | undefined): void;
+    abstract getKernelZoomFactor(): number;
+}
+export {};

package/lib/definitions/packages/common-core/src/cameracontrol/camera-type.d.ts

@@ -0,0 +1,7 @@
+import type { Enumify } from '../types';
+export declare const CAMERA_TYPE: {
+    readonly CAMERA_2D: "2D";
+    readonly CAMERA_3D: "3D";
+    readonly CAMERA_FP: "FP";
+};
+export declare const sanitizedCameraMode: (mode: Enumify<typeof CAMERA_TYPE>) => Enumify<typeof CAMERA_TYPE>;

package/lib/definitions/packages/common-core/src/cameracontrol/configurator-camera-behaviour.d.ts

@@ -0,0 +1,21 @@
+import CameraBehaviour from './camera-behaviour';
+import type CameraControl3D from './camera-control-3d';
+import type { CameraParameter } from './camera-control';
+import { type Box3 } from 'three';
+export default class ConfiguratorCameraBehaviour extends CameraBehaviour {
+    get cameraControl(): CameraControl3D;
+    resetCameraOnSceneClear(): void;
+    externalApiMoveCamera(cameraParameter: CameraParameter): Promise<void>;
+    externalApiZoomIn(value?: number): void;
+    externalApiZoomOut(value?: number): void;
+    externalApiResetCameraPosition(boundingBox: Box3): void;
+    disablePanningOnShiftRelease(): void;
+    enablePanningOnShiftClick(): void;
+    resetCameraToStartOnConfigurationLoaded(boundingBox: Box3): void;
+    updateBoundsOnPlanObjectUpdated(boundingBox: Box3): void;
+    updateBoundsOnCancelDockings(boundingBox: Box3): void;
+    zoomToComponentOnConsecutiveClick(cameraParameters: CameraParameter): Promise<void>;
+    resetCameraToStateOnCancelSelection(): void;
+    zoomToFitBoundsAfterUserInitiatedPreviews(boundingBox: Box3): void;
+    resetCameraOnStartConfiguring(boundingBox: Box3, rotation?: number): void;
+}

package/lib/definitions/packages/common-core/src/cameracontrol/glb-viewer-camera-behaviour.d.ts

@@ -0,0 +1,9 @@
+import CameraBehaviour from './camera-behaviour';
+import type AdjustableCameraControl3D from '../../../glb-viewer-core/src/camera-control/adjustable-camera-control-3d';
+import { type Box3 } from 'three';
+import type { CameraParameter } from './camera-control';
+export default class GlbViewerCameraBehaviour extends CameraBehaviour {
+    get cameraControl(): AdjustableCameraControl3D;
+    updateCameraOnItemLoaded(bounds: Box3): void;
+    externalApiMoveCamera(cameraParameter: CameraParameter): Promise<void>;
+}

package/lib/definitions/packages/common-core/src/cameracontrol/material-viewer-camera-behaviour.d.ts

@@ -0,0 +1,5 @@
+import CameraBehaviour from './camera-behaviour';
+import type AdjustableCameraControl3D from '../../../glb-viewer-core/src/camera-control/adjustable-camera-control-3d';
+export default class MaterialViewerCameraBehaviour extends CameraBehaviour {
+    get cameraControl(): AdjustableCameraControl3D;
+}

package/lib/definitions/packages/common-core/src/cameracontrol/planner-2d-camera-behaviour.d.ts

@@ -0,0 +1,16 @@
+import type CameraControl2D from './camera-control-2d';
+import PlannerCameraBehaviour from './planner-camera-behaviour';
+import { type Box3 } from 'three';
+export default class Planner2dCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControl2D;
+    resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    externalApiResetCameraPosition(bounds: Box3): void;
+    resetCameraOnSwitchTo2d(bounds: Box3): void;
+    updateCameraOnDrawWalls(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(_bounds: Box3): void;
+    updateCameraOnBackToPlanner(bounds: Box3): void;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}

package/lib/definitions/packages/common-core/src/cameracontrol/planner-3d-camera-behaviour.d.ts

@@ -0,0 +1,20 @@
+import type CameraControl3D from './camera-control-3d';
+import PlannerCameraBehaviour from './planner-camera-behaviour';
+import { type Box3 } from 'three';
+import type { CameraParameter } from './camera-control';
+export default class Planner3dCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControl3D;
+    resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    externalApiResetCameraPosition(bounds: Box3): void;
+    resetCameraOnSwitchTo3d(bounds: Box3): void;
+    disablePanningOnShiftRelease(): void;
+    enablePanningOnShiftClick(): void;
+    updateCameraOnDrawWalls(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(bounds: Box3): void;
+    updateCameraOnBackToPlanner(bounds: Box3): void;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+    externalApiMoveCamera(cameraParameter: CameraParameter): Promise<void>;
+}

package/lib/definitions/packages/common-core/src/cameracontrol/planner-camera-behaviour.d.ts

@@ -0,0 +1,15 @@
+import type CameraControl from './camera-control';
+import { type Box3 } from 'three';
+import CameraBehaviour from './camera-behaviour';
+export default abstract class PlannerCameraBehaviour extends CameraBehaviour {
+    get cameraControl(): CameraControl;
+    abstract resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    abstract externalApiResetCameraPosition(bounds: Box3): void;
+    abstract updateCameraOnDrawWalls(bounds: Box3): void;
+    abstract updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    abstract updateCameraOnPlanElementInsertedInsideCurrentCameraView(bounds: Box3): void;
+    abstract updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    abstract updateCameraOnPlanElementRemoved(bounds: Box3): void;
+    abstract updateCameraOnBackToPlanner(bounds: Box3): void;
+    abstract resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}

package/lib/definitions/packages/common-core/src/cameracontrol/planner-fp-camera-behaviour.d.ts

@@ -0,0 +1,15 @@
+import type CameraControlFirstPerson from '../../../planner-core/src/camera-control/camera-control-first-person';
+import PlannerCameraBehaviour from './planner-camera-behaviour';
+import { type Box3 } from 'three';
+export default class PlannerFpCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControlFirstPerson;
+    resetCameraOnPlanCompletelyLoaded(_bounds: Box3): void;
+    externalApiResetCameraPosition(_bounds: Box3): void;
+    updateCameraOnDrawWalls(_bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(_bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(_bounds: Box3): void;
+    updateCameraOnBackToPlanner(_bounds: Box3): void;
+    resetCameraOnEnableWallDrawing(_bounds: Box3): void;
+}

package/lib/definitions/packages/common-core/src/common-configurator-kernel-callback.d.ts

@@ -0,0 +1,16 @@
+import type { KernelComponent, KernelMeshAttributes, KernelMeshBuffer, KernelVector3 } from '../../typings/kernel';
+export interface CommonConfiguratorKernelCallbackI {
+    Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentObjectRuntimeId: number): void;
+    Editor3dAddMesh(runtimeComponentId: number, meshId: number, geometryName: string, environmentGeometry: boolean, meshAttributes: KernelMeshAttributes, meshBuffer: KernelMeshBuffer): void;
+    Editor3ChangedMesh(runtimeComponentId: number, meshId: number, geometryName: string, meshAttributes: KernelMeshAttributes): void;
+    Editor3dRemoveMesh(runtimeComponentId: number, meshId: number): void;
+    componentMetaUpdated(kernelComponent: KernelComponent): void;
+    componentConfigurationUpdated(runtimeComponentId: number, geometryChanged: boolean): void;
+    Editor3dBeginConstruction(componentId: number, isDeltaUpdate: boolean): void;
+    Editor3dEndConstruction(id: number): void;
+    Editor3dComponentDocked(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    Editor3dGeometryReady(id: number): void;
+    Editor3dGeometryNotReady(id: number): void;
+    componentDeleted(componentId: number): void;
+    sceneCleared(): void;
+}

package/lib/definitions/packages/common-core/src/common-interfaces.d.ts

@@ -0,0 +1,37 @@
+import type { Base64String } from '../../typings/rapi-types';
+/**
+ * Used to set the camera offset of the canvas, for example this is useful
+ * if you have UI elements which should not overlap with the product you
+ * want to show
+ *
+ * Example:
+ * ```
+ * {
+ *     left: 0.1, // 10% offset from left
+ *     top: 0.2, // 20% offset from top
+ *     right: 0.85, // 15% offset from right
+ *     bottom: 0.95 // 5% offset from bottom
+ * }
+ * ```
+ */
+export interface CanvasOffset {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface Position2 {
+    x: number;
+    y: number;
+}
+export interface Position3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Base64Image {
+    image: Base64String;
+    width: number;
+    height: number;
+    blob: Blob;
+}

package/lib/definitions/packages/common-core/src/configurator-kernel-access.d.ts

@@ -0,0 +1,145 @@
+import type ConfiguratorContext from './webgl/configurator-context';
+import type { DebugClient } from '../../typings/kernel';
+import { type EmscriptenString, type KernelComponent, type KernelParameter, type KernelParameterGroup, type KernelVector3, type PlanObject, type VariantsList } from '../../typings/kernel';
+import CommonKernelAccess, { KERNEL_TYPE } from './services/common-kernel-access';
+import type { ArticleNumber, ConfigurationHash, ConfigurationString, RapiId, RapiPrice } from '../../typings/rapi-types';
+import type { CommonConfiguratorKernelCallbackI } from './common-configurator-kernel-callback';
+import { PromiseQueue } from './utils/promise-queue';
+import type InitData from './utils/init-data';
+export interface ConfiguratorKernelCallbackI extends CommonConfiguratorKernelCallbackI {
+    planObjectCreated(conversationId: number, planObjectId: number): void;
+    planObjectUpdated(planObject: PlanObject, pendingDocking: boolean): void;
+    planObjectConfigurationUpdated(planObjectId: number, configuration: ConfigurationString, hash: string, pendingDocking: boolean): void;
+    configurationLoaded(conversationId: number, objectId: number, componentId: number, hash: string, errors: any): void;
+    Editor3dAddDockPreview(componentId: number, previewId: number): void;
+    Editor3dSetPreviewPointAssociations(dockPairs: any, previewId: number): void;
+    Editor3dSetPreviewLineAssociations(dockLines: any, previewId: number): void;
+    Editor3dPreviewConstructionDone(componentId: number, objectId: number): void;
+    Editor3dPlanObjectConstructionDone(planObjectId: number): void;
+    Editor3dComponentDocked(componentId: number, isRootComponent: boolean, parentObjectRuntimeId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    finishParameterChange(resolve: () => void, reject: () => void): void;
+    updateAnimationParameters(elementId: number | number[], parameters: KernelParameter[]): void;
+    changeAnimationValue(elementId: number, parameterKey: string, value: string, applyToChildren: boolean, animate: boolean): void;
+}
+export default class ConfiguratorKernelAccess extends CommonKernelAccess {
+    private _memoryManager;
+    private _configuratorKernelAccessCallback;
+    protected _initData: InitData;
+    private _configuratorHistory;
+    externalMeshQueue: PromiseQueue<void>;
+    muteKernelCallbacks: boolean;
+    constructor(creator: string);
+    init(kernelType: KERNEL_TYPE): void;
+    protected _loadSuccess(): void;
+    protected _loadError(): void;
+    selectedComponent(componentId: number): void;
+    uiRequestConfiguration(objectId: number): void;
+    getComponentParameters(componentId: number): KernelParameter[];
+    getPlanObjectParameters(objectId: number): KernelParameter[];
+    private _addAnimationParameters;
+    private _updateComponentParameters;
+    selectionChange(componentId: number, isRoot: boolean): void;
+    protected _componentSelectionChanged(_planObject: PlanObject, _component: KernelComponent, _planComponentSelection: boolean): void;
+    protected _externalObjectParameterChanged(_objectOrComponentId: number, _parameterKey: string, _value: string): void;
+    multiSelectionChange(runtimeComponentIds: number[], rootComponentId: number): void;
+    private _updateCommonComponentDependencies;
+    private _updateComponentChildren;
+    private _updateComponentDependencies;
+    private _updatePlanObjectParameters;
+    private _enableRootComponentParametersAsGlobal;
+    private _updatePlanObjectChildren;
+    updatePlanObjectDependencies(planObjectId: number): void;
+    private _updateConfigurationHasChildren;
+    dockComponent(parentId: number, parentDockId: number, childId: number, childDockId: number): void;
+    dockExternalObjectComponent(_parentId: number, _parentDockId: number, _childId: number, _childDockId: number): void;
+    changeUseOfHDGeometry(context: ConfiguratorContext, useHDGeometry: boolean): void;
+    webGlPreviewDockings(context: ConfiguratorContext, dragIn: boolean): void;
+    webGlPreviewDockingsForKernelObjects(context: ConfiguratorContext, dragIn: boolean): void;
+    webGlPreviewDockingsForExternalObjects(context: ConfiguratorContext, _dragIn: boolean): void;
+    previewDockingsWithDrag(componentId: number, planObjectId: number): void;
+    cancelDocking(componentId: number): void;
+    loadConfiguration(configuration: ConfigurationString): void;
+    changeCommonComponentParameter(componentIds: number[], parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
+    changeComponentParameter(componentId: number, parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
+    changePlanObjectParameter(planObjectId: number, parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
+    updateAnimationParameters(elementId: number | number[], parameters: KernelParameter[]): void;
+    changeAnimationValue(elementId: number, parameterKey: string, value: string, applyToChildren: boolean, animate: boolean): void;
+    private _finishParameterChange;
+    requestDeleteComponents(componentIds: number[]): void;
+    requestDeletePlanComponent(componentId: number): void;
+    loadComponentIntoKernel(component: string, componentId: RapiId): void;
+    requestPartListAndUpdatePricesOfParts(hash?: ConfigurationHash, _prices?: Map<ArticleNumber, RapiPrice>): Promise<void>;
+    requestSync(conversationId: number, planObjectId: number): void;
+    getGlobalParameters(planObjectId: number, rootComponentParametersAsGlobal: boolean): Promise<KernelParameter[]>;
+    getPartList(): Promise<unknown>;
+    getConfigurationHash(context: ConfiguratorContext): Promise<ConfigurationHash>;
+    requestPlanObjectConstruction(objectId: number): void;
+    isReady(): void;
+    protected _setupKernel(): void;
+    onLoadComponentError(error: Error, id: RapiId): void;
+    configurationLoaded(conversationId: number, objectId: number, componentId: number, hash: string, errors: EmscriptenString[], _valid: boolean): void;
+    componentDefinitionLoaded(conversationId: number, componentId: number): void;
+    componentDefinitionLoadingError(conversationId: number, errorMessage: string): void;
+    configurationLoadingError(_runtimeId: number, errors?: EmscriptenString[]): void;
+    componentConfigurationUpdated(componentId: number, geometryChanged: boolean): void;
+    setActiveGroupInView(group: string): void;
+    setActiveGroupInViewForPlanObject(group: string, runtimeId?: number): void;
+    componentParameters(): void;
+    requestComponentDimensions(): void;
+    planObjectCreated(conversationId: number, planObjectId: number): void;
+    planObjectUpdated(planObjectId: number, pendingDocking: boolean): void;
+    planObjectConfigurationUpdated(planObjectId: number, configuration: ConfigurationString, hash: string, _rootPlanComponentId: number, _valid: boolean, pendingDocking: boolean): Promise<void>;
+    private _onBoundsUpdate;
+    planObjectDeleted(): void;
+    requestPlanObjectDimensions(): void;
+    requestExternalMesh(requestedMeshes: Array<{
+        meshId: string;
+        quality: number;
+    }>): Promise<void>;
+    Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentId: number): void;
+    Editor3dPlanObjectConstructionDone(planObjectId: number): void;
+    Editor3dBeginGroup(): void;
+    Editor3dEndGroup(): void;
+    Editor3dSetMaterial(): void;
+    Editor3dLoadMaterial(): void;
+    Editor3dAddDockPreview(componentId: number, previewId: number): void;
+    Editor3dSetPreviewPointAssociations(dockPairs: any, previewId: number): void;
+    Editor3dSetPreviewLineAssociations(dockLines: any, previewId: number): void;
+    Editor3dPreviewConstructionDone(componentId: number, objectId: number): void;
+    Editor3dTranslateBy(): void;
+    Editor3dRotateBy(): void;
+    Editor3dRotateAround(): void;
+    Editor3dAddCube(): void;
+    Editor3dAddCubeUVMod(): void;
+    Editor3dAddSphere(): void;
+    Editor3dAddSphereUVMod(): void;
+    Editor3dAddRectangle(): void;
+    Editor3dAddRectangleUVMod(): void;
+    Editor3dAddMeshUVMod(): void;
+    Editor3dAddMeshUVCoord(): void;
+    Editor3dAddCylinder(): void;
+    Editor3dAddCylinderUVMod(): void;
+    Editor3dAddPrism(): void;
+    Editor3dAddPrismUVMod(): void;
+    Editor3dAddFittingPoint(): void;
+    Editor3dAddFittingLine(): void;
+    Editor3dSelectObject(): void;
+    Editor3dCopy(): void;
+    Editor3dUpdatePlanObjectPosition(): void;
+    Editor3dUpdatePlanObjectRotation(): void;
+    Editor3dUpdatePlanObjectTransform(): void;
+    Editor3dUpdatePlanComponentPosition(): void;
+    Editor3dUpdatePlanComponentRotation(): void;
+    Editor3dUpdatePlanComponentTransform(): void;
+    getRuntimeComponentIdOfRootComponent(planObjectId: number): number;
+    getRuntimeComponentId(runtimeComponentId: number): string;
+    getParameterGroups(): KernelParameterGroup[];
+    resume(): void;
+    getSerializedConfiguration(objectId: number): string;
+    createNewSerializedConfiguration(configurationRuntimeId: number): string;
+    getCurrentConfigurationHash(planObjectId: number): ConfigurationHash;
+    listOfVariants: (_componentId: RapiId, _list: VariantsList) => void;
+    listOfVariantsError(dbId: RapiId, error: string): void;
+    addDebugClient(debugClient: DebugClient): void;
+}
+export declare function logKernelCall(target: any, propertyName: string): void;

package/lib/definitions/packages/common-core/src/di/container.d.ts

@@ -0,0 +1,20 @@
+export declare const enum DI_TYPE {
+    GLOBAL = 0,
+    CONTEXT = 1,
+    NEW = 2
+}
+export default class Container {
+    private _context;
+    private _lookups;
+    private _singletons;
+    getContext(name: string): string;
+    addDependencyInjectionAssignments(injections: DependencyInjectionAssignment[]): void;
+    lookup<T>(specifier: string, context?: string): T;
+    cleanUp(context?: string): void;
+}
+export declare class DependencyInjectionAssignment {
+    className: string;
+    classDefinition: any;
+    type: DI_TYPE;
+    constructor(className: string, classDefinition: any, type?: DI_TYPE);
+}

package/lib/definitions/packages/common-core/src/di/context.d.ts

@@ -0,0 +1,3 @@
+export interface Context {
+    _creator_: string;
+}

package/lib/definitions/packages/common-core/src/di/global-definitions.d.ts

@@ -0,0 +1,6 @@
+import type Container from './container';
+declare global {
+    interface Window {
+        __RML__DI__: Container;
+    }
+}

package/lib/definitions/packages/common-core/src/di/inject.d.ts

@@ -0,0 +1,2 @@
+import './global-definitions';
+export default function inject(target: any, propertyName: string): void;

package/lib/definitions/packages/common-core/src/di/injectables.d.ts

@@ -0,0 +1,2 @@
+import { DependencyInjectionAssignment } from './container';
+export declare const INJECTABLES: DependencyInjectionAssignment[];

package/lib/definitions/packages/common-core/src/di/roomle-dependency-injection.d.ts

@@ -0,0 +1,9 @@
+import type { DependencyInjectionAssignment } from './container';
+export default class RoomleDependencyInjection {
+    private static _ensureContainer;
+    static setup(injectables: DependencyInjectionAssignment[]): void;
+    static lookup<T>(specifier: string, context?: string): T;
+    static getContext(name: string): string;
+    static cleanUp(context?: string): void;
+    static addToContainer(injectables: DependencyInjectionAssignment[]): void;
+}

package/lib/definitions/packages/common-core/src/environment/background-environment.d.ts

@@ -0,0 +1,15 @@
+import Environment from './environment';
+import type { Color, Scene } from 'three';
+export default class BackgroundEnvironment extends Environment {
+    private readonly _oldBackground;
+    private readonly _color;
+    private readonly _canvas;
+    private readonly _style;
+    constructor(scene: Scene, oldEnvironment?: Environment, color?: Color, canvas?: HTMLCanvasElement, url?: string);
+    needsBounds(): boolean;
+    needsCamera(): boolean;
+    needsRotation(): boolean;
+    addToScene(): void;
+    removeFromScene(): void;
+    showGUI(): void;
+}

package/lib/definitions/packages/common-core/src/environment/dynamic-environment-setting-loader.d.ts

@@ -0,0 +1,82 @@
+import type Environment from './environment';
+import type { SceneSettings } from '../scene-settings-loader';
+import type { Scene } from 'three';
+export interface EnvironmentDetails {
+    imageUrl: string;
+    color: string;
+    material: string;
+    fog: boolean;
+}
+/**
+ * Dynamic environment settings can be used to select which environment is used.
+
+ Example
+
+ ```
+ {
+"environment": {
+    "type": "image",
+    "details": {
+      "imageUrl": "https://storage.googleapis.com/roomle-static/test/bg/bg_grey.jpg"
+    }
+  }
+}
+ ```
+
+ Available environment types
+
+ "type": "floor"/"image"/"color"/"gltf"
+
+ Type floor
+
+ ```
+ "details": {
+    "material": "roomle_floor:DresdenEiche"
+ }
+ ```
+
+ Currently available floor materials, for others get in touch with us
+
+ ```
+ roomle_floor:DresdenEiche
+ roomle_floor:Ibiza
+ roomle_floor:Palma
+ roomle_floor:Elba
+ roomle_floor:Manacor
+ roomle_floor:KernEiche
+ roomle_floor:KieferScandic
+ roomle_floor:EicheHabsburg
+ roomle_floor:FuldaKiefer
+ roomle_floor:Ashton
+ roomle_floor:EicheLondon
+ ```
+
+ Type image
+
+ ```
+ "details": {
+    "imageUrl": "https://storage.googleapis.com/roomle-static/test/bg/bg_grey_shine.jpg"
+}
+ ```
+
+ Type color
+
+ ```
+ "details": {
+    "color": "#ff0000"
+}
+ ```
+
+ Type gltf
+
+ Type gltf does not have any details yet
+ */
+export interface EnvironmentSetting {
+    type: string;
+    details: EnvironmentDetails;
+}
+export default class DynamicEnvironmentSettingLoader {
+    private _rapiAccess;
+    parse(scene: Scene, canvas: HTMLCanvasElement, oldEnvironment: Environment, json: string, maxAnisotropy: number): Promise<Environment>;
+    load(scene: Scene, canvas: HTMLCanvasElement, oldEnvironment: Environment, jsonObject: SceneSettings, maxAnisotropy: number): Promise<Environment>;
+}

package/lib/definitions/packages/common-core/src/environment/environment.d.ts

@@ -0,0 +1,15 @@
+import type { PerspectiveCamera, Scene, Vector3 } from 'three';
+export default abstract class Environment {
+    protected _scene: Scene;
+    protected _bounds: Vector3;
+    constructor(scene: Scene, oldEnvironment?: Environment);
+    abstract needsBounds(): boolean;
+    abstract needsCamera(): boolean;
+    updateCamera(_camera: PerspectiveCamera): void;
+    abstract addToScene(): void;
+    abstract removeFromScene(): void;
+    abstract showGUI(updateCallback: () => void): void;
+    reload(): void;
+    updateBounds(bounds: Vector3, _force?: boolean): void;
+    cleanUp(): void;
+}

package/lib/definitions/packages/common-core/src/environment/ground-projected-environment.d.ts

@@ -0,0 +1,14 @@
+import Environment from './environment';
+import type { Scene, Texture } from 'three';
+export default class GroundProjectedEnvironment extends Environment {
+    private _environmentTexture;
+    private _skybox;
+    constructor(scene: Scene, oldEnvironment: Environment, texture: Texture);
+    updateEnvironmentTexture(texture: Texture): void;
+    needsBounds(): boolean;
+    needsCamera(): boolean;
+    needsRotation(): boolean;
+    addToScene(): void;
+    removeFromScene(): void;
+    showGUI(updateCallback: () => void): void;
+}

package/lib/definitions/packages/common-core/src/error-handler.d.ts

@@ -0,0 +1,18 @@
+export declare const enum ERROR_CODES {
+    OFFLINE = 0,
+    GENERIC_RAPI_ERROR = 1,
+    CONTENT_PROBLEM = 2
+}
+type ErrorListener = (...args: any[]) => void;
+export declare class RoomleError extends Error {
+    rmlErrorCode: ERROR_CODES;
+}
+export default class ErrorHandler {
+    private _listeners;
+    private _subscribe;
+    subscribe(errorCode: ERROR_CODES, callback: ErrorListener): void;
+    dispatch(errorCode: ERROR_CODES, args?: any[]): void;
+    unsubscribe(errorCode: ERROR_CODES, callback: ErrorListener): void;
+    softReject(resolve: (...args: any[]) => any, errorMessage: string, errorCode: ERROR_CODES): any;
+}
+export {};