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

package/packages/web-sdk/packages/configurator-core/src/webgl/configurator-scene-manager.d.ts

@@ -0,0 +1,161 @@
+import { PreviewComponent, PreviewLineComponent, RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import { default as InputManager } from '../../../common-core/src/input/input-manager';
+import { SELECTION_MODE } from '../utils/selection-handler';
+import { Base64Image, CanvasOffset } from '../../../common-core/src/common-interfaces';
+import { KernelComponent, PlanObject, UiPossibleChild } from '../../../typings/kernel';
+import { SceneSettings } from '../../../common-core/src/scene-settings-loader';
+import { RapiMaterial } from '../../../typings/rapi-types';
+import { default as ConfiguratorUiCallbacks } from '../services/configurator-ui-callback';
+import { default as ConfiguratorContext } from '../../../common-core/src/webgl/configurator-context';
+import { default as ConfiguratorViewModel, ConfiguratorViewModelCallbackI } from '../../../common-core/src/view-model/configurator-view-model';
+import { default as ComponentRaycastHelper } from '../utils/component-raycast-helper';
+import { CameraParameter } from '../../../common-core/src/cameracontrol/camera-control';
+import { default as SceneManager } from '../../../common-core/src/webgl/scene-manager';
+import { CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import { default as PlannerKernelAccess } from '../../../planner-core/src/services/planner-kernel-access';
+import { Enumify } from '../../../common-core/src/types';
+import { Object3D, Box3, Vector3 } from 'three';
+import { CameraTarget, PrepareImageOptions, RenderOptions } from '../../../common-core/src/webgl/image-renderer';
+import { default as ConfiguratorCameraBehaviour } from '../../../common-core/src/cameracontrol/configurator-camera-behaviour';
+import { default as CameraBehaviour } from '../../../common-core/src/cameracontrol/camera-behaviour';
+import { default as CameraBehaviour3d } from '../../../common-core/src/cameracontrol/camera-behaviour-3d';
+import { default as GlobalInitData } from '../../../common-core/src/utils/global-init-data';
+import { CancelSelectionReasons } from '../../../typings/planner';
+
+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;
+    waitForMaterialQueue(): Promise<void>;
+    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, _isolationMode?: boolean): 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, _isolationMode?: boolean): 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 _checkUndoRedo(event: KeyboardEvent): void;
+    protected _onKeyDown(event: KeyboardEvent): void;
+    protected _onKeyUp(event: KeyboardEvent, cleanup?: boolean): void;
+    protected enablePanning(): void;
+    protected disablePanning(): void;
+    cancelPreviousDockings(): void;
+    cancelComponentSelection(resetCamera?: boolean, reason?: CancelSelectionReasons): void;
+    protected notifyPlannerOnComponentSelectionCancel(_isExternalObject: boolean, _reason: CancelSelectionReasons): 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>;
+    getSelectedRuntimeComponentIds(): number[];
+    selectComponent(runtimeId: number, triggerClickCallback?: boolean): 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;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    clearHistory(): void;
+    private _callOnPartListUpdate;
+}

package/packages/web-sdk/packages/configurator-core/src/webgl/environment/floor-environment.d.ts

