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

package/packages/web-sdk/packages/common-core/mock/three-mock.d.ts

@@ -0,0 +1,47 @@
+import { Texture } from 'three';
+
+export declare class MockHTMLCanvasElement extends HTMLCanvasElement {
+    toDataUrl(): string;
+}
+export declare class WebGLRendererMock {
+    setClearColor: () => void;
+    setPixelRatio: () => void;
+    setSize: () => void;
+    clear: () => void;
+    clearDepth: () => void;
+    render: () => void;
+    getClearColor: () => void;
+    getClearAlpha: () => void;
+    setClearAlpha: () => void;
+    getRenderTarget: () => void;
+    setRenderTarget: () => void;
+    readRenderTargetPixels: () => void;
+    compile: () => void;
+    extensions: {
+        get: () => boolean;
+    };
+    capabilities: {
+        getMaxAnisotropy: () => number;
+        maxTextures: number;
+    };
+    shadowMap: {
+        enabled: boolean;
+    };
+    getPixelRatio(): number;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    protected get domElement(): HTMLCanvasElement;
+}
+export declare class ThreeLoaderMock {
+    load(url: string, callback: (texture: Texture) => void): void;
+    parse(font: object): Texture;
+    setPath(_path: string): void;
+}
+export default class ThreeMock {
+    static setup(): void;
+    static teardown(): void;
+    static override(key: string, mock: any): void;
+    static dispatchEventOnCanvas(e: Event): void;
+}

package/packages/web-sdk/packages/common-core/mock/tween-mock.d.ts

@@ -0,0 +1,5 @@
+export declare const getTweenMock: (asyncBehavior?: boolean) => any;
+export default class TweenMock {
+    static setup(asyncBehavior?: boolean): void;
+    static teardown(): void;
+}

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

@@ -0,0 +1,12 @@
+export default class AsyncGuard<T> {
+    info: any;
+    private _promise;
+    private _resolve;
+    private _reject;
+    constructor(info?: any);
+    private _init;
+    resolve(value?: any): void;
+    reject(e: Error): void;
+    wait(): Promise<T>;
+    reset(): void;
+}

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

@@ -0,0 +1,6 @@
+import { default as CameraControl3D } from './camera-control-3d';
+import { default as CameraBehaviour } from './camera-behaviour';
+
+export default abstract class CameraBehaviour3d extends CameraBehaviour {
+    abstract get cameraControl(): CameraControl3D;
+}

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

@@ -0,0 +1,9 @@
+import { Context } from '../di/context';
+import { Box3, Vector3 } from 'three';
+
+export default class CameraBehaviourState implements Context {
+    _creator_: string;
+    private _lastPlanBounds;
+    constructor(creator: string);
+    isWithinPlanBounds(position: Vector3, updatedBounds?: Box3): boolean;
+}

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

@@ -0,0 +1,14 @@
+import { default as CameraControl } from './camera-control';
+import { default as CameraBehaviourState } from './camera-behaviour-state';
+
+export default abstract class CameraBehaviour {
+    protected _cameraControl: CameraControl;
+    private _state;
+    private _cameraChangeListener;
+    constructor(cameraControl: CameraControl, state: CameraBehaviourState);
+    abstract get cameraControl(): CameraControl;
+    protected get state(): CameraBehaviourState;
+    setCameraChangeListener(callback: () => void): void;
+    removeCameraChangeListener(): void;
+    protected _onCameraChanged(): void;
+}

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

@@ -0,0 +1,28 @@
+import { default as InputManager } from '../input/input-manager';
+import { default as CameraControl, CameraParameter } from './camera-control';
+import { OrthographicOffsetCamera } from '../webgl/roomle-component-factory';
+import { Box3, Vector3 } from 'three';
+
+export default class CameraControl2D extends CameraControl {
+    private _camera;
+    private _scale;
+    private _cameraZoom;
+    private _state;
+    private _size;
+    private _lastPosition;
+    private _zoomPosition;
+    private _lastZoom;
+    private _wasZooming;
+    private _zoomSpeed;
+    constructor(creator: string, inputManager: InputManager, initialCameraParameters?: CameraParameter, camera?: OrthographicOffsetCamera);
+    protected _getCamera(): OrthographicOffsetCamera;
+    private _initCamera;
+    updateCamera(): void;
+    protected _initInputListener(): void;
+    private _zoomTo;
+    private _move;
+    zoomToFitBounds(bounds: Box3, zoomInAllowed: boolean, force?: boolean): void;
+    protected _update(_overrideTarget?: Vector3, _ignoreChecks?: boolean | undefined, _keepVariables?: boolean | undefined): void;
+    animateCamera(delta: number): boolean;
+    getKernelZoomFactor(): number;
+}

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

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

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

