@lumiscaphe/viewer 4.1.13 → 4.1.15

package/dist/lib/index.d.ts

@@ -0,0 +1,833 @@
+import { m4 } from 'twgl.js';
+import { v3 } from 'twgl.js';
+
+declare interface Animation_2 {
+    name: string;
+    camera: any;
+    duration: number;
+    reverse?: boolean;
+    loop?: boolean;
+}
+export { Animation_2 as Animation }
+
+declare class Canvas2D {
+    element: HTMLCanvasElement;
+    image?: HTMLImageElement;
+    fit: 'contain' | 'cover' | 'fill';
+    private context;
+    private backCanvas;
+    private backContext;
+    private pixelRatio;
+    private requestAnimationId?;
+    constructor(fit: 'contain' | 'cover' | 'fill');
+    destroy(): void;
+    show(useDisplay: boolean): void;
+    hide(useDisplay: boolean): void;
+    get resolution(): Resolution;
+    resize(width: number, height: number, pixelRatio: number): void;
+    draw(img: HTMLImageElement, fade: boolean, speed?: number): void;
+    private fadeLoop;
+}
+
+declare class Canvas3D {
+    element: HTMLCanvasElement;
+    context: WebGLRenderingContext | undefined;
+    constructor();
+    show(): void;
+    hide(): void;
+    resize(width: number, height: number, pixelRatio: number): void;
+}
+
+export declare interface Encoder {
+    format: string;
+    compression?: number;
+    quality?: number;
+}
+
+export declare interface Hotspot {
+    id: string;
+    name: string;
+    position2D: {
+        x: number;
+        y: number;
+    };
+    position3D: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    visibility: 'Visible' | 'Occluded' | 'Clipped' | 'OutOfFrustum';
+}
+
+export declare type ImageScene = string;
+
+declare class Loader {
+    private webrender;
+    private webrenderV2?;
+    private delegate?;
+    private loadingId;
+    private loaded;
+    private total;
+    private databases;
+    constructor(server: string, api: string, delegate: LoaderDelegate);
+    get progress(): number;
+    loadImageSnapshot(snapshot: Snapshot): Promise<HTMLImageElement>;
+    loadVideoSnapshot(video: HTMLVideoElement, snapshot: Snapshot): Promise<any>;
+    loadVRCubeSnapshot(snapshot: Snapshot): Promise<HTMLImageElement[]>;
+    loadVRObjectSnapshot(snapshot: Snapshot, position: number): Promise<Promise<HTMLImageElement>[]>;
+    private loadImage;
+    private loadImageFrames;
+    private loadVideo;
+    private loadVideoFrame;
+    private loadVideoFrames;
+    loadImageHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[]>;
+    loadVRCubeHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[][]>;
+    loadVRObjectHotspots(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>): Promise<Hotspot[][]>;
+    loadImagePick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    loadVRObjectPick(snapshot: Snapshot, position: WRAPIv2.Vector2D, index: number, frames: number): Promise<WRAPIv2.PickResult>;
+    loadVRCubePick(snapshot: Snapshot, position: WRAPIv2.Vector2D, face: string): Promise<WRAPIv2.PickResult>;
+    private convert;
+    private vrObjectFrameSnapshot;
+    private vrCubeFrameSnapshot;
+    private onLoadStart;
+    private onLoadProgress;
+    private onLoadEnd;
+    private static isValidHttpUrl;
+}
+
+declare interface LoaderDelegate {
+    onLoadStart: (progress: number) => void;
+    onLoadProgress: (progress: number) => void;
+    onLoadEnd: (progress: number) => void;
+}
+
+export declare interface Options {
+    server: string;
+    api: string;
+    autores: boolean;
+    fit: 'contain' | 'cover' | 'fill';
+    image: any;
+    video: any;
+    vrcube: any;
+    vrobject: any;
+    events: any;
+}
+
+declare interface Parameters_2 {
+    width?: number;
+    height?: number;
+    antialiasing: boolean;
+    superSampling: number;
+    imageFormat?: string;
+    imageQuality?: number;
+    softwareAntialiasing?: boolean;
+}
+export { Parameters_2 as Parameters }
+
+declare class PointOfView {
+    target: v3.Vec3;
+    eye: v3.Vec3;
+    up: v3.Vec3;
+    static readonly default: PointOfView;
+    static initCubeFace(eye: v3.Vec3, target: v3.Vec3, face: string): PointOfView;
+    constructor(target: v3.Vec3, eye: v3.Vec3, up: v3.Vec3);
+    get viewVector(): v3.Vec3;
+    get rightVector(): v3.Vec3;
+    get viewMatrix(): m4.Mat4;
+    clone(): PointOfView;
+}
+
+declare class Resolution {
+    width: number;
+    height: number;
+    constructor(width: number, height: number);
+    get aspect(): number;
+}
+
+export declare type Scene = ImageScene | WebRenderScene | WRAPIv2.Scene;
+
+declare interface Snapshot {
+    scene: Scene[];
+    view: View;
+    parameters: Parameters_2;
+    encoder: Encoder;
+}
+
+export declare interface Transition {
+    fromPosition: number;
+    toPosition: number;
+    animation: Animation_2;
+}
+
+declare class Video {
+    element: HTMLVideoElement;
+    constructor();
+    show(): void;
+    hide(): void;
+    resize(width: number, height: number, resolution: Resolution, fit: 'contain' | 'cover' | 'fill'): void;
+}
+
+export declare interface View {
+    mode: string;
+    camera?: string | any;
+    background?: string;
+    animation?: string;
+    frames?: number;
+    loop?: boolean;
+    cameraGroup?: any;
+    panFrom?: number;
+    panTo?: number;
+    panFrames?: number;
+    panLoop?: boolean;
+    tiltFrom?: number;
+    tiltTo?: number;
+    tiltFrames?: number;
+    tiltLoop?: boolean;
+    duration?: number;
+    reverse?: boolean;
+    fps?: number;
+}
+
+export declare class Viewer {
+    options: Options;
+    private container;
+    private containerWidth;
+    private containerHeight;
+    private canvas2D;
+    private canvas3D;
+    private video;
+    private loader;
+    private scene?;
+    private view?;
+    private parameters;
+    private encoder;
+    private hotspots;
+    private resolution;
+    private widget;
+    private widgetImage;
+    private widgetVideo;
+    private widgetVRCube;
+    private widgetVRObject;
+    private isDestroyed;
+    constructor(container: HTMLElement, options: Partial<Options>);
+    destroy(): void;
+    load(scene: Scene | Scene[], transition?: Transition): Promise<void>;
+    setEncoder(encoder: Encoder): Promise<void>;
+    setParameters(parameters: Parameters_2): Promise<void>;
+    setHotspots(hotspots: Array<string | WRAPIv2.Vector3D>): void;
+    setView(view: View, transition?: Transition): Promise<void>;
+    setVrcube(data: Partial<WidgetVRCube>): void;
+    setVrobject(data: Partial<WidgetVRObject>): void;
+    private loadAnimation;
+    playAnimation(animation: Animation_2): Promise<void>;
+    stopAnimation(): void;
+    pick(position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    pickHotspot(position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    snapshot(type: string, quality: number): string;
+    private loadWidget;
+    private get viewWidget();
+    private checkResize;
+    private onMouseDown;
+    private onMouseEnter;
+    private onMouseMove;
+    private onMouseUp;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private onDeviceOrientation;
+    private onResize;
+    private onVrcubeInteraction;
+    private onVrobjectInteraction;
+    private onHotspotsChange;
+    onLoadStart(...args: any[]): void;
+    onLoadProgress(...args: any[]): void;
+    onLoadEnd(...args: any[]): void;
+    private onLoadError;
+}
+
+export declare interface WebRenderScene {
+    database: string;
+    configuration?: string;
+    animations?: string[];
+    translation?: {
+        x: number;
+        y: number;
+    };
+    accessory?: boolean;
+    decor?: boolean;
+}
+
+export declare interface Widget {
+    destroy(): void;
+    show(): void;
+    hide(): void;
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    hotspots(resolution: Resolution): Hotspot[];
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    snapshot(type: string, quality: number): string;
+    onMouseDown(e: MouseEvent): void;
+    onMouseEnter(e: MouseEvent): void;
+    onMouseMove(e: MouseEvent): void;
+    onMouseUp(e: MouseEvent): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    onDeviceOrientation(e: DeviceOrientationEvent): void;
+}
+
+export declare class WidgetImage implements Widget {
+    private container;
+    private canvas;
+    private loader;
+    private image?;
+    private hotspotList;
+    private hotspotsHash?;
+    private snapshotHash?;
+    constructor(container: HTMLElement, canvas: Canvas2D, loader: Loader);
+    destroy(): void;
+    show(): void;
+    hide(): void;
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(resolution: Resolution): Hotspot[];
+    snapshot(type: string, quality: number): string;
+    onMouseDown(e: MouseEvent): void;
+    onMouseMove(e: MouseEvent): void;
+    onMouseUp(e: MouseEvent): void;
+    onMouseEnter(e: MouseEvent): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    onDeviceOrientation(e: DeviceOrientationEvent): void;
+}
+
+export declare class WidgetVideo implements Widget {
+    private container;
+    private loader;
+    private video;
+    private hash?;
+    constructor(container: HTMLElement, video: Video, loader: Loader);
+    destroy(): void;
+    show(): void;
+    hide(): void;
+    load(snapshot: Snapshot): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(resolution: Resolution): Hotspot[];
+    snapshot(type: string, quality: number): string;
+    play(): Promise<void>;
+    onMouseDown(e: MouseEvent): void;
+    onMouseMove(e: MouseEvent): void;
+    onMouseUp(e: MouseEvent): void;
+    onMouseEnter(e: MouseEvent): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    onDeviceOrientation(e: DeviceOrientationEvent): void;
+}
+
+export declare class WidgetVRCube implements Widget {
+    private container;
+    private canvas;
+    private loader;
+    private images;
+    private hotspotsList;
+    private interaction;
+    private onInteraction;
+    private gl;
+    private programInfo;
+    private quad;
+    private uniforms;
+    private hotspotsHash?;
+    private snapshotHash?;
+    private animationFrameId?;
+    constructor(container: HTMLElement, canvas: Canvas3D, loader: Loader, onInteraction: (...args: any[]) => void);
+    destroy(): void;
+    show(): void;
+    hide(): void;
+    get pov(): PointOfView;
+    set pov(pov: PointOfView);
+    get fov(): number;
+    set fov(fov: number);
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(): Hotspot[];
+    snapshot(type: string, quality: number): string;
+    private get modelViewProjectionMatrix();
+    render(): void;
+    onMouseDown(e: MouseEvent): void;
+    onMouseMove(e: MouseEvent): void;
+    onMouseUp(e: MouseEvent): void;
+    onMouseEnter(e: MouseEvent): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    onDeviceOrientation(e: DeviceOrientationEvent): void;
+}
+
+export declare class WidgetVRObject implements Widget {
+    private container;
+    private canvas;
+    private loader;
+    private images;
+    private frames;
+    private hotspotsList;
+    private interaction;
+    private onInteraction;
+    private hotspotsHash?;
+    private snapshotHash?;
+    private animationFrameId?;
+    constructor(container: HTMLElement, canvas: Canvas2D, loader: Loader, onInteraction: (...args: any[]) => void);
+    destroy(): void;
+    show(): void;
+    hide(): void;
+    goto(position: number): Promise<void>;
+    get position(): number;
+    set position(position: number);
+    get image(): HTMLImageElement;
+    load(snapshot: Snapshot, hotspots: Array<string | WRAPIv2.Vector3D>, reset: boolean, fade: boolean): Promise<void>;
+    pick(snapshot: Snapshot, position: WRAPIv2.Vector2D): Promise<WRAPIv2.PickResult>;
+    hotspots(resolution: Resolution): Hotspot[];
+    snapshot(type: string, quality: number): string;
+    onMouseDown(e: MouseEvent): void;
+    onMouseMove(e: MouseEvent): void;
+    onMouseUp(e: MouseEvent): void;
+    onMouseEnter(e: MouseEvent): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    onDeviceOrientation(e: DeviceOrientationEvent): void;
+}
+
+export declare namespace WRAPIv1 {
+    export interface RequestRender {
+        databaseId: string;
+        configuration?: string;
+        animations?: string;
+        accessoryDatabaseId?: string;
+        decorDatabaseId?: string;
+        decorDeltaAltitude?: number;
+        background?: string;
+        width: number;
+        height: number;
+        softwareAntialiasing: boolean;
+        superSampling: number;
+        imageFormat: string;
+        imageQuality: number;
+    }
+    export interface RequestRenderBatchCubeFromBookmark extends RequestRender {
+        bookmarkSet: string;
+        bookmark: string;
+    }
+    export interface RequestRenderBatchImagesFromAnimation extends RequestRender {
+        animation: string;
+        bookmarkSet: string;
+        bookmark: string;
+        duration?: number;
+        frames?: number;
+        loop?: boolean;
+        reverse?: boolean;
+    }
+    export interface RequestRenderBatchImagesFromBookmarkSet extends RequestRender {
+        bookmarkSet: string;
+    }
+    export interface RequestRenderImageFromBookmark extends RequestRender {
+        bookmarkSet: string;
+        bookmark: string;
+    }
+}
+
+export declare namespace WRAPIv2 {
+    export interface AabbRequest {
+        scene: Scene;
+    }
+    export interface HotspotRequest {
+        scene: Scene;
+        mode: AnimationMode | ImageMode | ImagesMode | VrCubeMode | VrObjectMode;
+        renderParameters?: RenderParameters;
+        positions?: Vector3D[];
+        tags?: string[];
+    }
+    export interface PickRequest {
+        scene: Scene;
+        camera: Camera;
+        renderParameters?: RenderParameters;
+        positions: PositionArray;
+    }
+    export interface SnapshotRequest {
+        scene: Scene;
+        mode: AnimationMode | ImageMode | ImagesMode | VrCubeMode | VrObjectMode;
+        renderParameters?: RenderParameters;
+        encoder?: JpegEncoder | PngEncoder | WebpEncoder | VideoEncoder;
+    }
+    export interface AabbResponse {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        size: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }
+    export type HotspotReponse = Hotspot | Hotspot[];
+    export interface Hotspot {
+        id: string;
+        name: string;
+        position2D: Vector2D;
+        position3D: Vector3D;
+        visibility: HotspotVisibility;
+    }
+    export enum HotspotVisibility {
+        Visible = "Visible",
+        Occluded = "Occluded",
+        Clipped = "Clipped",
+        OutOfFrustum = "OutOfFrustum"
+    }
+    export type PickResponse = PickResult[];
+    export interface PickResult {
+        product: string;
+        surface: PickResultSurface;
+        normal: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        point: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        uvw: {
+            u: number;
+            v: number;
+            w: number;
+        };
+    }
+    export interface PickResultSurface {
+        id: string;
+        name: string;
+        tags: string[];
+    }
+    export type SnapshotResponse = Frame | Frame[];
+    export interface Frame {
+        url: string;
+    }
+    export type AnimationArray = Animation[];
+    export type Camera = Guid | CameraObj;
+    export type CameraGroup = Guid;
+    export type Color = string;
+    export type ColoredBackground = {
+        color: Color;
+    } | {
+        startColor: Color;
+        endColor: Color;
+    };
+    export type Guid = string;
+    export type LabelArray = (Label | ImageLabel | TextLabel)[];
+    export type LabelTransformArray = LabelTransform[];
+    export type MaterialArray = Material[];
+    export type MaterialMultiLayerArray = MaterialMultiLayer[];
+    export type MaterialSeamArray = MaterialSeam[];
+    export type MaterialStandardArray = MaterialStandard[];
+    export type PositionArray = Vector2D[];
+    export type ProductArray = Product[];
+    export type Scene = Guid | Product | ProductArray;
+    export type SurfaceArray = Surface[];
+    export interface Animation {
+        id: Guid;
+        time: number;
+    }
+    export interface AnimationMode {
+        animation: {
+            id: Guid;
+            camera?: Camera;
+            fps?: number;
+            reverse?: boolean;
+        };
+    }
+    export interface CameraObj {
+        id?: Guid;
+        depthPolicy?: DepthPolicy;
+        lens?: LensFov | LensFrustum;
+        pov?: Pov;
+        sensor?: Guid | Sensor;
+    }
+    export interface DepthPolicy {
+        mode?: DepthPolicyMode;
+        zMin?: number;
+        zMax?: number;
+    }
+    export type DepthPolicyMode = 'frustumBased' | 'fixedDepthRange' | 'lookAtPointBasedInterest' | 'useGlobalPolicy';
+    export interface ImageMode {
+        image: {
+            camera: Camera;
+        };
+    }
+    export interface ImagesMode {
+        images: {
+            cameraGroup: CameraGroup;
+        };
+    }
+    export interface JpegEncoder {
+        jpeg: {
+            quality?: number;
+        };
+    }
+    export interface Label {
+        type?: string;
+        surface?: string;
+        tag?: string;
+        id?: Guid;
+        filename?: string;
+        translation?: Vector2D;
+        rotation?: number;
+        scaling?: Vector2D;
+    }
+    export interface ImageLabel extends Label {
+        type: 'image';
+        src: string;
+    }
+    export interface TextLabel extends Label {
+        type: 'text';
+        text: string;
+        fontFamily: string;
+        fontSize: number;
+        color?: Color;
+        textAlign?: 'left' | 'start' | 'center' | 'right' | 'end';
+    }
+    export interface LabelTransform {
+        index?: number;
+        translation?: Vector2D;
+        rotation?: number;
+        scaling?: Vector2D;
+    }
+    export interface LensFov {
+        fov: number;
+        view?: 'perspective' | 'isometric';
+        axis?: 'x' | 'y';
+    }
+    export interface LensFrustum {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        view?: 'perspective' | 'isometric';
+    }
+    export interface Material {
+        name?: string;
+        tag?: string;
+        id?: Guid;
+        filename?: string;
+    }
+    export interface MaterialMultiLayer {
+        name: string;
+        layer: number;
+        diffuseColor?: Color;
+        diffuseColorIntensity?: number;
+        specularRoughness?: number;
+    }
+    export interface MaterialSeam {
+        name: string;
+        diffuseColor?: Color;
+        diffuseColorIntensity?: number;
+        specularRoughness?: number;
+    }
+    export interface MaterialStandard {
+        name: string;
+        diffuseColor?: Color;
+        diffuseColorIntensity?: number;
+        diffuseColorMap?: string;
+        specularRoughness?: number;
+    }
+    export interface Pov {
+        target: Vector3D;
+        eye: Vector3D;
+        up: Vector3D;
+    }
+    export interface PngEncoder {
+        png: {
+            compression?: number;
+        };
+    }
+    export interface Product {
+        id?: Guid;
+        database: Guid;
+        product?: Guid;
+        animations?: AnimationArray;
+        configuration?: string;
+        labels?: LabelArray;
+        materials?: MaterialArray;
+        materialMultiLayers?: MaterialMultiLayerArray;
+        materialSeams?: MaterialSeamArray;
+        materialStandards?: MaterialStandardArray;
+        partitions?: RenderPartitions;
+        surfaces?: SurfaceArray;
+        surfacesFilter?: SurfacesFilter;
+        translation?: Vector3D;
+        rotation?: Vector3D;
+        visible?: boolean;
+        isMaster?: boolean;
+    }
+    export type RenderMode = 'aabb' | 'fill' | 'gbuffer' | 'lightmap' | 'material' | 'mix' | 'normalDepth' | 'uv' | 'wireframe' | 'worldPosition' | 'zbuffer';
+    export interface RenderParameters {
+        width?: number;
+        height?: number;
+        mode?: RenderMode;
+        antialiasing?: boolean;
+        background?: boolean;
+        compositing?: boolean;
+        enhancedTransparency?: boolean;
+        grid?: boolean;
+        matting?: boolean;
+        mipmap?: boolean;
+        mirror?: boolean;
+        overlay?: boolean;
+        partitions?: RenderPartitions;
+        postProcess?: boolean;
+        product?: boolean;
+        referential?: boolean;
+        superSampling?: '1' | '2' | '3' | '4';
+        screenSpaceReflections?: boolean;
+        screenSpaceReflectionsGrazingAngleFadeoff?: number;
+        screenSpaceReflectionsQualityFactor?: number;
+        screenSpaceReflectionsRayDepthFactor?: number;
+        ssaoParameters?: SSAOParameters;
+        sunAuthoringData?: SunAuthoringData;
+    }
+    export interface RenderPartitions {
+        axfCpa2?: boolean;
+        environment?: boolean;
+        error?: boolean;
+        label?: boolean;
+        matte?: boolean;
+        mirrorOpaque?: boolean;
+        mirrorTransparent?: boolean;
+        multiLayerOpaque?: boolean;
+        multiLayerTransparent?: boolean;
+        null?: boolean;
+        seam?: boolean;
+        shaper?: boolean;
+        standardOpaque?: boolean;
+        standardTransparent?: boolean;
+    }
+    export interface Sensor {
+        id?: Guid;
+        background?: Guid | ColoredBackground | ('product' | 'transparent');
+        overlay?: Guid;
+    }
+    export interface SSAOParameters {
+        enabled: boolean;
+        lightmaps: boolean;
+        transparentSurfaces: boolean;
+        radius: number;
+        intensity: number;
+        bias: number;
+        steps: number;
+    }
+    export interface SunAuthoringData {
+        enabled?: boolean;
+        sunColor?: string;
+        intensity?: number;
+        lightmapIntensity?: number;
+        enabledShadowsInMirrors?: boolean;
+        shadowIntensity?: number;
+        shadowQuality?: SunShadowQualityMode;
+        shadowSmoothness?: SunShadowSmoothnessMode;
+        specularEnabled?: boolean;
+        specularIntensity?: number;
+        northOrientation?: number;
+        useCase?: SunUseCaseMode;
+        manualData?: SunManualData;
+    }
+    export interface SunManualData {
+        azimuth: number;
+        altitude: number;
+    }
+    export enum SunShadowQualityMode {
+        VeryLow = "veryLow",
+        Low = "low",
+        Medium = "medium",
+        Fine = "fine",
+        Ultra = "ultra"
+    }
+    export enum SunShadowSmoothnessMode {
+        None = "none",
+        Weak = "weak",
+        Normal = "normal",
+        Fine = "fine",
+        UltraFine = "ultraFine",
+        Max = "max"
+    }
+    export enum SunUseCaseMode {
+        Manual = "manual",
+        ExtractedFromEnv = "extractedFromEnv"
+    }
+    export interface Surface {
+        tag: string;
+        hide?: boolean;
+        labels?: LabelTransformArray;
+        vertices?: number[];
+        normals?: number[];
+        uvs?: number[];
+    }
+    export interface SurfacesFilter {
+        mode: SurfacesFilterMode;
+        tags: string[];
+    }
+    export enum SurfacesFilterMode {
+        ShowOnly = "showOnly",
+        HideOnly = "hideOnly"
+    }
+    export interface Vector2D {
+        x: number;
+        y: number;
+    }
+    export interface Vector3D {
+        x: number;
+        y: number;
+        z: number;
+    }
+    export interface VideoEncoder {
+        video: {
+            container?: string;
+            encoder?: string;
+            bitrate?: number;
+            fps?: number;
+        };
+    }
+    export interface VrCubeMode {
+        vrCube: {
+            camera: Camera;
+        };
+    }
+    export interface VrObjectMode {
+        vrObject: {
+            camera: Camera;
+            frames: number;
+        } | {
+            camera: Camera;
+            panLoop?: boolean;
+            panFrom?: number;
+            panTo?: number;
+            panFrames: number;
+            tiltLoop?: boolean;
+            tiltFrom?: number;
+            tiltTo?: number;
+            tiltFrames?: number;
+        };
+    }
+    export interface WebpEncoder {
+        webp?: {
+            quality?: number;
+        };
+    }
+}
+
+export { }