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

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;
+}

package/packages/web-sdk/packages/common-core/src/environment/dynamic-environment-setting-loader.d.ts

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

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

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

package/packages/web-sdk/packages/common-core/src/environment/ground-projected-environment.d.ts

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

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

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

package/packages/web-sdk/packages/common-core/src/form-data-util.d.ts

@@ -0,0 +1,16 @@
+import { Base64String } from '../../typings/rapi-types';
+
+interface ImagesTypes {
+    JPG: string;
+    JPEG: string;
+    PNG: string;
+    GIF: string;
+    [key: string]: string;
+}
+export declare const IMAGE_FORMATS: ImagesTypes;
+export default class FormDataUtil {
+    private _base64toBlob;
+    private _createFormData;
+    create(base64: Base64String, hash: string, fileExtension: string, formfield: string): FormData;
+}
+export {};

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

@@ -0,0 +1,116 @@
+import { Position2 } from '../common-interfaces';
+import { default as EventDispatcher } from '../../../configurator-core/src/utils/event-dispatcher';
+import { Context } from '../di/context';
+
+export declare const BROWSER_EVENTS: {
+    [key: string]: string;
+};
+export declare const WINDOW_EVENTS: {
+    [key: string]: string;
+};
+export declare const enum INPUT_EVENT {
+    DRAG_START = 0,
+    DRAG = 1,
+    DRAG_END = 2,
+    DOWN = 3,
+    UP = 4,
+    CLICK = 5,
+    MOVE = 6,
+    ZOOM_IN = 7,
+    ZOOM_OUT = 8,
+    ROTATE = 9,
+    ROTATE_END = 10,
+    PAN = 11,
+    DOUBLE_CLICK = 12,
+    TOUCH_END = 13,
+    LONG_TOUCH = 14,
+    MOUSE_LEAVE = 15,
+    KEY_DOWN = 16,
+    KEY_UP = 17
+}
+export declare const enum INPUT_EVENT_TYPE {
+    UNKNOWN = 0,
+    MOUSE = 1,
+    TOUCH = 2,
+    AUTO = 3,
+    KEYBOARD = 4
+}
+export declare const EVENT_TYPE: {
+    readonly CLICK: 1;
+    readonly DOUBLE_CLICK: 2;
+};
+export declare const INPUT_DELAY_TYPE: {
+    readonly DRAG: 50;
+};
+export declare class InputEvent {
+    position: Position2;
+    positionRelative: Position2;
+    type: INPUT_EVENT_TYPE;
+    rotation: number;
+    event: Event;
+    constructor(position?: Position2, positionRelative?: Position2, type?: INPUT_EVENT_TYPE, rotation?: number, event?: Event);
+}
+export declare const MIN_MOVE_DISTANCE: number;
+export default class InputManager extends EventDispatcher<InputEvent> implements Context, EventListenerObject {
+    _creator_: string;
+    private _domHelper;
+    private _downPosition;
+    private _downPositionRelative;
+    private _elementHit;
+    private _longClickTimer;
+    private _delta;
+    private _state;
+    private _pinchDistance;
+    private _rotationAngle;
+    private _firefoxDragPosition;
+    private _lastMouseWheelEvent;
+    private _lastTouchEvent;
+    private _events;
+    private _windowEvents;
+    private _dragEnabled;
+    private _dragTarget;
+    private _dragMVName;
+    private _dragMV;
+    private _dragEVName;
+    private _dragEV;
+    private _boundingClientRect;
+    private _boundingClientRectInvalid;
+    constructor(creator: string);
+    enableDragIn(dragEvent?: DragEvent): void;
+    isMouseUp(): boolean;
+    forceMouseUp(): void;
+    private _dragM;
+    private _dragE;
+    addEvents(element: HTMLElement): void;
+    removeEvents(element: HTMLElement): void;
+    private _move2;
+    private _setState;
+    private _move;
+    private _longClick;
+    private _onUp;
+    private _getTouchPosition;
+    private _getTouchPositionRelative;
+    private _getMousePosition;
+    private _getFireFoxMousePosition;
+    private _getMousePositionRelative;
+    private _getDelta;
+    setDragEnabled(enabled: boolean): void;
+    handleEvent(evt: Event): void;
+    private _onKeyDown;
+    private _onKeyUp;
+    private _onMouseDown;
+    private _onMouseUp;
+    private _onMouseMove;
+    private _onDoubleClick;
+    private _onMouseLeave;
+    private _onMouseEnter;
+    private _onMouseWheel;
+    private _onTouchMove;
+    private _onTouchStart;
+    private _onTouchEnd;
+    private _onContextMenu;
+    protected _canDrag(_type: INPUT_EVENT_TYPE): boolean;
+    onElementHit(): void;
+    private _getBoundingClientRect;
+    updateSize(): void;
+}

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

