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

package/lib/definitions/packages/configurator-core/src/webgl/plugin-system.d.ts

@@ -0,0 +1,43 @@
+import type { Context } from '../../../common-core/src/di/context';
+import type { 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/lib/definitions/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/lib/definitions/packages/glb-viewer-core/src/camera-control/adjustable-camera-control-3d.d.ts

@@ -0,0 +1,8 @@
+import 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/lib/definitions/packages/glb-viewer-core/src/glb-viewer.d.ts

@@ -0,0 +1,13 @@
+import './utils/global-definitions';
+import Main from '../../common-core/src/main';
+import 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/lib/definitions/packages/glb-viewer-core/src/input/glb-input-manager.d.ts

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

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

@@ -0,0 +1,108 @@
+import type { Base64Image, CanvasOffset, Position3 } from '../../common-core/src/common-interfaces';
+import type { ExternalEmbeddable, GlobalAPI } from '../../common-core/src/main';
+import type Main from '../../common-core/src/main';
+import type { Context } from '../../common-core/src/di/context';
+import type { SceneSettings } from '../../common-core/src/scene-settings-loader';
+import type InitData from '../../common-core/src/utils/init-data';
+import type { GlobalInitDataDefinition, InitDataDefinition } from '../../common-core/src/utils/shims';
+import type UnitFormatter from '../../configurator-core/src/services/unit-formatter';
+import type { Scene } from 'three';
+import type IdbManager from '../../common-core/src/services/idb-manager';
+import type { CameraParameter } from '../../common-core/src/cameracontrol/camera-control';
+import type { 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/lib/definitions/packages/glb-viewer-core/src/services/glb-render-worker.d.ts

@@ -0,0 +1,27 @@
+import type GLBViewerSceneManager from '../webgl/glb-viewer-scene-manager';
+import type { 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/lib/definitions/packages/glb-viewer-core/src/utils/global-definitions.d.ts

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

package/lib/definitions/packages/glb-viewer-core/src/utils/injectables.d.ts

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

package/lib/definitions/packages/glb-viewer-core/src/webgl/glb-viewer-light-setting.d.ts

@@ -0,0 +1,11 @@
+import LightSetting from '../../../common-core/src/lightsetting/light-setting';
+import type { 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/lib/definitions/packages/glb-viewer-core/src/webgl/glb-viewer-scene-manager.d.ts

@@ -0,0 +1,35 @@
+import SceneManager from '../../../common-core/src/webgl/scene-manager';
+import type { Base64Image, CanvasOffset } from '../../../common-core/src/common-interfaces';
+import type { GLBRenderWorkerListener } from '../services/glb-render-worker';
+import type InputManager from '../../../common-core/src/input/input-manager';
+import { CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import type { Enumify } from '../../../common-core/src/types';
+import { Box3, Vector3, WebGLRenderer } from 'three';
+import GlbViewerCameraBehaviour from '../../../common-core/src/cameracontrol/glb-viewer-camera-behaviour';
+import { type 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/lib/definitions/packages/material-viewer/src/material-viewer.d.ts

@@ -0,0 +1,13 @@
+import './utils/global-definitions';
+import Main from '../../common-core/src/main';
+import 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/lib/definitions/packages/material-viewer/src/roomle-material-viewer-ui-callback.d.ts

@@ -0,0 +1,10 @@
+import { UiCallback } from '../../common-core/src/utils/ui-callback';
+import type { 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;
+}

package/lib/definitions/packages/material-viewer/src/roomle-material-viewer.d.ts

@@ -0,0 +1,126 @@
+import type { ExternalEmbeddable, GlobalAPI } from '../../common-core/src/main';
+import type Main from '../../common-core/src/main';
+import type { Context } from '../../common-core/src/di/context';
+import type { SceneSettings } from '../../common-core/src/scene-settings-loader';
+import type { GEOMETRY } from './webgl/material-viewer-scene-manager';
+import type { RapiId, RapiMaterial, RapiMaterialShading, RapiTexture } from '../../typings/rapi-types';
+import type RoomleMaterialViewerUiCallback from './roomle-material-viewer-ui-callback';
+import type { InitDataDefinition } from '../../common-core/src/utils/shims';
+import type { CanvasOffset } from '../../common-core/src/common-interfaces';
+import type UnitFormatter from '../../configurator-core/src/services/unit-formatter';
+import type { Scene } from 'three';
+import type IdbManager from '../../common-core/src/services/idb-manager';
+import type { GlobalCallback } from '../../common-core/src/services/global-callback';
+export default class RoomleMaterialViewer implements GlobalAPI, Context, ExternalEmbeddable<RoomleMaterialViewerUiCallback> {
+    _creator_: string;
+    private _domHelper;
+    private _scriptLoader;
+    private _lifeCycleManager;
+    private _roomleMaterialViewerUiCallback;
+    private _initData;
+    private _globalCallback;
+    private _rapiAccess;
+    private _unitFormatter;
+    protected _idbManager: IdbManager;
+    private _sceneManager;
+    constructor(creator: string);
+    setCameraOffset(offset: CanvasOffset): void;
+    getCameraOffset(): CanvasOffset;
+    init(element: HTMLElement): Promise<void>;
+    private _initPromiseCallback;
+    get callbacks(): RoomleMaterialViewerUiCallback;
+    set callbacks(callback: RoomleMaterialViewerUiCallback);
+    loadMaterialShading(materialShading: RapiMaterialShading): Promise<void>;
+    resetMaterial(): void;
+    loadMaterial(material: RapiMaterial, options?: {
+        flushCache?: boolean;
+    }): Promise<void>;
+    loadMaterialId(materialId: RapiId, options?: {
+        flushCache?: boolean;
+    }): Promise<void>;
+    getMaterialShading(version?: number): RapiMaterialShading;
+    /**
+     * 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-loader#EnvironmentSetting}).
+     * @param sceneSettings
+     */
+    loadSceneSetting(sceneSettings: SceneSettings): Promise<void>;
+    setOverrides(initData: InitDataDefinition): 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;
+    /**
+     * Sets the material of the floor to the given material id.
+     * If the current environment is not floor environment it will be changed
+     *
+     * Example material ids are:
+     * 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
+     *
+     * @param materialId
+     * @return promise that resolves when material has been changed
+     */
+    changeFloorMaterialById(materialId: string): Promise<void>;
+    /**
+     * Set the geometry of the demo material mesh
+     *
+     * Possible parameter:
+     * 'cube',
+     * 'sphere',
+     * 'plane_vertical',
+     * 'plane_horizontal'
+     *
+     * @param type
+     */
+    setGeometry(type: GEOMETRY): void;
+    /**
+     * Set a texture on the demo material, if no base64Image is set, the image field of rapiTexture is used
+     * @param rapiTexture
+     * @param base64Image for example "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPj/HwADBwIAMCbHYQAAAABJRU5ErkJggg=="
+     */
+    addTexture(rapiTexture: RapiTexture, base64Image?: string): Promise<void>;
+    /**
+     * Remove texture from the demo material
+     * @param rapiTexture
+     */
+    removeTexture(rapiTexture: RapiTexture): void;
+    private _clearCaches;
+    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;
+    /**
+     * @internal
+     * Use this callbacks to hook in your functionality
+     */
+    get globalCallbacks(): GlobalCallback;
+}

package/lib/definitions/packages/material-viewer/src/utils/global-definitions.d.ts

@@ -0,0 +1,7 @@
+import '../../../typings/global-definitions';
+import type RoomleMaterialViewer from '../roomle-material-viewer';
+declare global {
+    interface Window {
+        RoomleMaterialViewer: RoomleMaterialViewer;
+    }
+}

package/lib/definitions/packages/material-viewer/src/utils/injectables.d.ts

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

package/lib/definitions/packages/material-viewer/src/webgl/material-viewer-scene-manager.d.ts

@@ -0,0 +1,47 @@
+import SceneManager from '../../../common-core/src/webgl/scene-manager';
+import type { CanvasOffset } from '../../../common-core/src/common-interfaces';
+import type InputManager from '../../../common-core/src/input/input-manager';
+import type { RapiId, RapiMaterial, RapiMaterialShading, RapiTexture } from '../../../typings/rapi-types';
+import { CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import type { Enumify } from '../../../common-core/src/types';
+import { Box3 } from 'three';
+export declare const enum GEOMETRY {
+    CUBE = "cube",
+    SPHERE = "sphere",
+    PLANE_VERTICAL = "plane_vertical",
+    PLANE_HORIZONTAL = "plane_horizontal"
+}
+export default class MaterialViewerSceneManager extends SceneManager {
+    private _inputManager;
+    private _configuratorMeshGenerator;
+    private _roomleMaterialViewerUiCallback;
+    private _rapiAccess;
+    private _guiGeometryFolder;
+    private _guiMaterialFolder;
+    private _mesh;
+    private _material;
+    private _sceneParams;
+    private _materialParams;
+    constructor(creator: string, offset: CanvasOffset);
+    private _initScene;
+    loadMaterialId(materialId: RapiId): Promise<void>;
+    loadMaterial(material: RapiMaterial): Promise<void>;
+    loadMaterialShading(materialShading: RapiMaterialShading): Promise<void>;
+    resetMaterial(): void;
+    private _setMaterial;
+    getMaterialShading(version?: number): RapiMaterialShading;
+    protected createCameraControl(_mode: Enumify<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
+    protected _getInputManager(): InputManager;
+    sceneChanged(): void;
+    getBounds(): Box3;
+    getGeometryBounds(): Box3;
+    protected _guiLoaded(): void;
+    private _updateGUI;
+    private _shadingChanged;
+    setGeometry(type: GEOMETRY): void;
+    private _setGeometry;
+    changeFloorMaterialById(materialId: string): Promise<void>;
+    addTexture(rapiTexture: RapiTexture, base64Image?: string): Promise<void>;
+    removeTexture(rapiTexture: RapiTexture): void;
+    clearCache(): void;
+}

package/lib/definitions/packages/planner-core/__tests__/webgl/lightsetting/planner-light-setting.d.ts

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

package/lib/definitions/packages/planner-core/mock/planner-kernel-access-mock.d.ts

@@ -0,0 +1,22 @@
+import PlannerKernelAccess from '../src/services/planner-kernel-access';
+import type { KernelCatalogItem } from '../../typings/kernel';
+import type { PlanInteractionHandler } from '../../typings/planner';
+export default class PlannerKernelAccessMock extends PlannerKernelAccess {
+    _kernelContainer: {
+        unregisterConfiguratorCallback: () => void;
+        registerConfiguratorCallback: () => void;
+        unregisterPlannerCallback: () => void;
+        registerPlannerCallback: () => void;
+        catalogItemLoaded: (_catalogItem: KernelCatalogItem) => void;
+        CatalogItem: {
+            new (): {};
+        };
+    };
+    private _planInteractionHandlerMock;
+    private _planModelViewHelper;
+    get planInteractionHandler(): PlanInteractionHandler;
+    get planModelViewHelper(): any;
+    updatePlanObjectDependencies(): void;
+    requestPartListAndUpdatePricesOfParts(): Promise<void>;
+    planObjectUpdated(_planObjectId: number, _pendingDocking: boolean): void;
+}

package/lib/definitions/packages/planner-core/mock/planner-mock-helper.d.ts

@@ -0,0 +1,39 @@
+import type { PlanMeasure, PlanObject, WallPlanObject } from '../../typings/planner';
+import type { RapiItem } from '../../typings/rapi-types';
+import { PlanElementType } from '../../typings/planner-kernel-container';
+import type { Point } from 'roomle-core-hsc/src/embind/configuratorCoreInterface';
+export declare const PLAN_OBJECT_ROTATION: number;
+export declare const getDoorArches: (size?: number, openingDirection?: number) => {
+    size: () => number;
+    get: (_number: number) => {
+        getStartPoint: () => Point;
+        getEndPoint: () => Point;
+        getStartPointRelativeToObject: () => Point;
+        getEndPointRelativeToObject: () => Point;
+        getOpeningDirection: () => {
+            value: number;
+        };
+    };
+};
+export declare const createPlanObject: (type?: PlanElementType) => PlanObject;
+export declare const getRapiItem: () => RapiItem;
+export declare const getWallPlanObject: (wallType?: any) => WallPlanObject;
+export declare const getMeasurementLinePlanObject: () => PlanMeasure;
+export declare const getFloorPlanObject: () => PlanObject;
+export declare const MOCK_RUNTIME_COMPONENTID = 49;
+export declare const MOCK_MESHID = "adidas-focs:ShelfTable_Table_Large_Metall";
+export declare const MOCK_MESH_ID_NUMBER = 42;
+export declare const MOCK_GEOMETRY_ID = "#asdfjaksdklfasd";
+export declare const MOCK_MATERIALID = "adidas:Metal";
+export declare const MOCK_TRANSFORM: Float32Array;
+export declare const MOCK_UVTRANSFORM: Float32Array;
+export declare const MOCK_VERTICES: Float32Array;
+export declare const MOCK_INDICES: Int32Array;
+export declare const MOCK_UVCOORDS: Float32Array;
+export declare const MOCK_NORMALS: Float32Array;
+export declare const MOCK_RAPIMATERIAL: any;
+export declare const MOCK_PLANNER_SCENE_EVENT_HANDLER: {
+    addPlanObjectHandlers: () => void;
+    addWallHandlers: () => void;
+    addFloorHandlers: () => void;
+};

package/lib/definitions/packages/planner-core/src/camera-control/camera-control-first-person.d.ts

@@ -0,0 +1,42 @@
+import CameraControl from '../../../common-core/src/cameracontrol/camera-control';
+import type InputManager from '../../../common-core/src/input/input-manager';
+import { PerspectiveCamera, Vector3 } from 'three';
+export default class CameraControlFirstPerson extends CameraControl {
+    private _camera;
+    private _orbitPosition;
+    private _state;
+    private _cameraRotation;
+    private _position;
+    private _downPosition;
+    private _rotationSpeed;
+    private _keyMap;
+    private _listenerLoopAnimationFrame;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    constructor(creator: string, inputManager: InputManager, initialCameraPosition?: Vector3, camera?: PerspectiveCamera);
+    private _gamepadConnected;
+    private _gamepadDisconnected;
+    private startButtonPressListener;
+    private buttonPressListener;
+    private _checkRightStick;
+    private _checkLeftStick;
+    private _checkButtons;
+    animateCamera(delta: number): boolean;
+    protected _getCamera(): PerspectiveCamera;
+    protected _initInputListener(): void;
+    protected _removeInputListener(): void;
+    private _down;
+    private _move;
+    private _up;
+    private _onLongDown;
+    protected _update(_overrideTarget?: Vector3): void;
+    updateCamera(): void;
+    private _onKeyChanged;
+    private _processKeyMap;
+    private _processUpDown;
+    private _orbit;
+    private _moveForward;
+    protected _rotateVertical(angle: number): void;
+    getKernelZoomFactor(): number;
+    cleanUp(): void;
+}