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

package/lib/definitions/packages/configurator-core/src/utils/raycast-helper.d.ts

@@ -0,0 +1,83 @@
+import type InputManager from '../../../common-core/src/input/input-manager';
+import { type InputEvent } from '../../../common-core/src/input/input-manager';
+import type { SceneEventInfo } from '../webgl/configurator-scene-event-handler';
+import EventDispatcher from './event-dispatcher';
+import { type RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import { type Camera, type Layers, type Object3D, type Scene } from 'three';
+import { Vector3 } from 'three';
+export declare const enum OBJECT_EVENT {
+    CLICK = "select",
+    DOUBLE_CLICK = "double_click",
+    HOVER_ON = "hover_on",
+    HOVER_OFF = "hover_off",
+    HOVER_MOVE = "hover_move",
+    DRAG_START = "drag_start",
+    DRAG = "drag",
+    DRAG_END = "drag_end",
+    ROTATE = "rotate"
+}
+export declare const RAYCAST_PRIORITY: {
+    readonly RAYCASTER_FLOOR: 0.8;
+    readonly FLOOR: 0.9;
+    readonly WALL: 0.95;
+    readonly DEFAULT: 1;
+    readonly CONSTRUCTION: 1;
+    readonly COMPONENT: 2;
+    readonly PREVIEW: 3;
+    readonly PREVIEW_LINE: 4;
+};
+export declare const enum INTERSECTION_MODE {
+    PLANNER = 0,
+    CONFIGURATOR = 1
+}
+export declare const enum RAYCAST_EVENT {
+    CLICK_OUTSIDE = 0
+}
+export default class RaycastHelper extends EventDispatcher<SceneEventInfo> {
+    private _mode;
+    private _object;
+    private _camera;
+    private _inputManager;
+    private _raycaster;
+    private _bounds;
+    private _rootComponentId;
+    private _rootComponentPosition;
+    private _backgroundScene;
+    private _currentHover;
+    private _currentDrag;
+    private _currentRotate;
+    private _offset;
+    private _planeFront;
+    private _planeBottom;
+    private _planeSide;
+    private _lastMoveCheck;
+    private _onWallSnapping;
+    constructor(object: Object3D, camera: Camera, generalInput: InputManager, mode?: INTERSECTION_MODE);
+    setLayers(layers: Layers): void;
+    getLayers(): Layers;
+    private _addInputListeners;
+    private _findCandidate;
+    private _findSelection;
+    private _findHover;
+    private _intersection;
+    private _intersect;
+    private _findObjectWithHandler;
+    private _onDragStart;
+    private _onDrag;
+    private _getIntersectionPosition;
+    private _getDistanceToCamera;
+    private _onDragEnd;
+    private _onRotate;
+    private _positionPlanes;
+    private _calculateOffset;
+    update(bounds: Vector3, rootComponentPosition: Vector3, backgroundScene: Scene): void;
+    clear(): void;
+    enableDragIn(mesh: RoomleEventedMesh): void;
+    setRootComponentId(rootComponentId: number): void;
+    setCamera(camera: Camera): void;
+    setObject(object: Object3D): void;
+    setMode(mode: INTERSECTION_MODE): void;
+    intersectMouseOnScene(event: InputEvent): import("../../../typings/kernel").KernelVector3;
+    enableOnWallSnapping(): void;
+    disableOnWallSnapping(): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/selection-handler.d.ts

@@ -0,0 +1,33 @@
+import type { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import EventDispatcher from './event-dispatcher';
+export declare const enum SELECTION_MODE {
+    STANDARD = "standard",
+    MULTISELECT = "multiselect"
+}
+export declare const enum SELECTION_EVENT {
+    SELECT_COMPONENT = 0,
+    DESELECT_COMPONENT = 1
+}
+export declare class SelectionHandlerEvent {
+    component: RoomleComponent;
+    resetCamera: boolean;
+    consecutive: boolean;
+    constructor(data: {
+        component?: RoomleComponent;
+        resetCamera?: boolean;
+        consecutive?: boolean;
+    });
+}
+export default class SelectionHandler extends EventDispatcher<SelectionHandlerEvent> {
+    private _selectionMode;
+    protected _selectedComponents: Map<number, RoomleComponent>;
+    check(component: RoomleComponent): void;
+    cancelSelection(): void;
+    private _checkStandard;
+    private _checkMulti;
+    setSelectionMode(mode: SELECTION_MODE): void;
+    getSelectionMode(): SELECTION_MODE;
+    hasSelection(): boolean;
+    getSelectedRuntimeComponentIds(): number[];
+    isSelected(component: RoomleComponent): boolean;
+}

package/lib/definitions/packages/configurator-core/src/utils/sort-helper.d.ts

@@ -0,0 +1,3 @@
+import type { RoomleSortable } from '../../../typings/rapi-types';
+export declare const sortBySort: (a: RoomleSortable, b: RoomleSortable) => number;
+export declare const sortByString: (aLabel: string, bLabel: string) => number;

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/animation-helper.d.ts

@@ -0,0 +1 @@
+export declare function waitForTween(): Promise<unknown>;

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/async-test-helper.d.ts

@@ -0,0 +1 @@
+export default function (test: (reject: (error: Error) => void) => void): Promise<unknown>;

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/fetch-helper.d.ts

@@ -0,0 +1,7 @@
+import type { RapiJsonBox } from '../../../../typings/rapi-types';
+export default class FetchHelper {
+    static setup(): void;
+    static setResponseJson(json: RapiJsonBox): void;
+    static getRequestedUrls(): string[];
+    static teardown(): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/globals-helper.d.ts

@@ -0,0 +1,4 @@
+export default class GlobalsHelper {
+    static setup(): void;
+    static teardown(): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/image-diff.d.ts

@@ -0,0 +1,10 @@
+import type { Configurator } from '../../configurator';
+import type { Base64String } from '../../../../typings/rapi-types';
+export interface ImageDiffResult {
+    getImageDataUrl: () => Base64String;
+    rawMisMatchPercentage: number;
+}
+export default class ImageDiff {
+    private static _compare;
+    static compare(app: Configurator, image1Url: string, image2Url: string): Promise<ImageDiffResult>;
+}

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/mock-data/materials.d.ts

@@ -0,0 +1,11 @@
+import type { RapiJsonBox, RapiMaterial } from '../../../../../typings/rapi-types';
+interface RapiMaterialBox extends RapiJsonBox {
+    materials: RapiMaterial[];
+}
+export default class MaterialsFactory {
+    static create(amount: number): RapiJsonBox;
+    static createByIds(ids: string[] | number[]): RapiMaterialBox;
+    static idsToUrl(ids: string[] | number[]): string;
+    static generateMaxIds(): string[];
+}
+export {};

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/mock-data/partlists.d.ts

@@ -0,0 +1,2 @@
+export declare const PARTLIST_USM_DRAG_TEST: any;
+export declare const PARTLIST_USM_PREVIEWS: any;

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/preview-helper.d.ts

@@ -0,0 +1,4 @@
+export default class PreviewHelper {
+    static setup(): HTMLDivElement;
+    static teardown(): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/ui-mock.d.ts

@@ -0,0 +1,17 @@
+import type { UiPossibleChild, KernelParameter } from '../../../../typings/kernel';
+import type { RapiId } from '../../../../typings/rapi-types';
+export default class UIMock {
+    private _element;
+    private _possibleChildren;
+    private _parameters;
+    private _possibleChildrenWaiter;
+    private _parametersWaiter;
+    constructor(element: HTMLElement);
+    private _onUpdateParameters;
+    private _onUpdatePossibleChildren;
+    initAndLoadId(id: RapiId): Promise<void>;
+    possibleChildrenUpdate(): Promise<void>;
+    parametersUpdate(): Promise<void>;
+    getParameterByKey(id: string): KernelParameter;
+    getPossibleChild(id: RapiId): UiPossibleChild;
+}

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function cleanRapiUrl(url: string): string;
+export declare const spyOnModuleMethod: (jest: any, module: any, methodName: string) => any;
+export declare const makeModuleSpyable: (jest: any, module: any) => any;
+export declare const removePrivateProperties: (array: any[]) => any[];

package/lib/definitions/packages/configurator-core/src/utils/test-helpers/webgl-mock.d.ts

@@ -0,0 +1,10 @@
+export default class WebGlMock {
+    requestDeleteComponentCalled: boolean;
+    context: {
+        planObjectBounds: {};
+        rootComponentId: number;
+    };
+    cancelSelection(): void;
+    requestDeleteComponent(): void;
+    onRemovePreviews(): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/text-with-background.d.ts

@@ -0,0 +1,23 @@
+import { Object3D, Vector3 } from 'three';
+import type { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+export default class TextWithBackground extends Object3D {
+    private _cacheHolder;
+    private _position;
+    private _label;
+    private _parameters;
+    private _text;
+    private _textGeometry;
+    private _plane;
+    topDown: boolean;
+    private _planeMaterial;
+    private _textMaterial;
+    private _cameraPosition;
+    constructor(font: Font);
+    private _initMaterials;
+    private _init;
+    update(position: Vector3, label: string, cameraPosition: Vector3): void;
+    private _update;
+    private _updateText;
+    private _getXSign;
+    dispose(): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/ui-intersection-helper.d.ts

@@ -0,0 +1,24 @@
+import EventDispatcher from './event-dispatcher';
+import type { CanvasOffset } from '../../../common-core/src/common-interfaces';
+import type { PerspectiveCamera } from 'three';
+import { Vector3 } from 'three';
+export type UIIntersection = 'left' | 'top' | 'right' | 'bottom';
+export type UIIntersections = UIIntersection[];
+export declare const enum UI_INTERSECTION_EVENT {
+    CHANGE = 0
+}
+export default class UiIntersectionHelper extends EventDispatcher<UIIntersections> {
+    private _uiIntersectionMask;
+    private _camera;
+    private _boundingBox;
+    private _clientWidth;
+    private _clientHeight;
+    private _boxVertices;
+    private _offset;
+    floorEnvironment: boolean;
+    constructor(camera: PerspectiveCamera);
+    updateToBounds(bounds: Vector3, clientWidth: number, clientHeight: number): void;
+    set canvasOffset(offset: CanvasOffset);
+    calculateUIIntersection(): void;
+    private _checkPaddings;
+}

package/lib/definitions/packages/configurator-core/src/webgl/banana-for-scale.d.ts

@@ -0,0 +1,13 @@
+import { ScenePluginDefaultImplementation } from './plugin-system';
+import type { Box3, Scene } from 'three';
+export default class BananaForScale extends ScenePluginDefaultImplementation {
+    private _scene;
+    private _bounds;
+    private _banana;
+    private _staticItemLoader;
+    setScene(scene: Scene): void;
+    updateBounds(bounds: Box3): void;
+    clearScene(scene: Scene, uiScene: Scene): void;
+    addToScene(): void;
+    removeFromScene(): void;
+}

package/lib/definitions/packages/configurator-core/src/webgl/configurator-mesh-generator.d.ts

@@ -0,0 +1,11 @@
+import MeshGenerator from '../../../common-core/src/webgl/mesh-generator';
+import type { KernelEnum } from '../../../typings/kernel';
+import type { RapiMaterial } from '../../../typings/rapi-types';
+import type { Material, Mesh, MeshPhysicalMaterial } from 'three';
+export default class ConfiguratorMeshGenerator extends MeshGenerator {
+    constructor(creator: string);
+    generateMesh(runtimeComponentId: number, geometryId: string, materialId: string, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
+    setMaterial(mesh: Mesh, materialId: string, _type?: KernelEnum, materialAttributes?: Record<string, string>): Promise<void>;
+    loadMaterial(materialId: string, width?: number, height?: number): Promise<Material>;
+    loadTextures(rapiMaterial: RapiMaterial, material: MeshPhysicalMaterial, width?: number, height?: number): Promise<void>;
+}

package/lib/definitions/packages/configurator-core/src/webgl/configurator-scene-event-handler.d.ts

@@ -0,0 +1,93 @@
+import type { PreviewComponent, PreviewLineComponent, RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type InputManager from '../../../common-core/src/input/input-manager';
+import { INPUT_EVENT_TYPE } from '../../../common-core/src/input/input-manager';
+import { SELECTION_MODE } from '../utils/selection-handler';
+import SceneEventHandler from '../../../common-core/src/webgl/scene-event-handler';
+import { RAYCAST_PRIORITY } from '../utils/raycast-helper';
+import type { Object3D, PerspectiveCamera, Scene } from 'three';
+import { type Vector3 } from 'three';
+import { type Camera } from 'three';
+import { type Enumify } from '../../../common-core/src/types';
+export declare const enum SCENE_EVENT {
+    INTERACTION = 0,
+    HOVER_ON = 1,
+    HOVER_OFF = 2,
+    CLICK_OUTSIDE = 3,
+    DRAG_START = 4,
+    DRAG_MOVE = 5,
+    DRAG_END = 6,
+    CLICK_PREVIEW = 7,
+    SELECT_COMPONENT = 8,
+    DESELECT_COMPONENT = 9
+}
+export declare class SceneEventInfo {
+    component: RoomleComponent;
+    preview: PreviewComponent;
+    resetCamera: boolean;
+    consecutive: boolean;
+    type: INPUT_EVENT_TYPE;
+    forceRender: boolean;
+    constructor(data: {
+        component?: RoomleComponent;
+        preview?: PreviewComponent;
+        resetCamera?: boolean;
+        consecutive?: boolean;
+        type?: INPUT_EVENT_TYPE;
+        forceRender?: boolean;
+    });
+}
+export interface ComponentEventInfo {
+    hasListener: boolean;
+    priority: Enumify<typeof RAYCAST_PRIORITY>;
+    roomleId: number;
+}
+export default class ConfiguratorSceneEventHandler extends SceneEventHandler<SceneEventInfo> {
+    _creator_: string;
+    private _selectionHandler;
+    private _configuratorUiCallbacks;
+    private _cameraMoving;
+    private _hoveredComponent;
+    private _hoveredPreview;
+    private _draggedComponent;
+    private _previewLineIntersection;
+    private _dragStartPosition;
+    private _dragStartRotation;
+    constructor(creator: string, scene: Scene, camera: PerspectiveCamera, inputManager: InputManager);
+    disable(): void;
+    enable(): void;
+    private _addInputListeners;
+    addComponentHandlers(component: RoomleComponent): void;
+    addComponentDragInHandler(component: RoomleComponent): void;
+    private _addComponentHandlers;
+    addPreviewHandlers(component: PreviewComponent): void;
+    addPreviewLineHandlers(component: PreviewLineComponent): void;
+    private _clickPreview;
+    private _clickPreviewLine;
+    clickComponent(component: RoomleComponent): void;
+    private _clickOutside;
+    private _hoverOn;
+    private _hoverOff;
+    private _hoverOnPreview;
+    private _hoverOffPreview;
+    private _hoverOnPreviewLine;
+    private _hoverMovePreviewLine;
+    private _updatePositionForPreviewLine;
+    private _hoverOffPreviewLine;
+    private _setDragComponentShadow;
+    private _dragStart;
+    private _drag;
+    private _dragEnd;
+    protected _interaction(forceRender?: boolean): void;
+    hasSelection(): boolean;
+    update(bounds: Vector3, rootComponentPosition: Vector3, backgroundScene: Scene): void;
+    isDragIn(): boolean;
+    isDragging(): boolean;
+    setRootComponentId(rootComponentId: number): void;
+    cancelSelection(): void;
+    setSelectionMode(mode: SELECTION_MODE): void;
+    getSelectionMode(): SELECTION_MODE;
+    getSelectedRuntimeComponentIds(): number[];
+    setCameraMoving(cameraMoving: boolean): void;
+    setCamera(camera: Camera): void;
+    setObject(object: Object3D): void;
+}

package/lib/definitions/packages/configurator-core/src/webgl/configurator-scene-manager.d.ts

@@ -0,0 +1,154 @@
+import type { PreviewComponent, PreviewLineComponent, RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type InputManager from '../../../common-core/src/input/input-manager';
+import { SELECTION_MODE } from '../utils/selection-handler';
+import type { Base64Image, CanvasOffset } from '../../../common-core/src/common-interfaces';
+import type { KernelComponent, PlanObject, UiPossibleChild } from '../../../typings/kernel';
+import type { SceneSettings } from '../../../common-core/src/scene-settings-loader';
+import type { RapiMaterial } from '../../../typings/rapi-types';
+import type ConfiguratorUiCallbacks from '../services/configurator-ui-callback';
+import type ConfiguratorContext from '../../../common-core/src/webgl/configurator-context';
+import type ConfiguratorViewModel from '../../../common-core/src/view-model/configurator-view-model';
+import { type ConfiguratorViewModelCallbackI } from '../../../common-core/src/view-model/configurator-view-model';
+import type ComponentRaycastHelper from '../utils/component-raycast-helper';
+import type { CameraParameter } from '../../../common-core/src/cameracontrol/camera-control';
+import SceneManager from '../../../common-core/src/webgl/scene-manager';
+import { type CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import type PlannerKernelAccess from '../../../planner-core/src/services/planner-kernel-access';
+import type { Enumify } from '../../../common-core/src/types';
+import type { Object3D } from 'three';
+import { Box3, Vector3 } from 'three';
+import type { CameraTarget, PrepareImageOptions, RenderOptions } from '../../../common-core/src/webgl/image-renderer';
+import ConfiguratorCameraBehaviour from '../../../common-core/src/cameracontrol/configurator-camera-behaviour';
+import type CameraBehaviour from '../../../common-core/src/cameracontrol/camera-behaviour';
+import type CameraBehaviour3d from '../../../common-core/src/cameracontrol/camera-behaviour-3d';
+import type GlobalInitData from '../../../common-core/src/utils/global-init-data';
+export default class ConfiguratorSceneManager extends SceneManager implements ConfiguratorViewModelCallbackI {
+    _creator_: string;
+    private _configuratorInputManager;
+    private _configuratorMeshGenerator;
+    private _memoryManager;
+    protected _configuratorContext: ConfiguratorContext;
+    private _componentDimensioningHelper;
+    private _configuratorHistory;
+    protected _configuratorUiCallbacks: ConfiguratorUiCallbacks;
+    protected _plannerKernelAccess: PlannerKernelAccess;
+    protected _globalInitData: GlobalInitData;
+    protected _viewModel: ConfiguratorViewModel;
+    private _componentFactory;
+    protected _componentRaycastHelper: ComponentRaycastHelper;
+    private _dimensionHelper;
+    private _uiIntersectionHelper;
+    private _sceneEventHandler;
+    constructor(creator: string, offset: CanvasOffset, mode: Enumify<typeof CAMERA_TYPE>);
+    private _initOptionalModules;
+    protected _changeCameraBehaviour(cameraBehaviour: CameraBehaviour): void;
+    disableEvents(): void;
+    enableEvents(): void;
+    enableConfiguratorEvents(): void;
+    disableConfiguratorEvents(): void;
+    protected _getViewModel(): ConfiguratorViewModel;
+    protected _getKernelAccess(): PlannerKernelAccess;
+    private _showDockings;
+    cancelDockings(): void;
+    private _cancelDockings;
+    private _onHoverOn;
+    private _onHoverOff;
+    private _highlightComponent;
+    protected shouldClearShadowsAndAO(): boolean;
+    resume(): void;
+    private _materialLoaded;
+    pause(): void;
+    protected _setupScene(offset?: CanvasOffset, transparent?: boolean, skipLightSetup?: boolean): void;
+    sceneCleared(shouldHardReset: boolean): void;
+    display(component: RoomleComponent): void;
+    protected setRootComponentId(rootComponentId: number): void;
+    debugSceneGraph(id?: number): void;
+    debugScene(): import("three").Scene;
+    private _printObjectGraph;
+    clearScene(): void;
+    planObjectConstructionDone(_planObject: PlanObject): void;
+    private _internalClearScene;
+    protected _waitForAssets(): Promise<void>;
+    preparePerspectiveImage(options?: PrepareImageOptions): Promise<Base64Image>;
+    renderImage(renderOptions: RenderOptions): Promise<Base64Image>;
+    preparePartImage(partId: number, options: PrepareImageOptions): Promise<any>;
+    protected _calculateBoundingBoxOfAllMeshes(spacing?: number, showDimensions?: boolean): CameraTarget;
+    private _externalMeshesAndMaterialsReady;
+    prepareTopImage(options?: PrepareImageOptions): Promise<Base64Image>;
+    enableDragIn(dragEvent: DragEvent): void;
+    private _zoomToComponentOnConsecutiveClick;
+    resetCameraPositionToStart(): void;
+    resetPreviews(): void;
+    changeOffset(offset: CanvasOffset): void;
+    setCameraOffset(offset: CanvasOffset): void;
+    /**
+     * This function is modified with callAgainAfter, see constructor
+     * @private
+     */
+    private _offsetAnimationStart;
+    /**
+     * This function is modified with debounce, see constructor
+     * @private
+     */
+    private _offsetAnimationEnd;
+    getCameraOffset(): CanvasOffset;
+    protected _onKeyDown(event: KeyboardEvent): void;
+    protected _onKeyUp(event: KeyboardEvent, cleanup?: boolean): void;
+    protected enablePanning(): void;
+    protected disablePanning(): void;
+    cancelPreviousDockings(): void;
+    cancelComponentSelection(resetCamera?: boolean): void;
+    protected notifyPlannerOnComponentSelectionCancel(_isExternalObject: boolean): void;
+    private _cancelSelection;
+    private _selectComponent;
+    private _deselectComponent;
+    getScreenXY(position: Vector3): Vector3;
+    setSelectionMode(mode: SELECTION_MODE): void;
+    changeFloorMaterial(material: RapiMaterial): Promise<void>;
+    zoomIn(value?: number): void;
+    zoomOut(value?: number): void;
+    showDimensions(): Promise<void>;
+    private _initDimensions;
+    hideDimensions(): void;
+    loadSceneSettings(sceneSetting: SceneSettings): Promise<void>;
+    protected onCameraChanged(): void;
+    requestDockingsPreview(userInitiated: boolean, possibleChild?: UiPossibleChild, dragEvent?: DragEvent, dragIn?: boolean): void;
+    private _requestDockingsPreviewWithDrag;
+    private _dockComponent;
+    private _dockKernelComponent;
+    private _dockExternalComponent;
+    private _onSelectedRuntimeComponentsChange;
+    private _onSelectedRuntimeComponentChange;
+    requestDeleteSelectedComponent(): void;
+    componentUpdated(component: RoomleComponent, _kernelComponent: KernelComponent): void;
+    planObjectUpdated(planObject: PlanObject, geometryChanged: boolean, pendingDocking: boolean): void;
+    componentDeleted(component: RoomleComponent): void;
+    previewConstructionDone(_component: RoomleComponent, hasPreviews: boolean): void;
+    configurationLoaded(component: RoomleComponent, isFreeFlying: boolean): void;
+    addComponentHandlers(component: RoomleComponent): void;
+    addPreviewHandlers(previewComponent: PreviewComponent): void;
+    addPreviewLineHandlers(previewLineComponent: PreviewLineComponent): void;
+    private _updateComponentPosition;
+    protected _updateBounds(box: Box3, geometryBox?: Box3, geometryChanged?: boolean): void;
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    selectComponent(runtimeId: number): void;
+    highlightParts(ids: number[]): void;
+    private _shouldHighlightComponent;
+    saveConfigToIdb(): void;
+    protected _getInputManager(): InputManager;
+    protected createCameraControl(_mode: Enumify<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
+    getBounds(): Box3;
+    getGeometryBounds(): Box3;
+    sceneChanged(): void;
+    protected get configuratorCameraBehaviour(): ConfiguratorCameraBehaviour;
+    protected get cameraBehaviour3d(): CameraBehaviour3d;
+    protected _onCameraIdle(): boolean;
+    protected _onCameraMove(): boolean;
+    getComponent(componentRuntimeId: number): KernelComponent;
+    cameraBehaviourChanged(): void;
+    protected _setCameraControlListeners(): void;
+    protected _shouldRenderUi(): boolean;
+    protected setEventHandlerObject(object: Object3D): void;
+    protected _readyForRender(): void;
+    animateElement(elementId: number, parameterName: string, value: string, applyToChildren: boolean, animate: boolean): void;
+}

package/lib/definitions/packages/configurator-core/src/webgl/environment/floor-environment.d.ts

@@ -0,0 +1,34 @@
+import Environment from '../../../../common-core/src/environment/environment';
+import type { RapiMaterial } from '../../../../typings/rapi-types';
+import type { PerspectiveCamera, Scene } from 'three';
+import { Vector3 } from 'three';
+export default class FloorEnvironment extends Environment {
+    private _rapiAccess;
+    private _dataSyncer;
+    private _bakedShadowPlane;
+    private _textureLoader;
+    private _longestSide;
+    private _width;
+    private _height;
+    private _cameraDistance;
+    private _repeatable;
+    private _floorMaterial;
+    private _floorTexture;
+    private _fog;
+    private _floorPromise;
+    constructor(scene: Scene, oldEnvironment: Environment, fog?: boolean);
+    needsBounds(): boolean;
+    needsCamera(): boolean;
+    needsRotation(): boolean;
+    updateBounds(bounds: Vector3): boolean;
+    updateCamera(camera: PerspectiveCamera): void;
+    private _update;
+    private _updateFog;
+    private _updateFloor;
+    addToScene(): void;
+    removeFromScene(): void;
+    setFloorMaterial(url: string, width: number, height: number, repeatable: boolean): Promise<void>;
+    changeFloorMaterial(rapiMaterial: RapiMaterial, maxAnisotropy: number): Promise<void>;
+    showGUI(): void;
+    private _addGUI;
+}

package/lib/definitions/packages/configurator-core/src/webgl/lightsetting/default-light-setting.d.ts

@@ -0,0 +1,15 @@
+import LightSetting from '../../../../common-core/src/lightsetting/light-setting';
+import type { Box3, Scene } from 'three';
+export default class DefaultLightSetting extends LightSetting {
+    private _ambientLight;
+    private _mainDirectionalLight;
+    private _secondDirectionalLight;
+    private _params;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    needsBounds(): boolean;
+    updateBounds(bounds: Box3): void;
+    addToScene(): void;
+    removeFromScene(): void;
+    reload(): void;
+    showGUI(): void;
+}

package/lib/definitions/packages/configurator-core/src/webgl/lightsetting/hd-light-setting.d.ts

@@ -0,0 +1,15 @@
+import LightSetting from '../../../../common-core/src/lightsetting/light-setting';
+import type { Scene } from 'three';
+export default class HdLightSetting extends LightSetting {
+    private _ambientLight;
+    private _areaLight;
+    private _sideSpot;
+    private _backspot;
+    private _params;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    private _createSpotlight;
+    addToScene(): void;
+    removeFromScene(): void;
+    reload(): void;
+    showGUI(): void;
+}

package/lib/definitions/packages/configurator-core/src/webgl/lightsetting/top-image-light-setting.d.ts

@@ -0,0 +1,12 @@
+import LightSetting from '../../../../common-core/src/lightsetting/light-setting';
+import type { Scene } from 'three';
+export default class TopImageLightSetting extends LightSetting {
+    private _ambientLight;
+    private _params;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    needsBounds(): boolean;
+    addToScene(): void;
+    removeFromScene(): void;
+    reload(): void;
+    showGUI(): void;
+}