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

package/packages/web-sdk/packages/common-core/src/cameracontrol/camera-control-3d.d.ts

@@ -0,0 +1,83 @@
+import { default as InputManager } from '../input/input-manager';
+import { CameraParameter, default as CameraControl } from './camera-control';
+import { PerspectiveOffsetCamera } from '../webgl/roomle-component-factory';
+import { Box3, PerspectiveCamera, Vector3 } from 'three';
+
+export declare class ZoomChangeEvent {
+    minZoom: boolean;
+    maxZoom: boolean;
+    constructor(minZoom?: boolean, maxZoom?: boolean);
+}
+export declare const enum STATE {
+    NONE = 0,
+    ORBIT = 1,
+    MOVE = 2
+}
+export declare const ROTATION_SPEED = 1;
+export declare const DISTANCE_FACTOR = 2.725;
+export declare const MAX_POLAR_ANGLE = 85;
+export default class CameraControl3D extends CameraControl {
+    protected _camera: PerspectiveOffsetCamera;
+    private _bounds;
+    private _scale;
+    private _state;
+    private _zoomSpeed;
+    minDistance: number;
+    maxDistance: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    private _objectRotation;
+    private _lookAtSide;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    private _zoomDistance;
+    private _orbitPosition;
+    private _userInteraction;
+    private _currentZoomHash;
+    private _maxZoomedIn;
+    private _maxZoomedOut;
+    private _panningEnabled;
+    private _targetPositionIsPanned;
+    constructor(creator: string, inputManager: InputManager, initialCameraParameters?: CameraParameter, camera?: PerspectiveOffsetCamera);
+    protected _getCamera(): PerspectiveCamera;
+    getCamera(): PerspectiveOffsetCamera;
+    private _initCamera;
+    setObjectRotation(objectRotation: number, lookAtSide?: number): void;
+    getObjectRotation(): number;
+    updateCamera(): void;
+    animateCamera(delta: number): boolean;
+    protected _initInputListener(): void;
+    private _panTargetPosition;
+    private _pan;
+    private _move;
+    checkBoundsAndPlaceCamera(boundingBox: Box3, reset?: boolean): void;
+    adjustToBoundsWithoutChangingDistance(boundingBox: Box3): void;
+    zoomToFitBounds(boundingBox: Box3, reset?: boolean): void;
+    updateToBounds(boundingBox: Box3, isPreview: boolean, changeCamera?: boolean, target?: Vector3): void;
+    protected _checkZoomDistance(boundingBox: Box3, idealDistance: number): void;
+    protected _setDistanceAndRangesBasedOnBounds(bounds: Vector3, updateDistance?: boolean): number;
+    private _getIdealDistance;
+    private _getOffset;
+    private _getMargin;
+    reset(bounds: Box3, target?: Vector3, yaw?: number, pitch?: number, animate?: boolean): void;
+    updateDistanceAndRangesBasedOnBounds(boundingBox: Box3): void;
+    updateAndReset(boundingBox: Box3, animate?: boolean): Promise<void>;
+    protected _update(overrideTarget?: Vector3, ignoreChecks?: boolean, keepVariables?: boolean): void;
+    private _zoomChanged;
+    zoomTo(cameraParameters: CameraParameter): Promise<void>;
+    private _getCameraSphere;
+    zoomIn(value?: number): void;
+    zoomOut(value?: number): void;
+    clear(): void;
+    /**
+     * Move camera based on provided camera parameters
+     * - Uses center when target is not set
+     * - Uses ideal distance when no distance is provided
+     * - For other properties it used current camera parameters if not provided
+     * @param cameraParameter
+     */
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    enablePanning(): void;
+    disablePanning(): void;
+    getKernelZoomFactor(): number;
+}

package/packages/web-sdk/packages/common-core/src/cameracontrol/camera-control.d.ts