@@ -0,0 +1,34 @@
+import { default as Environment } from '../../../../common-core/src/environment/environment';
+import { RapiMaterial } from '../../../../typings/rapi-types';
+import { PerspectiveCamera, Scene, 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/packages/web-sdk/packages/configurator-core/src/webgl/lightsetting/default-light-setting.d.ts

@@ -0,0 +1,16 @@
+import { default as LightSetting } from '../../../../common-core/src/lightsetting/light-setting';
+import { 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/packages/web-sdk/packages/configurator-core/src/webgl/lightsetting/hd-light-setting.d.ts

@@ -0,0 +1,16 @@
+import { default as LightSetting } from '../../../../common-core/src/lightsetting/light-setting';
+import { 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/packages/web-sdk/packages/configurator-core/src/webgl/lightsetting/top-image-light-setting.d.ts

@@ -0,0 +1,13 @@
+import { default as LightSetting } from '../../../../common-core/src/lightsetting/light-setting';
+import { 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;
+}

package/packages/web-sdk/packages/configurator-core/src/webgl/plugin-system.d.ts

@@ -0,0 +1,44 @@
+import { Context } from '../../../common-core/src/di/context';
+import { Box3, Scene, Vector3 } from 'three';
+
+export declare interface ScenePluginHooks {
+    updateBounds(bounds: Box3): void;
+    clearScene(scene: Scene, uiScene: Scene): void;
+    moveCameraEnd(position: Vector3): void;
+    moveCameraStart(position: Vector3): void;
+    needsUiScene(): boolean;
+}
+export declare interface ScenePlugin extends ScenePluginHooks, Context {
+    setScene(scene: Scene): void;
+    setUiScene(uiScene: Scene): void;
+}
+export declare class ScenePluginDefaultImplementation implements ScenePlugin {
+    _creator_: string;
+    constructor(creator: string);
+    setScene(scene: Scene): void;
+    setUiScene(uiScene: Scene): void;
+    updateBounds(bounds: Box3): void;
+    clearScene(scene: Scene, uiScene: Scene): void;
+    moveCameraEnd(position: Vector3): void;
+    moveCameraStart(position: Vector3): void;
+    needsUiScene(): boolean;
+}
+export default class PluginSystem implements Context, ScenePluginHooks {
+    _creator_: string;
+    private _initData;
+    private _scene;
+    private _uiScene;
+    private _bounds;
+    private _cameraPosition;
+    private _plugins;
+    constructor(creator: string);
+    init(scene: Scene, uiScene: Scene, cameraPosition: Vector3): Promise<void>;
+    addPlugin(plugin: ScenePlugin): void;
+    updateBounds(bounds: Box3): void;
+    clearScene(scene: Scene, uiScene: Scene): void;
+    getActivePlugins(): ScenePlugin[];
+    getPlugin<T extends ScenePlugin>(type: any): T;
+    moveCameraEnd(position: Vector3): void;
+    moveCameraStart(position: Vector3): void;
+    needsUiScene(): boolean;
+}

package/packages/web-sdk/packages/glb-viewer-core/__tests__/adjujstable-camera-control-3d.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/web-sdk/packages/glb-viewer-core/__tests__/glb-viewer-scene-manager.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/web-sdk/packages/glb-viewer-core/__tests__/roomle-glb-viewer.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/web-sdk/packages/glb-viewer-core/mock/mock-scene-settings.d.ts

@@ -0,0 +1 @@
+export declare const MockSceneSettings = "{\n  \"lights\": [\n    {\n      \"type\": \"ambient\",\n      \"name\": \"ambient\",\n      \"intensity\": 0.3,\n      \"color\": \"#ffffff\",\n      \"position\": {\n        \"x\": 0,\n        \"y\": 0,\n        \"z\": 0\n      }\n    }\n  ],\n  \"environment\": {\n    \"type\": \"image\",\n    \"details\": {\n      \"imageUrl\": \"https://storage.googleapis.com/roomle-static/test/bg/bg_grey.jpg\"\n    }\n  }\n}";

package/packages/web-sdk/packages/glb-viewer-core/src/camera-control/adjustable-camera-control-3d.d.ts

@@ -0,0 +1,9 @@
+import { default as CameraControl3D } from '../../../common-core/src/cameracontrol/camera-control-3d';
+import { Vector3 } from 'three';
+
+export default class AdjustableCameraControl3D extends CameraControl3D {
+    shouldIgnoreStandardBehavior: boolean;
+    adjust(bounds: Vector3, position: Vector3, yaw: number, pitch: number, _fov: number): void;
+    protected _update(overrideTarget?: Vector3): void;
+    animateCamera(delta: number): boolean;
+}

package/packages/web-sdk/packages/glb-viewer-core/src/glb-viewer-main.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/web-sdk/packages/glb-viewer-core/src/glb-viewer.d.ts

@@ -0,0 +1,13 @@
+import { default as Main } from '../../common-core/src/main';
+import { default as RoomleGLBViewer } from './roomle-glb-viewer';
+
+export declare class GlbViewer extends Main {
+    private _viewer;
+    protected setupGlobals(): void;
+    protected setupDependencies(): void;
+    protected cleanUpGlobals(): void;
+    protected cleanUpDependencies(): void;
+    protected bootFinished(): void;
+    getApi(): RoomleGLBViewer;
+    protected getContextName(): string;
+}

package/packages/web-sdk/packages/glb-viewer-core/src/input/glb-input-manager.d.ts

@@ -0,0 +1,4 @@
+import { default as InputManager } from '../../../common-core/src/input/input-manager';
+
+export default class GlbInputManager extends InputManager {
+}

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

@@ -0,0 +1,108 @@
+import { Base64Image, CanvasOffset, Position3 } from '../../common-core/src/common-interfaces';
+import { ExternalEmbeddable, GlobalAPI, default as Main } from '../../common-core/src/main';
+import { Context } from '../../common-core/src/di/context';
+import { SceneSettings } from '../../common-core/src/scene-settings-loader';
+import { default as InitData } from '../../common-core/src/utils/init-data';
+import { GlobalInitDataDefinition, InitDataDefinition } from '../../common-core/src/utils/shims';
+import { default as UnitFormatter } from '../../configurator-core/src/services/unit-formatter';
+import { Scene } from 'three';
+import { default as IdbManager } from '../../common-core/src/services/idb-manager';
+import { CameraParameter } from '../../common-core/src/cameracontrol/camera-control';
+import { GlobalCallback } from '../../common-core/src/services/global-callback';
+
+interface RenderCameraInformation {
+    fieldOfView: number;
+    rotation: Position3;
+    position: Position3;
+}
+export declare interface RenderEntry {
+    path: string;
+    camera: RenderCameraInformation;
+}
+export declare class GlbViewerUiCallbacks {
+}
+export default class RoomleGLBViewer implements GlobalAPI, Context, ExternalEmbeddable<GlbViewerUiCallbacks> {
+    _creator_: string;
+    private _rapiAccess;
+    private _domHelper;
+    private _scriptLoader;
+    private _lifeCycleManager;
+    private _initData;
+    private _globalInitData;
+    private _globalCallback;
+    private _unitFormatter;
+    protected _idbManager: IdbManager;
+    private _sceneManager;
+    private _currentIdOrUrl;
+    constructor(creator: string);
+    setCameraOffset(offset: CanvasOffset): void;
+    getCameraOffset(): CanvasOffset;
+    init(element: HTMLElement, initData?: InitDataDefinition): Promise<void>;
+    private _initPromiseCallback;
+    /**
+     * Remove the current glb from the scene if it exists
+     */
+    clearScene(): void;
+    /**
+     * Loads the GLB from the given URL Param
+     * @param url
+     * @param scaling defaults to 1
+     * @param callback loading percent between 0 and 1
+     */
+    loadGLB(url: string, scaling?: number, callback?: (percent: number) => void): Promise<void>;
+    /**
+     * Loads the glb asset from the static item
+     * @param staticItemId
+     * @param callback loading percent between 0 and 1
+     */
+    loadStaticItem(staticItemId: string, callback?: (percent: number) => void): Promise<void>;
+    /**
+     * Returns the current item id or url of the loaded object
+     */
+    getCurrentId(): string;
+    /**
+     * Loads a SceneSettings object, currently it can can contain a light setting definition
+     * (see {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.loadDynamicLightSetting}) and an environment definition (see {@link @roomle/web-sdk/configurator-core/src/environment/dynamic-environment-setting-loaderEnvironmentSetting}).
+     * @param sceneSettings
+     */
+    loadSceneSetting(sceneSettings: SceneSettings): Promise<void>;
+    preparePerspectiveImage(): Promise<Base64Image>;
+    processRenderList(jsonString: string, width?: number, height?: number): void;
+    setOverrides(initData: Partial<InitDataDefinition & GlobalInitDataDefinition> | InitData): 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;
+    resumeTest(element: HTMLElement): void;
+    pauseTest(): void;
+    showGUI(): void;
+    get callbacks(): {};
+    getScene(): Scene;
+    updateScene(): void;
+    /**
+     * returns unit formatter for formatting input und output values in scene
+     */
+    getUnitFormatter(): UnitFormatter;
+    /**
+     * returns manager class to interface with indexedDB storage
+     */
+    getStorage(): IdbManager;
+    setEnvironmentMap(params: {
+        url?: string;
+        intensity?: number;
+        rotation?: number;
+        maxLightSources?: number;
+    }): void;
+    exportCanvasScreenshot(quality?: number): Promise<string>;
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    /**
+     * @internal
+     * Use this callbacks to hook in your functionality
+     */
+    get globalCallbacks(): GlobalCallback;
+}
+export {};

package/packages/web-sdk/packages/glb-viewer-core/src/services/glb-render-worker.d.ts

@@ -0,0 +1,28 @@
+import { default as GLBViewerSceneManager } from '../webgl/glb-viewer-scene-manager';
+import { RenderEntry } from '../roomle-glb-viewer';
+
+export interface GLBRenderWorkerListener {
+    onStart(count: number): void;
+    onElementFinished(finishedElements: number): void;
+    onFinished(zip: any): void;
+}
+export default class GLBRenderWorker {
+    private _sceneManager;
+    private _entries;
+    private _resolve;
+    private _prefix;
+    private _renderer;
+    private _width;
+    private _height;
+    private _listeners;
+    private _finishedItems;
+    private _zip;
+    constructor(sceneManager: GLBViewerSceneManager, width: number, height: number);
+    addListener(listener: GLBRenderWorkerListener): void;
+    removeListener(listener: GLBRenderWorkerListener): void;
+    start(entries: RenderEntry[]): Promise<any>;
+    private _transform;
+    private _doNextEntry;
+    private _processEntry;
+    private _entryFinished;
+}

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

@@ -0,0 +1,7 @@
+import { default as RoomleGLBViewer } from '../../../glb-viewer-core/src/roomle-glb-viewer';
+
+declare global {
+    interface Window {
+        RoomleGLBViewer: RoomleGLBViewer;
+    }
+}

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

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

package/packages/web-sdk/packages/glb-viewer-core/src/webgl/glb-viewer-light-setting.d.ts

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

package/packages/web-sdk/packages/glb-viewer-core/src/webgl/glb-viewer-scene-manager.d.ts

@@ -0,0 +1,36 @@
+import { default as SceneManager } from '../../../common-core/src/webgl/scene-manager';
+import { Base64Image, CanvasOffset } from '../../../common-core/src/common-interfaces';
+import { GLBRenderWorkerListener } from '../services/glb-render-worker';
+import { default as InputManager } from '../../../common-core/src/input/input-manager';
+import { CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import { Enumify } from '../../../common-core/src/types';
+import { Box3, Vector3, WebGLRenderer } from 'three';
+import { default as GlbViewerCameraBehaviour } from '../../../common-core/src/cameracontrol/glb-viewer-camera-behaviour';
+import { CameraParameter } from '../../../common-core/src/cameracontrol/camera-control';
+
+export default class GLBViewerSceneManager extends SceneManager implements GLBRenderWorkerListener {
+    private _glbInputManager;
+    private _rapiAccess;
+    private _currentGLB;
+    private _standardSceneBackgroundColor;
+    private _itemsCount;
+    constructor(creator: string, offset: CanvasOffset);
+    protected createCameraControl(_mode: Enumify<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
+    protected _getInputManager(): InputManager;
+    loadStaticItem(id: string, callback?: (percent: number) => void): Promise<void>;
+    loadGLB(url: string, automaticallyAdjustCamera?: boolean, scaling?: Vector3, callback?: (percent: number) => void): Promise<void>;
+    preparePerspectiveImage(renderer?: WebGLRenderer, width?: number, height?: number): Promise<Base64Image>;
+    adjustCamera(position: Vector3, yaw: number, pitch: number, fov: number): void;
+    onStart(count: number): void;
+    onElementFinished(itemsFinished: number): void;
+    onFinished(_zip: any): void;
+    clearScene(): void;
+    enableHD(): void;
+    sceneChanged(): void;
+    getBounds(): Box3;
+    protected get glbViewerCameraBehaviour(): GlbViewerCameraBehaviour;
+    getGeometryBounds(): Box3;
+    cameraBehaviourChanged(): void;
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    protected _readyForRender(): void;
+}

package/packages/web-sdk/packages/material-viewer/__tests__/roomle-material-viewer.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/web-sdk/packages/material-viewer/src/material-viewer-main.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/web-sdk/packages/material-viewer/src/material-viewer.d.ts

@@ -0,0 +1,13 @@
+import { default as Main } from '../../common-core/src/main';
+import { default as RoomleMaterialViewer } from './roomle-material-viewer';
+
+export declare class MaterialViewer extends Main {
+    private _viewer;
+    protected setupGlobals(): void;
+    protected setupDependencies(): void;
+    protected cleanUpGlobals(): void;
+    protected cleanUpDependencies(): void;
+    protected bootFinished(): void;
+    getApi(): RoomleMaterialViewer;
+    protected getContextName(): string;
+}

package/packages/web-sdk/packages/material-viewer/src/roomle-material-viewer-ui-callback.d.ts

@@ -0,0 +1,11 @@
+import { UiCallback } from '../../common-core/src/utils/ui-callback';
+import { RapiMaterialShading } from '../../typings/rapi-types';
+
+export default class RoomleMaterialViewerUiCallback extends UiCallback {
+    constructor(creator: string);
+    /**
+     * Gets called when a material parameter has been changed using the graphical user interface
+     * @param materialShading
+     */
+    onMaterialShadingChanged: (materialShading: RapiMaterialShading) => void;
+}