@@ -0,0 +1,127 @@
+import { Listener, default as EventDispatcher } from '../../../configurator-core/src/utils/event-dispatcher';
+import { default as DomHelper } from '../utils/dom-helper';
+import { InputEvent, default as InputManager } from '../input/input-manager';
+import { Context } from '../di/context';
+import { default as InitData } from '../utils/init-data';
+import { Box3, Object3D, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
+import { default as GlobalInitData } from '../utils/global-init-data';
+import { Position2 } from '../common-interfaces';
+
+export declare const enum CAMERA_EVENT {
+    ORBIT_START = 0,
+    ORBIT_MOVE = 1,
+    ORBIT_END = 2,
+    ZOOM_IN = 3,
+    ZOOM_OUT = 4,
+    ZOOM_CHANGE = 5,
+    KEYBOARD_PRESSED = 6,
+    MOVING = 7,// general event when camera moves
+    IDLE = 8
+}
+export interface CameraParameter {
+    /**
+     * Yaw of the camera in radians
+     */
+    yaw?: number;
+    /**
+     * pitch of the camera in radians
+     */
+    pitch?: number;
+    /**
+     * Distance to the target position in meters
+     */
+    distance?: number;
+    /**
+     * X position where the camera should look at (in meters)
+     * targetX: 0 -> is in the middle of the object
+     */
+    targetX?: number;
+    /**
+     * Y position where the camera should look at (in meters)
+     * targetY: 0 -> is in on the bottom of the object (ground level)
+     */
+    targetY?: number;
+    /**
+     * Z position where the camera should look at (in meters)
+     * targetZ: 0 -> is in the middle of the object
+     */
+    targetZ?: number;
+    /**
+     * Field of view of the camera (in degree)
+     */
+    fov?: number;
+    /**
+     * Near clipping plane of the camera
+     */
+    near?: number;
+    /**
+     * Far clipping plane of the camera
+     */
+    far?: number;
+    /**
+     * Should this camera movement block other camera movements?
+     */
+    blockOtherTweens?: boolean;
+}
+export declare const INITIAL_YAW = -30;
+export declare const INITIAL_PITCH = 10;
+export declare const INITIAL_CAMERA_DISTANCE = -1;
+export declare const DEBUG_CAMERA_POSITION = "debug_camera_position";
+type PerspectiveOrOrthographicCamera = PerspectiveCamera | OrthographicCamera;
+export default abstract class CameraControl extends EventDispatcher<any> implements Context {
+    _creator_: string;
+    protected _domHelper: DomHelper;
+    protected _initData: InitData;
+    protected _globalInitData: GlobalInitData;
+    protected _width: number;
+    protected _height: number;
+    protected _boundingBox: Box3;
+    protected _cameraPosition: Vector3;
+    protected _targetPosition: Vector3;
+    protected _tweenEnd: CameraParameter;
+    private _stateSaved;
+    private _cameraStandingStill;
+    protected _pitch: number;
+    protected _yaw: number;
+    protected _distance: number;
+    protected _locked: boolean;
+    private _inputManager;
+    protected _inputListeners: Array<Listener<InputEvent>>;
+    protected _lerpEnabled: boolean;
+    constructor(creator: string, inputManager: InputManager, initialCameraParameters?: CameraParameter);
+    getCamera(): PerspectiveOrOrthographicCamera;
+    protected abstract _getCamera(): PerspectiveOrOrthographicCamera;
+    abstract updateCamera(): void;
+    protected abstract _initInputListener(): void;
+    private _addInputListeners;
+    private _removeInputListeners;
+    setUp(): void;
+    cleanUp(): void;
+    animateCamera(delta: number): boolean;
+    protected getDebugCameraPosition(): CameraParameter;
+    protected saveDebugCameraPosition(): void;
+    protected _dispatchCameraIdle(): void;
+    protected _tweenCameraParameter(start: CameraParameter, end: CameraParameter, ignoreChecks?: boolean): Promise<void>;
+    protected _setCameraNear(): void;
+    getCurrentCameraParameters(): CameraParameter;
+    setCurrentCameraParameters(cameraParameters: CameraParameter): void;
+    protected _rotateHorizontal(angle: number): void;
+    protected _rotateVertical(angle: number): void;
+    saveState(override: boolean): CameraParameter;
+    resetToState(): void;
+    setToState(start: CameraParameter, state: CameraParameter): Promise<void>;
+    hasSavedState(): boolean;
+    lock(): void;
+    unlock(): void;
+    isLocked(): boolean;
+    getTargetPosition(): Vector3;
+    protected _saveYawAndPitch(): void;
+    getInputPosition(position: Position2): Vector3;
+    addLightContainer(container: Object3D): void;
+    checkNearFarDistance(point: Vector3): void;
+    setBounds(boundingBox: Box3): void;
+    get domHelper(): DomHelper;
+    protected abstract _update(overrideTarget?: Vector3, ignoreChecks?: boolean | undefined, keepVariables?: boolean | undefined): void;
+    abstract getKernelZoomFactor(): number;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { Enumify } from '../types';
+
+export declare const CAMERA_TYPE: {
+    readonly CAMERA_2D: "2D";
+    readonly CAMERA_3D: "3D";
+    readonly CAMERA_FP: "FP";
+};
+export declare const sanitizedCameraMode: (mode: Enumify<typeof CAMERA_TYPE>) => Enumify<typeof CAMERA_TYPE>;

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

@@ -0,0 +1,22 @@
+import { default as CameraBehaviour } from './camera-behaviour';
+import { default as CameraControl3D } from './camera-control-3d';
+import { CameraParameter } from './camera-control';
+import { Box3 } from 'three';
+
+export default class ConfiguratorCameraBehaviour extends CameraBehaviour {
+    get cameraControl(): CameraControl3D;
+    resetCameraOnSceneClear(): void;
+    externalApiMoveCamera(cameraParameter: CameraParameter): Promise<void>;
+    externalApiZoomIn(value?: number): void;
+    externalApiZoomOut(value?: number): void;
+    externalApiResetCameraPosition(boundingBox: Box3): void;
+    disablePanningOnShiftRelease(): void;
+    enablePanningOnShiftClick(): void;
+    resetCameraToStartOnConfigurationLoaded(boundingBox: Box3): void;
+    updateBoundsOnPlanObjectUpdated(boundingBox: Box3): void;
+    updateBoundsOnCancelDockings(boundingBox: Box3): void;
+    zoomToComponentOnConsecutiveClick(cameraParameters: CameraParameter): Promise<void>;
+    resetCameraToStateOnCancelSelection(): void;
+    zoomToFitBoundsAfterUserInitiatedPreviews(boundingBox: Box3): void;
+    resetCameraOnStartConfiguring(boundingBox: Box3, cameraParameters: CameraParameter, rotation?: number, lookAtSide?: number): Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { default as CameraControl2D } from './camera-control-2d';
+import { default as PlannerCameraBehaviour } from './planner-camera-behaviour';
+import { Box3 } from 'three';
+import { CameraParameter } from './camera-control';
+
+export default class Planner2dCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControl2D;
+    resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    externalApiResetCameraPosition(bounds: Box3): void;
+    resetCameraOnSwitchTo2d(bounds: Box3): void;
+    updateCameraOnDrawWalls(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(_bounds: Box3): void;
+    updateCameraOnBackToPlanner(bounds: Box3, _startCameraParams: CameraParameter, _endCameraParams: CameraParameter): void;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}

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

@@ -0,0 +1,21 @@
+import { default as CameraControl3D } from './camera-control-3d';
+import { default as PlannerCameraBehaviour } from './planner-camera-behaviour';
+import { Box3 } from 'three';
+import { CameraParameter } from './camera-control';
+
+export default class Planner3dCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControl3D;
+    resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    externalApiResetCameraPosition(bounds: Box3): void;
+    resetCameraOnSwitchTo3d(bounds: Box3): void;
+    disablePanningOnShiftRelease(): void;
+    enablePanningOnShiftClick(): void;
+    updateCameraOnDrawWalls(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(bounds: Box3): void;
+    updateCameraOnBackToPlanner(_bounds: Box3, startCameraParams: CameraParameter, endCameraParams: CameraParameter): Promise<void>;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+    externalApiMoveCamera(cameraParameter: CameraParameter): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+import { Box3 } from 'three';
+import { default as CameraBehaviour } from './camera-behaviour';
+import { default as CameraControl, CameraParameter } from './camera-control';
+
+export default abstract class PlannerCameraBehaviour extends CameraBehaviour {
+    get cameraControl(): CameraControl;
+    abstract resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    abstract externalApiResetCameraPosition(bounds: Box3): void;
+    abstract updateCameraOnDrawWalls(bounds: Box3): void;
+    abstract updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    abstract updateCameraOnPlanElementInsertedInsideCurrentCameraView(bounds: Box3): void;
+    abstract updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    abstract updateCameraOnPlanElementRemoved(bounds: Box3): void;
+    abstract updateCameraOnBackToPlanner(bounds: Box3, startCameraParams: CameraParameter, endCameraParams: CameraParameter): void;
+    abstract resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}

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

@@ -0,0 +1,18 @@
+import { default as CameraControlFirstPerson } from '../../../planner-core/src/camera-control/camera-control-first-person';
+import { default as PlannerCameraBehaviour } from './planner-camera-behaviour';
+import { Box3 } from 'three';
+import { CameraParameter } from './camera-control';
+
+export default class PlannerFpCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControlFirstPerson;
+    resetCameraOnPlanCompletelyLoaded(_bounds: Box3): void;
+    externalApiResetCameraPosition(_bounds: Box3): void;
+    updateCameraOnDrawWalls(_bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(_bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(_bounds: Box3): void;
+    updateCameraOnBackToPlanner(_bounds: Box3, _startCameraParams: CameraParameter, _endCameraParams: CameraParameter): void;
+    resetCameraOnEnableWallDrawing(_bounds: Box3): void;
+    resetCameraOnSwitchToFirstPerson(): void;
+}

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

@@ -0,0 +1,20 @@
+import { KernelComponent, KernelLightSourceAttributes, KernelMeshAttributes, KernelMeshBuffer, KernelVector3 } from '../../typings/kernel';
+
+export interface CommonConfiguratorKernelCallbackI {
+    Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentObjectRuntimeId: number): void;
+    Editor3dAddMesh(runtimeComponentId: number, meshId: number, geometryName: string, environmentGeometry: boolean, meshAttributes: KernelMeshAttributes, meshBuffer: KernelMeshBuffer): void;
+    Editor3ChangedMesh(runtimeComponentId: number, meshId: number, geometryName: string, meshAttributes: KernelMeshAttributes): void;
+    Editor3dRemoveMesh(runtimeComponentId: number, meshId: number): void;
+    componentMetaUpdated(kernelComponent: KernelComponent): void;
+    componentConfigurationUpdated(runtimeComponentId: number, geometryChanged: boolean): void;
+    Editor3dBeginConstruction(componentId: number, isDeltaUpdate: boolean): void;
+    Editor3dEndConstruction(id: number): void;
+    Editor3dComponentDocked(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    Editor3dGeometryReady(id: number): void;
+    Editor3dGeometryNotReady(id: number): void;
+    componentDeleted(componentId: number): void;
+    sceneCleared(): void;
+    Editor3dRemoveLightSource(runtimeComponentId: number, lightSourceId: number): void;
+    Editor3dAddLightSource(runtimeComponentId: number, lightSourceId: number, lightSourceAttributes: KernelLightSourceAttributes): void;
+    Editor3dChangedLightSource(runtimeComponentId: number, lightSourceId: number, lightSourceAttributes: KernelLightSourceAttributes): void;
+}

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

@@ -0,0 +1,38 @@
+import { Base64String } from '../../typings/rapi-types';
+
+/**
+ * Used to set the camera offset of the canvas, for example this is useful
+ * if you have UI elements which should not overlap with the product you
+ * want to show
+ *
+ * Example:
+ * ```
+ * {
+ *     left: 0.1, // 10% offset from left
+ *     top: 0.2, // 20% offset from top
+ *     right: 0.85, // 15% offset from right
+ *     bottom: 0.95 // 5% offset from bottom
+ * }
+ * ```
+ */
+export interface CanvasOffset {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface Position2 {
+    x: number;
+    y: number;
+}
+export interface Position3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Base64Image {
+    image: Base64String;
+    width: number;
+    height: number;
+    blob: Blob;
+}