@@ -0,0 +1,15 @@
+import { Context } from './di/context';
+
+export interface KernelAccessCallbackI {
+    isReady(): void;
+    loadError(error?: any): void;
+}
+export default class KernelAccessCallback implements Context, KernelAccessCallbackI {
+    _creator_: string;
+    private _callbackListener;
+    constructor(creator: string);
+    addListener(listener: KernelAccessCallbackI): void;
+    removeListener(listener: KernelAccessCallbackI): void;
+    isReady(): void;
+    loadError(error?: any): void;
+}

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

@@ -0,0 +1,28 @@
+import { Context } from './di/context';
+import { default as Logger } from './logger';
+import { ValuesFromObject } from './utils/common-utils';
+import { RapiId } from '../../typings/rapi-types';
+
+export interface KernelMessageMetaInfo {
+    componentId?: RapiId;
+    rapiId?: RapiId;
+    parentId?: number;
+}
+export declare const KERNEL_MESSAGE_TYPE: {
+    readonly EXCEPTION: "exception";
+    readonly ERROR: "error";
+    readonly WARNING: "warning";
+    readonly LOG: "log";
+};
+export type KernelMessageType = ValuesFromObject<typeof KERNEL_MESSAGE_TYPE>;
+export default class KernelIo extends Logger implements Context {
+    _creator_: string;
+    private _globalCallback;
+    private _meta;
+    constructor(creator: string);
+    setMeta(meta: object): void;
+    get meta(): KernelMessageMetaInfo;
+    throw(msg: string): void;
+    error(msg: string): void;
+    warn(msg: string): void;
+}

package/packages/web-sdk/packages/common-core/src/life-cycle-manager.d.ts

