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

package/lib/definitions/packages/common-core/mock/kernel-instances.d.ts

@@ -0,0 +1,222 @@
+import type { KernelObject, PlanOverview } from '../../typings/planner';
+import PlanViewModel from '../../planner-core/src/view-model/plan-view-model';
+import type { KernelAnimation, KernelParameter, KernelPossibleChild } from '../../typings/kernel';
+export declare const extendKernelInstanceMock: <T>(methods: T) => {
+    setEnvironmentVariable: () => void;
+    useEnvironmentGeometry: () => void;
+    loadConfiguration: () => void;
+    clearScene: () => void;
+    getPlanObject: () => any;
+    getFullPartList: () => any;
+    getPartList: () => any;
+    getHashOfConfiguration: () => string;
+    getSerializedConfiguration: () => string;
+    getComponentId: () => number;
+    isExternalPlanObject: () => boolean;
+    setLevel: () => void;
+    setUpdateCallbacksOnlyIfGeometryIsReady: () => void;
+    setAssetInvalid: () => void;
+    setDockInsertPreviewBoxParameters: () => void;
+    getPlanObjectFromPlanComponent: () => any;
+    getPlanObjectParameters: () => KernelParameter[];
+    getPlanObjectAnimations: () => KernelAnimation[];
+    getRootPlanComponentIdFromObjectId: () => number;
+    getComponentParameters: () => KernelParameter[];
+    getPlanComponentAnimations: () => KernelParameter[];
+    getComponent: () => any;
+    getPlanObjectPossibleChildren: () => KernelPossibleChild[];
+} | T;
+export declare const extendKernelContainerMock: (methods: object) => {
+    setExternalHelpers: () => void;
+    registerConfiguratorCallback: () => void;
+    registerPlannerCallback: () => void;
+    unregisterConfiguratorCallback: () => void;
+    PlanInteractionHandler: () => void;
+    PlanModelViewHelper: {
+        getPlanOverview: () => PlanOverview;
+    };
+    UnitMeasureFormatter: () => void;
+    Unit: {};
+    UnitStringType: {};
+    LongArray: () => void;
+    DrawingType: {
+        CLICK_PER_CLICK: number;
+    };
+    SnapMode: {
+        OFF: number;
+        ON_COLLISION: number;
+        ON_COLLISION_ROTATE_WITHIN_DISTANCE: number;
+        WITHIN_SNAP_DISTANCE: number;
+    };
+    CatalogItem: {
+        new (): {
+            size: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+    };
+    CatalogItemPtrList: {
+        new (): {
+            push_back(kernelObject: KernelObject): void;
+        };
+    };
+    EMSReference: () => void;
+    WallType: {
+        StandAloneWall: {
+            value: number;
+        };
+        OuterWallLeft: {
+            value: number;
+        };
+        OuterWallRight: {
+            value: number;
+        };
+        InnerWall: {
+            value: number;
+        };
+    };
+} & object;
+export declare const MOCK_MINIMAL_KERNEL_INSTANCE: {
+    setEnvironmentVariable: () => void;
+    useEnvironmentGeometry: () => void;
+    loadConfiguration: () => void;
+    clearScene: () => void;
+    getPlanObject: () => any;
+    getFullPartList: () => any;
+    getPartList: () => any;
+    getHashOfConfiguration: () => string;
+    getSerializedConfiguration: () => string;
+    getComponentId: () => number;
+    isExternalPlanObject: () => boolean;
+    setLevel: () => void;
+    setUpdateCallbacksOnlyIfGeometryIsReady: () => void;
+    setAssetInvalid: () => void;
+    setDockInsertPreviewBoxParameters: () => void;
+    getPlanObjectFromPlanComponent: () => any;
+    getPlanObjectParameters: () => KernelParameter[];
+    getPlanObjectAnimations: () => KernelAnimation[];
+    getRootPlanComponentIdFromObjectId: () => number;
+    getComponentParameters: () => KernelParameter[];
+    getPlanComponentAnimations: () => KernelParameter[];
+    getComponent: () => any;
+    getPlanObjectPossibleChildren: () => KernelPossibleChild[];
+};
+export declare class MockConfiguratorKernel {
+}
+export declare const getMockMinimalKernelContainer: (kernelInstance?: any) => {
+    setExternalHelpers: () => void;
+    registerConfiguratorCallback: () => void;
+    registerPlannerCallback: () => void;
+    unregisterConfiguratorCallback: () => void;
+    PlanInteractionHandler: () => void;
+    PlanModelViewHelper: {
+        getPlanOverview: () => PlanOverview;
+    };
+    UnitMeasureFormatter: () => void;
+    Unit: {};
+    UnitStringType: {};
+    LongArray: () => void;
+    DrawingType: {
+        CLICK_PER_CLICK: number;
+    };
+    SnapMode: {
+        OFF: number;
+        ON_COLLISION: number;
+        ON_COLLISION_ROTATE_WITHIN_DISTANCE: number;
+        WITHIN_SNAP_DISTANCE: number;
+    };
+    CatalogItem: {
+        new (): {
+            size: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+    };
+    CatalogItemPtrList: {
+        new (): {
+            push_back(kernelObject: KernelObject): void;
+        };
+    };
+    EMSReference: () => void;
+    WallType: {
+        StandAloneWall: {
+            value: number;
+        };
+        OuterWallLeft: {
+            value: number;
+        };
+        OuterWallRight: {
+            value: number;
+        };
+        InnerWall: {
+            value: number;
+        };
+    };
+};
+export declare const MOCK_MINIMAL_KERNEL_CONTAINER: {
+    setExternalHelpers: () => void;
+    registerConfiguratorCallback: () => void;
+    registerPlannerCallback: () => void;
+    unregisterConfiguratorCallback: () => void;
+    PlanInteractionHandler: () => void;
+    PlanModelViewHelper: {
+        getPlanOverview: () => PlanOverview;
+    };
+    UnitMeasureFormatter: () => void;
+    Unit: {};
+    UnitStringType: {};
+    LongArray: () => void;
+    DrawingType: {
+        CLICK_PER_CLICK: number;
+    };
+    SnapMode: {
+        OFF: number;
+        ON_COLLISION: number;
+        ON_COLLISION_ROTATE_WITHIN_DISTANCE: number;
+        WITHIN_SNAP_DISTANCE: number;
+    };
+    CatalogItem: {
+        new (): {
+            size: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+    };
+    CatalogItemPtrList: {
+        new (): {
+            push_back(kernelObject: KernelObject): void;
+        };
+    };
+    EMSReference: () => void;
+    WallType: {
+        StandAloneWall: {
+            value: number;
+        };
+        OuterWallLeft: {
+            value: number;
+        };
+        OuterWallRight: {
+            value: number;
+        };
+        InnerWall: {
+            value: number;
+        };
+    };
+};
+export declare const MOCK_PLAN_INTERACTION_HANDLER: {
+    addPlanObjects: () => void;
+    startInteraction: () => void;
+    endInteraction: () => void;
+    getPlan: () => {
+        extRef: {
+            jsObject: PlanViewModel;
+        };
+    };
+    removeElement: () => void;
+};

package/lib/definitions/packages/common-core/mock/mock-camera-parameters.d.ts

@@ -0,0 +1,16 @@
+export declare const MOCK_1_CAMERA_PARAMETER: {
+    yaw: number;
+    pitch: number;
+    distance: number;
+    targetX: number;
+    targetY: number;
+    targetZ: number;
+};
+export declare const MOCK_2_CAMERA_PARAMETER: {
+    yaw: number;
+    pitch: number;
+    distance: number;
+    targetX: number;
+    targetY: number;
+    targetZ: number;
+};

package/lib/definitions/packages/common-core/mock/mock-draco-loader.d.ts

@@ -0,0 +1,6 @@
+import { Loader } from 'three';
+export declare class DracoLoaderMock extends Loader {
+    setDecoderPath(path: string): void;
+    _loadLibrary(): void;
+    setDecoderConfig(): void;
+}

package/lib/definitions/packages/common-core/mock/mock-gltf-loader.d.ts

@@ -0,0 +1,9 @@
+import { Loader } from 'three';
+export declare class GLTFLoaderMock extends Loader {
+    dracoLoader: any;
+    constructor(manager: any);
+    load(_url: string, callback: (arg: any) => void): void;
+    setDRACOLoader(dracoLoader: any): void;
+    parse(_data: ArrayBuffer | string, _path: string, onLoad: (gltf: any) => void, _onError?: (event: ErrorEvent) => void): void;
+}
+export { GLTFLoaderMock as GLTFLoader };

package/lib/definitions/packages/common-core/mock/mock-idb-manager.d.ts

@@ -0,0 +1,19 @@
+import type { SavedIdbData, UseIdbStore } from '../src/types';
+import type { Context } from '../src/di/context';
+export default class MockIdbManager implements Context {
+    _creator_: string;
+    private _initData;
+    readonly configStore: UseIdbStore | null;
+    constructor(creator: string);
+    private get allStores();
+    private _getValue;
+    private _setValue;
+    private _getEntries;
+    deleteValue(key: IDBValidKey, objStore: UseIdbStore): Promise<void>;
+    private _createStore;
+    getKey(...args: string[]): string;
+    setValue<T>(key: string, value: T, store: UseIdbStore): Promise<void>;
+    getValue<T>(key: IDBValidKey, store: UseIdbStore): Promise<SavedIdbData<T> | undefined>;
+    clearStore(objStore: UseIdbStore): Promise<void>;
+    pruneOldEntries(): Promise<void>;
+}

package/lib/definitions/packages/common-core/mock/mock-image-renderer.d.ts

@@ -0,0 +1,18 @@
+import type { RoomleWebGLRenderer } from '../src/webgl/roomle-webgl-renderer';
+import type { Box3, PerspectiveCamera, Scene, Texture } from 'three';
+import type { Base64Image } from '../src/common-interfaces';
+import type { CameraTarget, PrepareImageOptions } from '../src/webgl/image-renderer';
+export default class MockImageRenderer {
+    private _roomleRenderer;
+    constructor(roomleRenderer?: RoomleWebGLRenderer);
+    private _getRoomleRenderer;
+    setEnvMap(scene: Scene, envMap: Texture): void;
+    switchToPlannerSettings(): void;
+    switchToConfiguratorSettings(): void;
+    static getCameraTargetForBBox(bbox: Box3, spacing?: number): CameraTarget;
+    preparePerspectiveImage(_scene: Scene, _uiScene: Scene, _camera: PerspectiveCamera, _cameraTarget: CameraTarget, _options?: PrepareImageOptions, _objectRotation?: number): Promise<Base64Image>;
+    renderPerspectiveImage(_scene: Scene, _camera: PerspectiveCamera, _cameraTarget: CameraTarget, _size?: number): Promise<Base64Image>;
+    static placeCameraForPerspectiveImage(camera: PerspectiveCamera, cameraTarget: CameraTarget, angleX: number, angleY: number): void;
+    prepareTopImage(_scene: Scene, _uiScene: Scene, _cameraTarget: CameraTarget, _options?: PrepareImageOptions): Promise<Base64Image>;
+    private _render;
+}

package/lib/definitions/packages/common-core/mock/mock-input-event-dispatcher.d.ts

@@ -0,0 +1,11 @@
+import type { Position2 } from '../src/common-interfaces';
+export default class MockInputEventDispatcher {
+    private _element;
+    constructor(element: HTMLElement);
+    getElement(): HTMLElement;
+    dispatchTouchEvent(type: string, { x, y }: Position2): void;
+    dispatchDoubleTouchEvent(type: string, pos0: Position2, pos1: Position2, timeToAdd?: number): void;
+    dispatchMouseEvent(type: string, { x, y }: Position2, options?: any): void;
+    dispatchGenericEvent(type: string, { x, y }: Position2): void;
+    dispatchEvent(event: Event, options?: any): void;
+}

package/lib/definitions/packages/common-core/mock/mock-rapi-types.d.ts

@@ -0,0 +1,94 @@
+import type { RapiBaseColor, RapiItem, RapiJson, RapiMaterial, RapiPrice, RapiSkin, RapiTenant, UnNormalizedRapiConfiguratorSettings } from '../../typings/rapi-types';
+import { RAPI_TEXTURE_TYPE } from '../../typings/rapi-types';
+export declare const cloneMockObject: (object: any) => any;
+export declare const MOCK_RAPI_BASE_COLOR: RapiBaseColor;
+export declare const MOCK_RAPI_EMISSIVE_COLOR: RapiBaseColor;
+export declare const MOCK_RAPI_SHEEN_COLOR: RapiBaseColor;
+export declare const MOCK_RAPI_SPECULAR_COLOR: RapiBaseColor;
+export declare const MOCK_RAPI_ATTENUATION_COLOR: RapiBaseColor;
+export declare const MOCK_RAPI_TEXTURES_EMPTY: any[];
+export declare const MOCK_RAPI_MATERIAL: RapiMaterial;
+export declare const MOCK_RAPI_MATERIAL_V2: RapiMaterial;
+export declare const MOCK_RAPI_MATERIAL_NO_TEXTURES: RapiMaterial;
+export declare const MOCK_RAPI_TENANT: RapiTenant;
+export declare const MOCK_RAPI_SKIN: RapiSkin;
+export declare const MOCK_RAPI_ITEM: RapiItem;
+export declare const MOCK_RAPI_TEXTURE: {
+    id: number;
+    material: string;
+    image: string;
+    url: string;
+    height: number;
+    width: number;
+    mmHeight: number;
+    mmWidth: number;
+    tileable: boolean;
+    mapping: RAPI_TEXTURE_TYPE;
+};
+export declare const MOCK_RAPI_NORMAL_TEXTURE: {
+    id: number;
+    material: string;
+    image: string;
+    url: string;
+    height: number;
+    width: number;
+    mmHeight: number;
+    mmWidth: number;
+    tileable: boolean;
+    mapping: RAPI_TEXTURE_TYPE;
+};
+export declare const MOCK_RAPI_PRICES: RapiPrice;
+export declare const MOCK_RAPI_CONFIGURATOR: UnNormalizedRapiConfiguratorSettings;
+export declare const MOCK_RAPI_USER_ACTION: {
+    id: string;
+    date: string;
+    module: number;
+    action: number;
+    actionId: string;
+    actionLabel: string;
+    country: string;
+    tenant: number;
+    device: number;
+    count: number;
+    aggregationLevel: number;
+};
+export declare const MOCK_ASSET_PROCESSING: {
+    id: string;
+    sourceSettings: {
+        export: {
+            formats: {
+                file_format: string;
+                pack_external_data: boolean;
+            }[];
+        };
+        import_config: {
+            configuration_id: string;
+            quality: number;
+        };
+        rapiContext: {
+            configuratorId: string;
+            tenant: number;
+        };
+    };
+    type: number;
+    status: number;
+    tenantId: number;
+    updated: string;
+    created: string;
+};
+export declare const MOCK_RAPI_CONFIGURABLE_ITEM: RapiItem;
+export declare const wrapIntoRapiBox: (key: string, data: RapiJson | RapiJson[]) => {
+    [x: string]: {};
+    meta: {};
+} | {
+    [x: string]: RapiJson;
+    meta?: undefined;
+};
+export declare const getResponseObject: (data: any) => Promise<{
+    headers: {
+        get: (header: string) => "application/json";
+    };
+    ok: boolean;
+    status: number;
+    json: () => Promise<any>;
+}>;

package/lib/definitions/packages/common-core/mock/mock-utils.d.ts

@@ -0,0 +1,25 @@
+import type { RoomleComponent } from '../src/webgl/roomle-component-factory';
+import type { KernelComponent, PlanObject } from '../../typings/kernel';
+import type { Object3D } from 'three';
+/**
+ * usage: await sleep(1);
+ * will block execution only in this thread
+ * @param ms
+ */
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function muteConsole(methods?: string[]): void;
+export declare function unmuteConsole(methods?: string[]): void;
+/**
+ * Returns number of occurrences
+ * @param objects
+ * @param type
+ */
+export declare function numberOfObjectsWithType(objects: Object3D[], type: string): number;
+export declare function createMockRoomleComponent(): RoomleComponent;
+export declare function createMockPlanObject(): PlanObject;
+export declare function createMockKernelComponent(): KernelComponent;
+export declare function createMockRoomleComponents(): {
+    roomleComponent: RoomleComponent;
+    roomlePreviewComponent: import("../src/webgl/roomle-component-factory").PreviewComponent;
+    previewLineComponent: import("../src/webgl/roomle-component-factory").PreviewLineComponent;
+};

package/lib/definitions/packages/common-core/mock/rapi-globals.d.ts

@@ -0,0 +1,6 @@
+export default class RapiGlobals {
+    private _envHasNoHeadersObject;
+    private _envHasNoRequestObject;
+    prepareGlobals(): void;
+    cleanUpGlobals(): void;
+}

package/lib/definitions/packages/common-core/mock/three-mock.d.ts

@@ -0,0 +1,45 @@
+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;
+    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/lib/definitions/packages/common-core/mock/tween-mock.d.ts

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

package/lib/definitions/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/lib/definitions/packages/common-core/src/cameracontrol/camera-behaviour-3d.d.ts

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

package/lib/definitions/packages/common-core/src/cameracontrol/camera-behaviour-state.d.ts

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

package/lib/definitions/packages/common-core/src/cameracontrol/camera-behaviour.d.ts

@@ -0,0 +1,13 @@
+import type CameraControl from './camera-control';
+import type 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/lib/definitions/packages/common-core/src/cameracontrol/camera-control-2d.d.ts

@@ -0,0 +1,27 @@
+import type InputManager from '../input/input-manager';
+import CameraControl from './camera-control';
+import type { OrthographicOffsetCamera } from '../webgl/roomle-component-factory';
+import type { Box3 } from 'three';
+import { 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 _zoomSpeed;
+    constructor(creator: string, inputManager: InputManager, initialCameraPosition?: Vector3, 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): void;
+    animateCamera(delta: number): boolean;
+    getKernelZoomFactor(): number;
+}

package/lib/definitions/packages/common-core/src/cameracontrol/camera-control-3d.d.ts

@@ -0,0 +1,81 @@
+import type InputManager from '../input/input-manager';
+import type { CameraParameter } from './camera-control';
+import CameraControl from './camera-control';
+import type { PerspectiveOffsetCamera } from '../webgl/roomle-component-factory';
+import { type 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;
+    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, initialCameraPosition?: Vector3, camera?: PerspectiveOffsetCamera);
+    protected _getCamera(): PerspectiveCamera;
+    getCamera(): PerspectiveOffsetCamera;
+    private _initCamera;
+    setObjectRotation(objectRotation: 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;
+    updateAndReset(boundingBox: Box3, animate?: boolean): void;
+    protected _update(overrideTarget?: Vector3, ignoreChecks?: boolean | undefined): 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;
+}