@@ -0,0 +1,127 @@
+import { Listener, default as EventDispatcher } from '../../../configurator-core/src/utils/event-dispatcher';
+import { default as DomHelper } from '../utils/dom-helper';
+import { InputEvent, default as InputManager } from '../input/input-manager';
+import { Context } from '../di/context';
+import { default as InitData } from '../utils/init-data';
+import { Box3, Object3D, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
+import { default as GlobalInitData } from '../utils/global-init-data';
+import { Position2 } from '../common-interfaces';
+
+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,// general event when camera moves
+    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, initialCameraParameters?: CameraParameter);
+    getCamera(): PerspectiveOrOrthographicCamera;
+    protected abstract _getCamera(): PerspectiveOrOrthographicCamera;
+    abstract updateCamera(): void;
+    protected abstract _initInputListener(): void;
+    private _addInputListeners;
+    private _removeInputListeners;
+    setUp(): void;
+    cleanUp(): void;
+    animateCamera(delta: number): boolean;
+    protected getDebugCameraPosition(): CameraParameter;
+    protected saveDebugCameraPosition(): void;
+    protected _dispatchCameraIdle(): void;
+    protected _tweenCameraParameter(start: CameraParameter, end: CameraParameter, ignoreChecks?: boolean): Promise<void>;
+    protected _setCameraNear(): void;
+    getCurrentCameraParameters(): CameraParameter;
+    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): Promise<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, keepVariables?: boolean | undefined): void;
+    abstract getKernelZoomFactor(): number;
+}
+export {};

package/packages/web-sdk/packages/common-core/src/cameracontrol/camera-type.d.ts

@@ -0,0 +1,8 @@
+import { 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/packages/web-sdk/packages/common-core/src/cameracontrol/configurator-camera-behaviour.d.ts

@@ -0,0 +1,22 @@
+import { default as CameraBehaviour } from './camera-behaviour';
+import { default as CameraControl3D } from './camera-control-3d';
+import { CameraParameter } from './camera-control';
+import { 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, cameraParameters: CameraParameter, rotation?: number, lookAtSide?: number): Promise<void>;
+}

package/packages/web-sdk/packages/common-core/src/cameracontrol/glb-viewer-camera-behaviour.d.ts

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

package/packages/web-sdk/packages/common-core/src/cameracontrol/material-viewer-camera-behaviour.d.ts

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

package/packages/web-sdk/packages/common-core/src/cameracontrol/planner-2d-camera-behaviour.d.ts

@@ -0,0 +1,18 @@
+import { default as CameraControl2D } from './camera-control-2d';
+import { default as PlannerCameraBehaviour } from './planner-camera-behaviour';
+import { Box3 } from 'three';
+import { CameraParameter } from './camera-control';
+
+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, _startCameraParams: CameraParameter, _endCameraParams: CameraParameter): void;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}

package/packages/web-sdk/packages/common-core/src/cameracontrol/planner-3d-camera-behaviour.d.ts

@@ -0,0 +1,21 @@
+import { default as CameraControl3D } from './camera-control-3d';
+import { default as PlannerCameraBehaviour } from './planner-camera-behaviour';
+import { Box3 } from 'three';
+import { 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, startCameraParams: CameraParameter, endCameraParams: CameraParameter): Promise<void>;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+    externalApiMoveCamera(cameraParameter: CameraParameter): Promise<void>;
+}

package/packages/web-sdk/packages/common-core/src/cameracontrol/planner-camera-behaviour.d.ts

@@ -0,0 +1,16 @@
+import { Box3 } from 'three';
+import { default as CameraBehaviour } from './camera-behaviour';
+import { default as CameraControl, CameraParameter } from './camera-control';
+
+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, startCameraParams: CameraParameter, endCameraParams: CameraParameter): void;
+    abstract resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}

package/packages/web-sdk/packages/common-core/src/cameracontrol/planner-fp-camera-behaviour.d.ts