@@ -0,0 +1,13 @@
+export interface LifeCycleCallbacks {
+    pause: () => void;
+    resume: () => void;
+    destroy: () => void;
+}
+export default class LifeCycleManager implements LifeCycleCallbacks {
+    private _listeners;
+    addEventListener(listener: LifeCycleCallbacks): void;
+    removeEventListener(listener: LifeCycleCallbacks): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,13 @@
+import { Light, Object3D } from 'three';
+import { KernelLightSourceAttributes } from '../../../typings/kernel';
+
+export declare const generateLightSource: (lightSourceAttributes: KernelLightSourceAttributes) => Light | null;
+export declare class RoomleLightSource {
+    private _lightSourceId;
+    private _light;
+    constructor(lightSourceId: number, lightSource: Light);
+    get lightSourceId(): number;
+    addToScene(object3d: Object3D): void;
+    removeFromScene(): void;
+    updateLightSource(lightSourceAttributes: any): void;
+}

package/packages/web-sdk/packages/common-core/src/lightsetting/dynamic-light-setting-loader.d.ts

@@ -0,0 +1,60 @@
+import { SceneSettings } from '../scene-settings-loader';
+import { Light, RectAreaLight, Vector3 } from 'three';
+
+export declare const PREDEFINED_LIGHTSETTING: {
+    readonly SOFA: "sofa";
+    readonly SHELF: "shelf";
+    readonly SHELF_FRONT: "shelf_front";
+    readonly BAKED: "baked";
+    readonly CAMERA: "camera";
+    readonly EQUAL: "equal";
+};
+/**
+ * Description of fields:
+ - type: 'ambient'/'rectarea'/'spot'/'directional'
+ - name: set a name for this light to identify it more easily
+ - intensity: light intensity/brightness
+ - color: light color as hex ('#ffffff')
+ - position: position of the light, for example `{"x": 0,"y": 0, "z": 0}`, coords are right hand y up
+ - target: position to which the light should shine, defaults to center
+ - castShadow: defines if this light casts shadows
+ - angle: used for spotlights, defines the light cone of the spotlight
+ - penumbra: used for spotlights, defines how hard the edges of the light are
+ - width: used for rect area light, width of the area
+ - height: used for rect area light, height of the area
+ - movesWithCamera: if true the light will always have the same position and angle as the camera
+ */
+export interface DynamicLight {
+    type: string;
+    name?: string;
+    intensity?: number;
+    color?: string;
+    position?: Vector3;
+    target?: Vector3;
+    castShadow?: boolean;
+    angle?: number;
+    penumbra?: number;
+    width?: number;
+    height?: number;
+    movesWithCamera?: boolean;
+}
+type PreDefinedLightSettings = (typeof PREDEFINED_LIGHTSETTING)[keyof typeof PREDEFINED_LIGHTSETTING];
+export interface DynamicLightSettingSource {
+    url?: string;
+    json?: string;
+    object?: SceneSettings;
+    ls?: PreDefinedLightSettings;
+}
+export default class DynamicLightSettingLoader {
+    static rectAreaLightReplacement: boolean;
+    static rectAreaLightLoadingListener: ((lightSource: RectAreaLight) => void) | undefined;
+    static createDynamicLightSettingSource(dls: string, ls: string): DynamicLightSettingSource;
+    parse(json: string): Light[];
+    load(jsonObject: SceneSettings): Light[];
+    private _parseAmbientLight;
+    private _parseRectAreaLight;
+    private _parseSpotLight;
+    private _parseDirectionalLight;
+    private _parseCommon;
+}
+export {};

package/packages/web-sdk/packages/common-core/src/lightsetting/dynamic-light-setting.d.ts

@@ -0,0 +1,26 @@
+import { default as LightSetting } from './light-setting';
+import { SceneSettings } from '../scene-settings-loader';
+import { Box3, PerspectiveCamera, Scene, Vector3 } from 'three';
+
+export default class DynamicLightSetting extends LightSetting {
+    private _lights;
+    private _cameraLight;
+    private _boundingSize;
+    private _dynamicLightSettingLoader;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    needsBounds(): boolean;
+    updateBounds(bounds: Box3): void;
+    loadFromJSON(json: string): Promise<void>;
+    loadFromObject(sceneSettings: SceneSettings): Promise<void>;
+    loadFromURL(url: string): Promise<void>;
+    addToScene(): void;
+    update(camera: PerspectiveCamera, target: Vector3): void;
+    removeFromScene(): void;
+    reload(): void;
+    showGUI(): void;
+    private _addToGUI;
+    private _addRectAreaLightToGUI;
+    private _addSpotLightToGUI;
+    private _addAmbientLightToGUI;
+    private _addDirectionalLightToGUI;
+}

package/packages/web-sdk/packages/common-core/src/lightsetting/light-setting.d.ts

@@ -0,0 +1,14 @@
+import { Box3, Scene, Object3D } from 'three';
+
+export default abstract class LightSetting {
+    protected _scene: Scene;
+    private _cameraContainer;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    needsBounds(): boolean;
+    updateBounds(_bounds: Box3): void;
+    abstract addToScene(): void;
+    abstract removeFromScene(): void;
+    abstract reload(): void;
+    abstract showGUI(): void;
+    getCameraContainer(): Object3D;
+}