@@ -0,0 +1,18 @@
+import { default as CameraControlFirstPerson } from '../../../planner-core/src/camera-control/camera-control-first-person';
+import { default as PlannerCameraBehaviour } from './planner-camera-behaviour';
+import { Box3 } from 'three';
+import { CameraParameter } from './camera-control';
+
+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, _startCameraParams: CameraParameter, _endCameraParams: CameraParameter): void;
+    resetCameraOnEnableWallDrawing(_bounds: Box3): void;
+    resetCameraOnSwitchToFirstPerson(): void;
+}

package/packages/web-sdk/packages/common-core/src/common-configurator-kernel-callback.d.ts

@@ -0,0 +1,20 @@
+import { KernelComponent, KernelLightSourceAttributes, 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;
+    Editor3dRemoveLightSource(runtimeComponentId: number, lightSourceId: number): void;
+    Editor3dAddLightSource(runtimeComponentId: number, lightSourceId: number, lightSourceAttributes: KernelLightSourceAttributes): void;
+    Editor3dChangedLightSource(runtimeComponentId: number, lightSourceId: number, lightSourceAttributes: KernelLightSourceAttributes): void;
+}

package/packages/web-sdk/packages/common-core/src/common-interfaces.d.ts

@@ -0,0 +1,38 @@
+import { 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/packages/web-sdk/packages/common-core/src/configurator-kernel-access.d.ts

@@ -0,0 +1,147 @@
+import { default as ConfiguratorContext } from './webgl/configurator-context';
+import { DebugClient, KernelDockPairToLine, KernelDockPairToPoint, EmscriptenString, KernelComponent, KernelParameter, KernelParameterGroup, KernelVector3, PlanObject, VariantsList } from '../../typings/kernel';
+import { default as CommonKernelAccess, KERNEL_TYPE } from './services/common-kernel-access';
+import { ArticleNumber, ConfigurationHash, ConfigurationString, RapiId, RapiPrice } from '../../typings/rapi-types';
+import { CommonConfiguratorKernelCallbackI } from './common-configurator-kernel-callback';
+import { PromiseQueue } from './utils/promise-queue';
+import { default as InitData } from './utils/init-data';
+import { ExternalObjectApiConfiguration } from '../../planner-core/src/external-object-api';
+
+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: KernelDockPairToPoint[], previewId: number): void;
+    Editor3dSetPreviewLineAssociations(dockLines: KernelDockPairToLine[], 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, level: number, 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, level: number, 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: KernelDockPairToPoint[], previewId: number): void;
+    Editor3dSetPreviewLineAssociations(dockLines: KernelDockPairToLine[], 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;
+    isExternalObjectOrComponent(planObjectOrComponentId: number): boolean;
+    listOfVariants: (_componentId: RapiId, _list: VariantsList) => void;
+    listOfVariantsError(dbId: RapiId, error: string): void;
+    addDebugClient(debugClient: DebugClient): void;
+    configureExternalObjectApi(_externalObjectSetting?: ExternalObjectApiConfiguration): void;
+}

package/packages/web-sdk/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/packages/web-sdk/packages/common-core/src/di/context.d.ts

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

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

@@ -0,0 +1,9 @@
+import { default as Container } from './container';
+import { Group } from '@tweenjs/tween.js';
+
+declare global {
+    interface Window {
+        __RML__DI__: Container;
+        TWEEN: Group;
+    }
+}

package/packages/web-sdk/packages/common-core/src/di/inject.d.ts

@@ -0,0 +1,2 @@
+
+export default function inject(target: any, propertyName: string): void;

package/packages/web-sdk/packages/common-core/src/di/injectables.d.ts

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

package/packages/web-sdk/packages/common-core/src/di/roomle-dependency-injection.d.ts

@@ -0,0 +1,10 @@
+import { 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/packages/web-sdk/packages/common-core/src/environment/background-environment.d.ts

@@ -0,0 +1,16 @@
+import { default as Environment } from './environment';
+import { 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;
+}