import * as THREE from 'three';
import * as lit from 'lit';
import { ReactiveElement, LitElement, CSSResultGroup } from 'lit';
import * as three_examples_jsm_loaders_GLTFLoader_js from 'three/examples/jsm/loaders/GLTFLoader.js';
import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer.js';
import * as lit_html from 'lit-html';

type Replace<T, K extends keyof T, S extends {}> = Omit<T, K> & S;
type Constructor<T = {}> = new (...args: any[]) => T;
type KeysMatching<O, T> = {
    [K in keyof O]: O[K] extends T ? K : never;
}[keyof O & string];

type RenderTargetDef = {
    type: THREE.TextureDataType;
    depthBuffer: boolean;
    depthTexture: boolean;
    samples: number;
    format?: THREE.PixelFormat;
};
type RenderTargetView = {
    renderTarget: THREE.WebGLRenderTarget;
    width: number;
    height: number;
};
declare class RenderTargetPool {
    private _renderTargetStates;
    allocate(width: number, height: number, def: RenderTargetDef): RenderTargetView;
    free(rtView: RenderTargetView): void;
    dispose(): void;
}

declare class FullscreenShaderMaterial extends THREE.ShaderMaterial {
    private _texUniformName;
    constructor(params: THREE.ShaderMaterialParameters, texUniformName?: string);
    setRtView(rtView: RenderTargetView): void;
}

declare class Renderer extends THREE.EventDispatcher<{
    "webglcontextlost": {};
    "webglcontextrestored": {};
    "prerender": {};
    "render": {
        frame: XRFrame;
    };
    "postrender": {};
    "tick": {
        time: number;
        delta: number;
    };
}> {
    static readonly instance: Renderer;
    webglRenderer: THREE.WebGLRenderer | null;
    rtPool: RenderTargetPool;
    canvas: HTMLCanvasElement;
    time: number;
    manualSizing: boolean;
    private _fsQuad;
    copyMaterial: FullscreenShaderMaterial;
    private _currentCanvasViewport;
    private constructor();
    private render;
    requestSize(width: number, height: number): void;
    copyPixels(target: HTMLCanvasElement, width: number, height: number, xOffset?: number, yOffset?: number): void;
    fsRender(material: THREE.Material): void;
    setRtView(view: RenderTargetView | null): void;
    copyRt(src: RenderTargetView, dst: RenderTargetView | null, blending?: boolean, alpha?: number): void;
    maxAnisotropy(): number;
    getContext(): WebGLRenderingContext | WebGL2RenderingContext | null;
    dispose(): void;
}

declare const paused: unique symbol;
declare const repeatMode: unique symbol;
declare const repeatCount: unique symbol;
declare const forcedUpdate: unique symbol;
declare class AnimationControls {
    private needsUpdate;
    mixer: THREE.AnimationMixer;
    names: string[];
    nameToAction: Map<string, THREE.AnimationAction>;
    currentAction: THREE.AnimationAction | null;
    private [paused];
    private [repeatMode];
    private [repeatCount];
    private [forcedUpdate];
    dispose: () => void;
    constructor(scene: THREE.Object3D, animations: THREE.AnimationClip[]);
    get isActive(): boolean;
    update(delta: number): boolean;
    play(name: string | null, crossFade?: number): void;
    get paused(): boolean;
    set paused(value: boolean);
    get repeatMode(): "repeat" | "mirror-repeat";
    set repeatMode(value: string);
    get repeatCount(): number;
    set repeatCount(value: number);
    get duration(): number | undefined;
    reset(): void;
}

declare const count: unique symbol;
declare class DownloadRequest extends THREE.EventDispatcher<{
    "progress": {
        value: number;
    };
}> {
    xhr: XMLHttpRequest;
    done: Promise<ArrayBuffer>;
    data?: ArrayBuffer;
    constructor(url: string, credentials?: boolean, headers?: Map<string, string>);
    private updateProgress;
    dispose(): void;
}
declare class Request<T, U = T> extends THREE.EventDispatcher<{
    "progress": {
        value: number;
    };
}> {
    done: Promise<U>;
    data?: U;
    dispose: () => void;
    private entry;
    private disposed;
    constructor(entry: Entry<T>, supply: (data: T, request?: Request<T, U>) => U);
    get url(): string;
    get progress(): number;
}
declare class Entry<T> extends THREE.EventDispatcher<{
    "progress": {
        value: number;
    };
    "usage-change": {};
}> {
    url: string;
    progress: number;
    downloadRequest?: DownloadRequest;
    done: Promise<T>;
    data?: T;
    dispose: () => void;
    private [count];
    private disposed;
    constructor(url: string, credentials: boolean, headers: Map<string, string>, transform: (buffer: ArrayBuffer) => Promise<T>, dispose: (data: T) => void);
    private updateProgress;
    get count(): number;
    set count(value: number);
}

type ModelRequest = Request<GLTF, Model>;

declare const $gltf: unique symbol;
declare const $request: unique symbol;
declare const $needsUpdate: unique symbol;
declare const $showLights: unique symbol;
declare const $variantIndex: unique symbol;
declare const $boundingBox: unique symbol;
declare const $dirtyBoundingBox: unique symbol;
declare class Model extends THREE.EventDispatcher<{
    "animation-frame": {};
    "bounding-box-update": {};
    "variant-change": {};
    "trs-transform": {};
}> {
    private [$gltf];
    private [$request]?;
    private [$needsUpdate];
    private [$showLights];
    private [$variantIndex];
    private [$boundingBox];
    private [$dirtyBoundingBox];
    scene: THREE.Object3D;
    animation: AnimationControls | null;
    cameras: (THREE.PerspectiveCamera | THREE.OrthographicCamera)[];
    lights: THREE.Light[];
    variants: string[];
    associations: Map<THREE.Object3D<THREE.Object3DEventMap> | THREE.Texture | THREE.Material, three_examples_jsm_loaders_GLTFLoader_js.GLTFReference>;
    constructor(gltf: GLTF, request?: ModelRequest);
    update(delta: number): boolean;
    get boundingBox(): THREE.Box3;
    computeBoundingBox(): THREE.Box3;
    get src(): string;
    setScale(x: number, y: number, z: number): void;
    setRotation(x: number, y: number, z: number): void;
    setPosition(x: number, y: number, z: number): void;
    setVariant(variant?: string | number | null): Promise<void>;
    getMeshFromIndices(nodeIndex: number, primitiveIndex: number): THREE.Mesh<any, any, any> | null;
    get json(): any;
    get showLights(): boolean;
    set showLights(value: boolean);
    dispose(): void;
}

type ShadowEvents = THREE.Object3DEventMap & {
    "visible": {
        value: boolean;
    };
    "bounding-box-update": {};
};
declare class Shadow extends THREE.Object3D<ShadowEvents> {
    light: THREE.DirectionalLight;
    mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.ShadowMaterial, THREE.Object3DEventMap>;
    private _offset;
    private height;
    private needsUpdate;
    constructor();
    update(): boolean;
    dispose(): void;
    get needsRepaint(): boolean;
    set needsRepaint(value: boolean);
    get intensity(): number;
    set intensity(value: number);
    get radius(): number;
    set radius(value: number);
    get samples(): number;
    set samples(value: number);
    get resolution(): number;
    set resolution(value: number);
    get offset(): number;
    set offset(value: number);
    adjustToBox(box: THREE.Box3): void;
}

type EnvironmentRequest = Request<THREE.CubeTexture>;

type EventfulScene = Constructor<Replace<THREE.Scene, keyof THREE.Object3D, THREE.Object3D<THREE.Object3DEventMap & {
    "model-added": {
        model: Model;
        index: number;
    };
    "model-removed": {
        model: Model;
        index: number;
    };
    "bounding-box-update": {};
    "models-bounding-box-update": {};
    "exploded-strength-change": {};
}>>>;
interface MaterialLayer {
    readonly enabled: boolean;
    setupMesh(mesh: THREE.Mesh): void;
    resetMesh(mesh: THREE.Mesh): void;
    invalidateMesh(mesh: THREE.Mesh): void;
}
declare enum Update$1 {
    ADDED = 0,
    MODIFIED = 1,
    REMOVED = 2
}
type BoxData = {
    root?: THREE.Box3;
    subtree: THREE.Box3;
    offset: THREE.Vector3;
    position: THREE.Vector3;
    center: THREE.Vector3;
    baseRoot?: THREE.Box3;
    baseSubtree: THREE.Box3;
};
declare const Scene_base: EventfulScene;
declare class Scene extends Scene_base {
    #private;
    models: Model[];
    modelRoots: THREE.Object3D<THREE.Object3DEventMap>;
    lightRoots: THREE.Object3D<THREE.Object3DEventMap>;
    helpers: THREE.Object3D<THREE.Object3DEventMap>;
    shadow: Shadow;
    materialLayers: MaterialLayer[];
    constructor();
    beforeRender(): void;
    afterRender(): void;
    get meshUpdates(): Map<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>, Update$1>;
    queueUpdate(): void;
    update(delta: number): boolean;
    addModel(model: Model): void;
    removeModel(model: Model): void;
    addHelper(helper: THREE.Object3D): void;
    removeHelper(helper: THREE.Object3D): void;
    get modelsBoundingBox(): THREE.Box3;
    computeModelsBoundingBox(): THREE.Box3;
    get boundingBox(): THREE.Box3;
    computeBoundingBox(): THREE.Box3;
    get boundingBoxes(): Map<THREE.Object3D<THREE.Object3DEventMap>, BoxData>;
    computeBoundingBoxes(): Map<THREE.Object3D<THREE.Object3DEventMap>, BoxData>;
    get explodedStrength(): number;
    set explodedStrength(value: number);
    interpolateExplodedStrength(value: number): void;
    private onModelBoundingBoxUpdate;
    private onModelTRSTransform;
    private onAnimationFrame;
    private onMaterialChange;
    setEnvironmentRequest(request: EnvironmentRequest | null): void;
    get skybox(): boolean;
    set skybox(value: boolean);
    getEnvironmentRotation(): {
        x: number;
        y: number;
        z: number;
    };
    setEnvironmentRotation(x: number, y: number, z: number, order?: THREE.EulerOrder): void;
    get showModelLights(): boolean;
    set showModelLights(value: boolean);
    closestMeshToPoint(position: THREE.Vector3): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
    dispose(): void;
}

type Camera = THREE.PerspectiveCamera | THREE.OrthographicCamera;

type RenderingConfig = {
    exposure: number;
    toneMapping: ToneMap;
    antiAliasing: "msaa" | "ssaa";
    msaaSamples: number;
    ssaaSamples: number;
    sharpenStrength: number;
    bloomStrength: number;
    bloomRadius: number;
    bloomThreshold: number;
    ssaoStrength: number;
    ssaoRadius: number;
    ssrEnabled: boolean;
    halfResFx: boolean;
    hueShift: number;
    saturation: number;
    contrast: number;
    brightness: number;
    transparencyMode: TransparencyMode$1;
};
type TransparencyMode$1 = "normal" | "depthWrite";
type ColorRepresentation = string | number;
type ToneMap = typeof toneMap[number];
declare const toneMap: readonly ["none", "linear", "reinhard", "cineon", "aces", "agx", "neutral"];
declare const $cfg: unique symbol;
declare class ViewerRendering {
    private _scene;
    private _width;
    private _height;
    [$cfg]: RenderingConfig;
    private _passes;
    private _needsRebuild;
    private _needsRender;
    private _needsMaterialUpdate;
    private _outlineNeedsRender;
    private _normalPass;
    private _tssaaPass;
    private _sharpenPass;
    private _bloomPass;
    private _ssaoPass;
    private _outputPass;
    private _prevFrameBuffer;
    private _prevImageWorldToProj;
    private _wireframeMaterial;
    private _wireframeMatCache;
    transparentWireframe: boolean;
    private _outlineMeshMaterial;
    private _outlineMaterial;
    backgroundMaterial: THREE.MeshBasicMaterial;
    skipEffects: boolean;
    constructor(scene: Scene);
    set antiAliasing(_aa: string);
    set sharpenStrength(sharpenStrength: number);
    set ssaaSamples(ssaaSamples: number);
    set msaaSamples(_msaaSamples: number);
    set bloomStrength(bloomStrength: number);
    set bloomRadius(bloomRadius: number);
    set bloomThreshold(bloomThreshold: number);
    get ssaoEnabled(): boolean;
    set ssaoRadius(ssaoRadius: number);
    set ssaoStrength(ssaoStrength: number);
    set ssrEnabled(_v: boolean);
    set halfResFx(_v: boolean);
    set hueShift(v: number);
    set saturation(v: number);
    set contrast(v: number);
    set brightness(v: number);
    set transparencyMode(_v: TransparencyMode$1);
    set exposure(_v: number);
    set toneMapping(_v: ToneMap);
    get outlineColor(): ColorRepresentation;
    set outlineColor(color: ColorRepresentation);
    get outlineWidth(): number;
    set outlineWidth(width: number);
    addOutlineMesh(mesh: THREE.Object3D): void;
    removeOutlineMesh(mesh: THREE.Object3D): void;
    addBackgroundMesh(mesh: THREE.Object3D): void;
    removeBackgroundMesh(mesh: THREE.Object3D): void;
    queueRender(): void;
    rebuild(): void;
    set wireframeColor(color: ColorRepresentation | null);
    private _build;
    update(renderRequested: boolean): boolean;
    private _renderOutline;
    render(camera: Camera): void;
    private _setupMesh;
    updateMeshes(updates?: Map<THREE.Mesh, Update$1>): void;
    invalidateMesh(mesh: THREE.Mesh): void;
    setSize(width: number, height: number): void;
    dispose(): void;
}

declare class Spring {
    #private;
    constructor(f: number);
    update(current: number, goal: number, delta: number, tolerance: number): number;
    get frequency(): number;
    set frequency(f: number);
    reset(): void;
}

type PointerState = {
    id: number;
    offsetX: number;
    offsetY: number;
};
declare const enum UpdateSource {
    INTERACTION = 0,
    MANUAL = 1,
    AUTOMATIC = 2,
    NONE = 3
}
declare const UpdateSourceText: {
    readonly 0: "interaction";
    readonly 1: "manual";
    readonly 2: "auto";
    readonly 3: "none";
};
type UpdateSourceTextType = typeof UpdateSourceText[keyof typeof UpdateSourceText];
declare enum Mode {
    ROTATE = 0,
    PAN = 1,
    ZOOM = 2,
    DOUBLE_TOUCH = 3,
    CONTEXT_MENU = 4,
    NONE = 5
}
declare const $enabled$1: unique symbol;
declare const $springFrequency: unique symbol;
declare const $animationFrequency: unique symbol;
declare const $updateConfig: unique symbol;
declare const $setSpringFrequencies: unique symbol;
type ControlEvents = {
    "change": {
        source: UpdateSourceTextType;
    };
};
declare class OrbitControls extends THREE.EventDispatcher<ControlEvents> {
    scene: Scene;
    element: HTMLElement;
    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
    width: number;
    height: number;
    needsUpdate: boolean;
    updateSource: UpdateSource;
    mode: Mode;
    [$enabled$1]: boolean;
    enablePan: boolean;
    enableZoom: boolean;
    enableRotation: boolean;
    pointerState: PointerState[];
    private lastDistance;
    private panFocus;
    recastTarget: boolean;
    target: THREE.Vector3;
    spherical: THREE.Spherical;
    fov: number;
    aspect: number;
    top: number;
    currentTarget: THREE.Vector3;
    currentSpherical: THREE.Spherical;
    currentFov: number;
    currentAspect: number;
    currentTop: number;
    minRadius: number;
    maxRadius: number;
    minTheta: number;
    maxTheta: number;
    minPhi: number;
    maxPhi: number;
    minFov: number;
    maxFov: number;
    minTop: number;
    maxTop: number;
    maxTargetDistance: number | null;
    rotationSensitivity: number;
    panSensitivity: number;
    zoomSensitivity: number;
    private [$springFrequency];
    private [$animationFrequency];
    private animating;
    targetSpringX: Spring;
    targetSpringY: Spring;
    targetSpringZ: Spring;
    radiusSpring: Spring;
    thetaSpring: Spring;
    phiSpring: Spring;
    fovSpring: Spring;
    topSpring: Spring;
    autoRotate: boolean;
    autoRotateDelay: number;
    autoRotateSpeed: number;
    inactiveTime: number;
    private [$updateConfig];
    sphere: THREE.Sphere;
    constructor(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, element: HTMLElement, scene: Scene);
    get enabled(): boolean;
    set enabled(value: boolean);
    private determineMode;
    private onPointerDown;
    private onPointerUp;
    private onPointerMove;
    private onWheel;
    private onContextMenu;
    rotate(dx: number, dy: number): void;
    pan: (dx: number, dy: number) => void;
    zoom(delta: number): void;
    setUpdateSource(source: UpdateSource): void;
    setSpherical(radius?: number, phi?: number, theta?: number): void;
    setTarget(x?: number, y?: number, z?: number): void;
    setFov(fov?: number): void;
    setTop(top?: number): void;
    setAspect(aspect: number): void;
    setCamera(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
    update(delta: number): boolean;
    updateCamera(): void;
    isStationary(): boolean;
    jump(): void;
    setSize(width: number, height: number): void;
    private updateCursor;
    private clampTarget;
    private wrapTheta;
    private [$setSpringFrequencies];
    get springFrequency(): number;
    set springFrequency(value: number);
    get animationFrequency(): number;
    set animationFrequency(value: number);
    setRadiusLimits(min?: number, max?: number): void;
    setThetaLimits(min?: number, max?: number): void;
    setPhiLimits(min?: number, max?: number): void;
    setFovLimits(min?: number, max?: number): void;
    setTopLimits(min?: number, max?: number): void;
}

declare enum ViewChannels {
    None = 0,
    VertexNormal = 1,
    VertexTangent = 2,
    VertexBitangent = 3,
    DerivativeTangent = 4,
    DerivativeBitangent = 5,
    WorldSpaceNormal = 6,
    NormalTexture = 7,
    BaseColor = 8,
    Alpha = 9,
    Metallic = 10,
    Roughness = 11,
    Occlusion = 12,
    Emissive = 13,
    FaceOrientation = 14,
    UV0 = 15,
    UV0Wrapped = 16,
    UV1 = 17,
    UV1Wrapped = 18,
    UV0Checker = 19,
    UV1Checker = 20,
    UV0PrimaryStretch = 21,
    UV0SecondaryStretch = 22,
    UV0StretchDirection = 23
}

declare const $viewChannel: unique symbol;
declare const $needsRender$2: unique symbol;
declare const $cache$2: unique symbol;
declare const $uvChecker: unique symbol;
declare class Inspector {
    private [$cache$2];
    private [$needsRender$2];
    private [$viewChannel];
    private [$uvChecker];
    private createMaterial;
    setupMesh(mesh: THREE.Mesh): void;
    resetMesh(mesh: THREE.Mesh): void;
    invalidateMesh(mesh: THREE.Mesh): void;
    get enabled(): boolean;
    get viewChannel(): ViewChannels;
    set viewChannel(viewChannel: ViewChannels);
    get needsRender(): boolean;
    set needsRender(needsRender: boolean);
    update(): boolean;
    dispose(): void;
}

declare const $scene: unique symbol;
declare const $cache$1: unique symbol;
declare const $enabled: unique symbol;
declare const $gemAntiAliasing: unique symbol;
declare const $rayTraceDepth: unique symbol;
declare const $needsRender$1: unique symbol;
declare class Jewelry extends THREE.EventDispatcher<{
    "enabled": {
        value: boolean;
    };
}> {
    private [$scene];
    private [$cache$1];
    private [$enabled];
    private [$gemAntiAliasing];
    private [$rayTraceDepth];
    private [$needsRender$1];
    constructor(scene: Scene);
    private createMaterial;
    setupMesh(mesh: THREE.Mesh): void;
    resetMesh(mesh: THREE.Mesh): void;
    invalidateMesh(mesh: THREE.Mesh): void;
    get enabled(): boolean;
    set enabled(enabled: boolean);
    get gemAntiAliasing(): boolean;
    set gemAntiAliasing(antiAliasing: boolean);
    get rayTraceDepth(): number;
    set rayTraceDepth(rayTraceDepth: number);
    get needsRender(): boolean;
    set needsRender(needsRender: boolean);
    update(): boolean;
}

declare class HotspotRenderer {
    #private;
    constructor(element: HTMLElement);
    queueRender(): void;
    render(camera: THREE.Camera): void;
    setSize(width: number, height: number): void;
    add(object: CSS2DObject): void;
    remove(object: CSS2DObject): void;
}

declare class ProgressTracker extends THREE.EventDispatcher<{
    "progress": {
        value: number;
        source: string;
    };
}> {
    private activities;
    private progress;
    private completed;
    private sum;
    get count(): number;
    addActivity(progress?: number, source?: string): (progress: number) => void;
    private updateProgress;
    reset(): void;
}

declare class AugmentedReality extends THREE.EventDispatcher<{
    "start": {};
    "end": {};
}> {
    private scene;
    private _initialRotationProvider?;
    private _arCamera;
    active: boolean;
    private _lastFrame;
    private _physicalHitPos;
    private _positioningPhase;
    private _rotationOffset;
    private _hasRotationOffset;
    private _activeInputSource;
    private _inputSourceToTransform;
    private _inputSourceToDeltaTransform;
    private _scaleInitMul;
    private _arCameraHolder;
    private _hitTestSource;
    private _session;
    private _firstFrame;
    private _cameraTransXr;
    constructor(scene: Scene, _initialRotationProvider?: (() => THREE.Spherical) | undefined);
    private _onSessionStart;
    private _onSessionEnd;
    private _stopPlacement;
    private _tempVec3;
    private _tempVec4;
    private _tempVec5;
    private _tempQuat2;
    private _tempMat2;
    private _tempEuler1;
    private _centerModel;
    render(frame: XRFrame): void;
    private _tempBoxSize;
    private _tempVec1;
    private _tempVec2;
    private _tempQuat1;
    private _tempMat1;
    update(delta: number): boolean;
    private _initSession;
    requestSession(): Promise<void>;
    offerSession(): Promise<void>;
    endSession(): Promise<void>;
}

declare const $changes: unique symbol;
declare const $update: unique symbol;
declare const enum Update {
    ADDED = 0,
    REMOVED = 1
}
type EventedSetEvents<T> = {
    "change": {
        changes: Map<T, Update>;
    };
};
declare class EventedSet<T, U extends EventedSetEvents<T> = EventedSetEvents<T>> extends Set<T> implements THREE.EventDispatcher<U> {
    protected [$changes]: Map<T, Update>;
    protected [$update]: Promise<void> | null;
    addEventListener: <K extends Extract<keyof U, string>>(type: K, listener: THREE.EventListener<U[K], K, this>) => void;
    hasEventListener: <K extends Extract<keyof U, string>>(type: K, listener: THREE.EventListener<U[K], K, this>) => boolean;
    removeEventListener: <K extends Extract<keyof U, string>>(type: K, listener: THREE.EventListener<U[K], K, this>) => void;
    dispatchEvent: <K extends Extract<keyof U, string>>(event: THREE.BaseEvent<K> & U[K]) => void;
    constructor(iterable?: Iterable<T>);
    private queueUpdate;
    add(item: T): this;
    delete(item: T): boolean;
    clear(): void;
}

declare const $viewer: unique symbol;
declare const $cache: unique symbol;
declare const $needsRender: unique symbol;
declare const $hoverMesh: unique symbol;
declare const $hoverController: unique symbol;
declare class ObjectSelection {
    private [$viewer];
    private [$needsRender];
    private [$cache];
    private [$hoverMesh];
    private [$hoverController];
    readonly background: EventedSet<THREE.Object3D>;
    readonly highlight: EventedSet<THREE.Object3D>;
    constructor(viewer: VntanaViewerBase);
    get hover(): THREE.Mesh | null;
    set hover(mesh: THREE.Mesh | null);
    get enabled(): boolean;
    private createHoverMaterial;
    private createHightlightMaterial;
    private shouldHover;
    private shouldHighlight;
    setupMesh(mesh: THREE.Mesh): void;
    resetMesh(mesh: THREE.Mesh): void;
    invalidateMesh(mesh: THREE.Mesh): void;
    get needsRender(): boolean;
    set needsRender(value: boolean);
    update(delta: number): boolean;
}

declare const $propertyTypes: unique symbol;
declare const $properties: unique symbol;
declare const $parsed: unique symbol;
declare const $unitTable: unique symbol;

type OffsetUnit = typeof Offset.units[number];
type UnitTable = {
    [Property in OffsetUnit]: number;
};
declare class Offset {
    static readonly units: readonly ["m", "cm", "mm", "r", "w", "h", "d"];
    number: number;
    unit: OffsetUnit;
    constructor(number: number, unit?: OffsetUnit);
    clone(): Offset;
    convertTo(unit: OffsetUnit, unitTable: UnitTable): this;
    toString(): string;
}

type AngleUnit = typeof Angle.units[number];
declare class Angle {
    static readonly units: readonly ["deg", "rad"];
    number: number;
    unit: AngleUnit;
    constructor(number: number, unit?: AngleUnit);
    equals(a: Angle): boolean;
    equivalent(a: Angle): boolean;
    clone(): Angle;
    convertTo(unit: AngleUnit): this;
    toString(): string;
}

type Scale = [number, number, number];
type Rotation = [Angle, Angle, Angle];
type Position = [Offset, Offset, Offset];

interface Domain<T> {
    has: (x: T) => boolean;
    project: (x: T) => T | null;
}

type CustomElement = ReactiveElement & {
    [$properties]: Map<string, any>;
    [$parsed]: Map<string, any>;
};

type RotationUnit = AngleUnit | [AngleUnit, AngleUnit, AngleUnit];
type PositionUnit = OffsetUnit | [OffsetUnit, OffsetUnit, OffsetUnit];

declare class StringMapper {
    readonly auto: string;
    constructor(auto?: string);
    parse(source: any): {
        value: string | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: string | null): {
        value: string;
        errors: undefined;
        reset: undefined;
    };
    process(value: string | null): {
        value: string;
        errors: undefined;
        reset: undefined;
    };
    evaluate(source: any): string;
    get type(): "string";
}
declare class BooleanMapper {
    parse(source: any): {
        value: boolean | null;
        errors: string[] | undefined;
        reset: boolean | null | undefined;
    };
    finalize(value: boolean | null): {
        value: boolean;
        errors: undefined;
        reset: undefined;
    };
    process(value: boolean | null): {
        value: boolean;
        errors: undefined;
        reset: undefined;
    };
    evaluate(source: any): boolean;
    get type(): "boolean";
}
declare class OptionMapper<T extends string> {
    readonly domain: readonly T[];
    readonly auto: T;
    constructor(domain: readonly T[], auto: T);
    parse(source: any): {
        value: T | null;
        errors: string[] | undefined;
        reset: T | null | undefined;
    };
    finalize(value: T | null): {
        value: T;
        errors: undefined;
        reset: undefined;
    };
    process(value: T | null): {
        value: T;
        errors: undefined;
        reset: undefined;
    };
    evaluate(source: any): T;
    get type(): "option";
}
declare abstract class ColorMapperBase<T extends string | null> {
    abstract auto: T;
    parse(source: any): {
        value: string | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: string | null): {
        value: string | null;
        errors: undefined;
        reset: undefined;
    };
    process(value: string | null): {
        value: string | null;
        errors: undefined;
        reset: undefined;
    };
    evaluate(source: any): string | null;
}
declare class OptionalColorMapper extends ColorMapperBase<null> {
    get auto(): null;
    parse(source: any): {
        value: string | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: string | null): {
        value: string | null;
        errors: undefined;
        reset: undefined;
    };
    process(value: string | null): {
        value: string | null;
        errors: undefined;
        reset: undefined;
    };
    evaluate(source: any): string | null;
    get type(): "optional-color";
}
declare class ColorMapper extends ColorMapperBase<string> {
    readonly auto: string;
    constructor(auto: string);
    parse(source: any): {
        value: string | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: string | null): {
        value: string;
        errors: undefined;
        reset: undefined;
    };
    process(value: string | null): {
        value: string;
        errors: undefined;
        reset: undefined;
    };
    evaluate(source: any): string;
    get type(): "color";
}
declare class NumberMapper<T extends CustomElement = any> {
    readonly domain: Domain<number>;
    auto: number | ((this: T) => number);
    constructor(domain: Domain<number>, auto: number);
    parse(source: any): {
        value: number | null;
        errors: string[] | undefined;
        reset: number | null | undefined;
    };
    finalize(value: number | null, instance?: T): {
        value: number;
        errors: string[] | undefined;
        reset: number | null | undefined;
    };
    process(value: number | null, instance?: T): {
        value: number;
        errors: string[] | undefined;
        reset: number | null | undefined;
    };
    evaluate(source: any, instance?: T): number;
    get type(): "number";
}
declare class AngleMapper {
    readonly domain: Domain<Angle>;
    readonly auto: string;
    constructor(domain: Domain<Angle>, auto: string);
    parse(source: any): {
        value: Angle | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: Angle | null): {
        value: Angle;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    convert(value: Angle, unit: AngleUnit): number;
    process(value: Angle | null, unit: AngleUnit): {
        value: number;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    evaluate(source: any, unit: AngleUnit): number;
    get type(): "angle";
}
declare class OffsetMapper<T extends CustomElement = any> {
    readonly domain: any;
    readonly auto: string | ((this: T) => string);
    constructor(domain: any, auto: string);
    parse(source: any): {
        value: Offset | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: Offset | null, instance?: T): {
        value: Offset;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    convert(value: Offset, unit: OffsetUnit, unitTable: UnitTable): number;
    process(value: Offset | null, unit: OffsetUnit, unitTable: UnitTable, instance?: T): {
        value: number;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    evaluate(source: any, unit: OffsetUnit, unitTable: UnitTable, instance?: T): number;
    get type(): "offset";
}
declare class ScaleMapper {
    readonly auto: string;
    constructor(auto: string);
    parse(source: any): {
        value: Scale | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: Scale | null): {
        value: Scale;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    process(value: Scale | null): {
        value: Scale;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    evaluate(source: any): Scale;
    get type(): "scale";
}
declare class RotationMapper {
    readonly domain: any;
    readonly auto: string;
    constructor(domain: any, auto: string);
    parse(source: any): {
        value: Rotation | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: Rotation | null): {
        value: Rotation;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    convert(value: Rotation, units: RotationUnit): Rotation;
    process(value: Rotation | null, units: RotationUnit): {
        value: [number, number, number];
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    evaluate(source: any, unit: RotationUnit): [number, number, number];
    validUnit(unit: RotationUnit): unit is RotationUnit;
    get type(): "rotation";
}
declare class PositionMapper<T extends CustomElement> {
    readonly auto: string;
    constructor(auto: string);
    parse(source: any): {
        value: Position | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: Position | null, _unitTable: UnitTable, _instance: T): {
        value: Position;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    convert(value: Position, units: PositionUnit, unitTable: UnitTable, _instance: T): Position;
    process(value: Position | null, units: PositionUnit, unitTable: UnitTable, instance: T): {
        value: [number, number, number];
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    evaluate(source: any, unit: PositionUnit, unitTable: UnitTable, instance: T): [number, number, number];
    validUnit(unit: PositionUnit): unit is PositionUnit;
    get type(): "position";
}

declare const lightProperties: {
    readonly directional: readonly ["intensity", "color", "position", "direction"];
    readonly point: readonly ["intensity", "color", "position", "distance"];
    readonly spot: readonly ["intensity", "color", "position", "direction", "distance", "angle", "penumbra"];
};
declare const lightPropertyMappers: {
    readonly intensity: NumberMapper<any>;
    readonly color: ColorMapper;
    readonly position: PositionMapper<CustomElement>;
    readonly direction: PositionMapper<CustomElement>;
    readonly distance: OffsetMapper<any>;
    readonly angle: AngleMapper;
    readonly penumbra: NumberMapper<any>;
};
type LightType = keyof typeof lightProperties;
type LightProperty = typeof lightProperties[LightType][number];
type LightProperties<T extends LightType> = typeof lightProperties[T][number];
type Mapper<K extends LightProperty> = typeof lightPropertyMappers[K];
type ParsedLightProperties = {
    [Property in LightProperty]: ReturnType<Mapper<Property>["parse"]>["value"];
};
type GenericParsedLight<type extends LightType> = {
    type: type;
    config: {
        [Property in LightProperties<type>]?: ParsedLightProperties[Property];
    };
};
type ParsedLight = GenericParsedLight<"directional"> | GenericParsedLight<"point"> | GenericParsedLight<"spot">;
type FinalizedLightProperties = {
    [Property in LightProperty]: ReturnType<Mapper<Property>["finalize"]>["value"];
};
type GenericFinalizedLight<type extends LightType> = {
    type: type;
    config: {
        [Property in LightProperties<type>]: FinalizedLightProperties[Property];
    };
};
type FinalizedLight = GenericFinalizedLight<"directional"> | GenericFinalizedLight<"point"> | GenericFinalizedLight<"spot">;
type MappedLightProperties = {
    [Property in LightProperty]: ReturnType<Mapper<Property>["process"]>["value"];
};
type GenericMappedLight<type extends LightType> = {
    type: type;
    config: {
        [Property in LightProperties<type>]: MappedLightProperties[Property];
    };
};
type MappedLight = GenericMappedLight<"directional"> | GenericMappedLight<"point"> | GenericMappedLight<"spot">;
type LightRigUnits = {
    "position": PositionUnit;
    "direction": PositionUnit;
    "distance": OffsetUnit;
    "angle": AngleUnit;
};
declare class LightRigMapper {
    parse(source: any): {
        value: ParsedLight[] | null;
        errors: string[] | undefined;
        reset: string | null | undefined;
    };
    finalize(value: ParsedLight[] | null, unitTable: UnitTable, instance: VntanaViewerBase): {
        value: FinalizedLight[];
        errors: string[] | undefined;
        reset: undefined;
    };
    convert(value: FinalizedLight[], units: LightRigUnits, unitTable: UnitTable, instance: VntanaViewerBase): FinalizedLight[];
    process(value: ParsedLight[] | null, units: LightRigUnits, unitTable: UnitTable, instance: VntanaViewerBase): MappedLight[];
    evaluate(source: any, units: LightRigUnits, unitTable: UnitTable, instance: VntanaViewerBase): MappedLight[];
    get type(): "light-rig";
}

declare global {
    interface __VntanaViewerMapper {
    }
}
declare const visible: unique symbol;
declare const needsRender: unique symbol;
declare const timeSinceLastUpdate: unique symbol;
declare const $loaded: unique symbol;
declare const $loading: unique symbol;
declare const $alreadyLoaded: unique symbol;
declare const $updateScene: unique symbol;
declare const $shouldLoad: unique symbol;
declare const $shouldUpdateProps: unique symbol;
declare const $shouldUpdateImmediateProps: unique symbol;
declare const $triggerUpdates: unique symbol;
declare const width: unique symbol;
declare const height: unique symbol;
declare const resolutionExceeded: unique symbol;
declare class VntanaViewerBase extends ReactiveElement {
    static readonly renderer: Renderer;
    static [$propertyTypes]: Map<keyof __VntanaViewerMapper, any>;
    [$parsed]: Map<keyof __VntanaViewerMapper, any>;
    [$properties]: Map<keyof __VntanaViewerMapper, any>;
    [$unitTable]: {
        [Property in OffsetUnit]: number;
    };
    private intersectionObserver;
    container: HTMLElement;
    canvas: HTMLCanvasElement;
    canvasContainer: HTMLElement;
    input: HTMLElement;
    hotspots: HTMLElement;
    scene: Scene;
    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
    controls: OrbitControls;
    rendering: ViewerRendering;
    inspector: Inspector;
    jewelry: Jewelry;
    hotspotRenderer: HotspotRenderer;
    progressTracker: ProgressTracker;
    ar?: AugmentedReality;
    selection: ObjectSelection;
    private [width];
    private [height];
    private [resolutionExceeded];
    private [visible];
    private [needsRender];
    protected [$loaded]: boolean;
    protected [$loading]: boolean;
    protected [$alreadyLoaded]: boolean;
    protected [timeSinceLastUpdate]: number;
    constructor();
    connectedCallback(): void;
    disconnectedCallback(): void;
    dispose(): void;
    protected onTick: ({ delta }: {
        delta: number;
    }) => void;
    protected updateSize: () => void;
    protected updateComponents: () => void;
    protected render: (event: {
        frame: XRFrame;
    }) => void;
    protected renderScene(canvas: HTMLCanvasElement, camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
    private onContextLost;
    get visible(): boolean;
    get needsRender(): boolean;
    set needsRender(value: boolean);
    get width(): number;
    get height(): number;
    get sceneVisible(): boolean;
    protected [$updateScene](): void;
    protected [$triggerUpdates](): void;
    protected get [$shouldLoad](): boolean;
    protected get [$shouldUpdateProps](): boolean;
    protected get [$shouldUpdateImmediateProps](): boolean;
    getNDC(clientX: number, clientY: number): {
        x: number;
        y: number;
    };
    evaluate<K extends KeysWithoutUnits>(property: K, source: any): EvaluateValue<K>;
    evaluate<K extends KeysWithUnits>(property: K, source: any, unit: Unit$1<K>): EvaluateValue<K>;
    evaluateProperty<K extends KeysWithoutUnits>(property: K): EvaluateValue<K>;
    evaluateProperty<K extends KeysWithUnits>(property: K, unit: Unit$1<K>): EvaluateValue<K>;
}
type UnitlessMapperType = StringMapper | BooleanMapper | OptionalColorMapper | ColorMapper | OptionMapper<any> | NumberMapper | ScaleMapper;
type KeysWithoutUnits = KeysMatching<__VntanaViewerMapper, UnitlessMapperType>;
type KeysWithUnits = Exclude<keyof __VntanaViewerMapper, KeysWithoutUnits>;
type EvaluateValue<K extends keyof __VntanaViewerMapper> = ReturnType<__VntanaViewerMapper[K]["evaluate"]>;
type Unit$1<K extends keyof __VntanaViewerMapper> = K extends KeysWithoutUnits ? never : K extends KeysMatching<__VntanaViewerMapper, AngleMapper> ? AngleUnit : K extends KeysMatching<__VntanaViewerMapper, OffsetMapper> ? OffsetUnit : K extends KeysMatching<__VntanaViewerMapper, RotationMapper> ? RotationUnit : K extends KeysMatching<__VntanaViewerMapper, PositionMapper<any>> ? PositionUnit : K extends KeysMatching<__VntanaViewerMapper, LightRigMapper> ? LightRigUnits : never;

declare const ARModeText: {
    readonly 0: "webxr";
    readonly 1: "native";
    readonly 2: "none";
};

declare global {
    interface __VntanaViewerMapper {
    }
}
type InterfaceType<K extends keyof __VntanaViewerMapper> = __VntanaViewerMapper[K] extends StringMapper ? string | null : __VntanaViewerMapper[K] extends BooleanMapper ? boolean | null : __VntanaViewerMapper[K] extends OptionMapper<infer T> ? T | null : __VntanaViewerMapper[K] extends OptionalColorMapper | ColorMapper ? string | null : __VntanaViewerMapper[K] extends NumberMapper ? number | null : __VntanaViewerMapper[K] extends AngleMapper ? string | null : __VntanaViewerMapper[K] extends OffsetMapper ? string | null : __VntanaViewerMapper[K] extends ScaleMapper ? string | null : __VntanaViewerMapper[K] extends RotationMapper ? string | null : __VntanaViewerMapper[K] extends PositionMapper<any> ? string | null : __VntanaViewerMapper[K] extends LightRigMapper ? string | null : never;
type InterfaceProps<T extends ReadonlyArray<keyof __VntanaViewerMapper>> = {
    [Property in T[number]]: InterfaceType<Property>;
};

declare const sceneInterfaceProps: readonly ["src", "scale", "rotation", "variant", "autoAR", "usdzSrc"];
declare interface SceneInterface extends InterfaceProps<typeof sceneInterfaceProps> {
    get arMode(): typeof ARModeText[keyof typeof ARModeText];
    startAR(): Promise<void>;
    stopAR(): Promise<void>;
    getVariants(): string[];
}
declare global {
    interface __VntanaViewerMapper {
        src: StringMapper;
        scale: ScaleMapper;
        rotation: RotationMapper;
        variant: StringMapper;
        autoAR: BooleanMapper;
        usdzSrc: StringMapper;
    }
}

declare const lightingInterfaceProps: readonly ["environmentSrc", "environmentRotation", "skybox", "shadowIntensity", "shadowRadius", "shadowSamples", "shadowResolution", "shadowOffset", "lightRig", "lightRigIntensity", "lightRigColor", "hideModelLights"];
declare interface LightingInterface extends InterfaceProps<typeof lightingInterfaceProps> {
}
declare global {
    interface __VntanaViewerMapper {
        environmentSrc: StringMapper;
        environmentRotation: RotationMapper;
        skybox: BooleanMapper;
        shadowIntensity: NumberMapper;
        shadowRadius: NumberMapper;
        shadowSamples: NumberMapper;
        shadowResolution: NumberMapper;
        shadowOffset: OffsetMapper;
        lightRig: LightRigMapper;
        lightRigIntensity: NumberMapper;
        lightRigColor: OptionalColorMapper;
        hideModelLights: BooleanMapper;
    }
}

declare const loadingType: readonly ["lazy", "eager", "hover"];
type LoadingType = typeof loadingType[number];
declare const loadingInterfaceProps: readonly ["loading", "poster"];
declare interface LoadingInterface extends InterfaceProps<typeof loadingInterfaceProps> {
    showPoster(): void;
    hidePoster(): void;
}
declare global {
    interface __VntanaViewerMapper {
        loading: OptionMapper<LoadingType>;
        poster: StringMapper;
    }
}
declare interface LoadingStaticInterface {
    setModelRequestHeaders(headers: {
        [index: string]: string;
    }): void;
    setModelRequestCredentials(value: boolean): void;
    setEnvironmentRequestHeaders(headers: {
        [index: string]: string;
    }): void;
    setEnvironmentRequestCredentials(value: boolean): void;
    setDracoDecoderPath(value: string): void;
    setKTX2DecoderPath(value: string): void;
}

declare const antiAliasing: readonly ["ssaa", "msaa"];
type AntiAliasing = typeof antiAliasing[number];
declare const transparencyMode: readonly ["normal", "depth-write"];
type TransparencyMode = typeof transparencyMode[number];

declare const renderingInterfaceProps: readonly ["exposure", "toneMapping", "antiAliasing", "msaaSamples", "ssaaSamples", "sharpenStrength", "bloomStrength", "bloomRadius", "bloomThreshold", "ssaoStrength", "ssaoRadius", "enableSsr", "hueShift", "saturation", "contrast", "brightness", "transparencyMode"];
declare interface RenderingInterface extends InterfaceProps<typeof renderingInterfaceProps> {
}
declare global {
    interface __VntanaViewerMapper {
        exposure: NumberMapper;
        toneMapping: OptionMapper<ToneMap>;
        antiAliasing: OptionMapper<AntiAliasing>;
        msaaSamples: NumberMapper;
        ssaaSamples: NumberMapper;
        sharpenStrength: NumberMapper;
        bloomStrength: NumberMapper;
        bloomRadius: NumberMapper;
        bloomThreshold: NumberMapper;
        ssaoStrength: NumberMapper;
        ssaoRadius: NumberMapper;
        enableSsr: BooleanMapper;
        hueShift: AngleMapper;
        saturation: NumberMapper;
        contrast: NumberMapper;
        brightness: NumberMapper;
        transparencyMode: OptionMapper<TransparencyMode>;
    }
}

declare const jewelryInterfaceProps: readonly ["enableJewelry", "gemAntiAliasing", "gemRayTracingDepth"];
declare interface JewelryInterface extends InterfaceProps<typeof jewelryInterfaceProps> {
}
declare global {
    interface __VntanaViewerMapper {
        enableJewelry: BooleanMapper;
        gemAntiAliasing: BooleanMapper;
        gemRayTracingDepth: NumberMapper;
    }
}

declare const cameraType: readonly ["perspective", "orthographic"];
type CameraType = typeof cameraType[number];
declare const controlsInterfaceProps: readonly ["disableControls", "disableZoom", "disablePan", "disableRotation", "rotationSensitivity", "panSensitivity", "zoomSensitivity", "enableAutoRotate", "autoRotateSpeed", "autoRotateDelay", "fieldOfView", "minFieldOfView", "maxFieldOfView", "orthographicSize", "minOrthographicSize", "maxOrthographicSize", "cameraType", "cameraTarget", "cameraDistance", "minCameraDistance", "maxCameraDistance", "cameraRotation", "minCameraRotation", "maxCameraRotation", "cameraAspect"];
declare interface ControlsInterface extends InterfaceProps<typeof controlsInterfaceProps> {
    getFieldOfView(): string;
    setFieldOfView(value: string | null): void;
    getOrthographicSize(): string;
    setOrthographicSize(value: string | null): void;
    getCameraDistance(): string;
    setCameraDistance(value: string | null): void;
    getCameraRotation(): string;
    setCameraRotation(value: string | null): void;
    getCameraTarget(): string;
    setCameraTarget(value: string | null): void;
    centerCamera(): void;
    jumpCamera(): void;
    getSceneRadius(): number;
}
declare global {
    interface __VntanaViewerMapper {
        disableZoom: BooleanMapper;
        disablePan: BooleanMapper;
        disableRotation: BooleanMapper;
        disableControls: BooleanMapper;
        rotationSensitivity: NumberMapper;
        panSensitivity: NumberMapper;
        zoomSensitivity: NumberMapper;
        enableAutoRotate: BooleanMapper;
        autoRotateSpeed: AngleMapper;
        autoRotateDelay: NumberMapper;
        fieldOfView: AngleMapper;
        minFieldOfView: AngleMapper;
        maxFieldOfView: AngleMapper;
        orthographicSize: OffsetMapper;
        minOrthographicSize: OffsetMapper;
        maxOrthographicSize: OffsetMapper;
        cameraDistance: OffsetMapper;
        minCameraDistance: OffsetMapper;
        maxCameraDistance: OffsetMapper;
        cameraRotation: RotationMapper;
        minCameraRotation: RotationMapper;
        maxCameraRotation: RotationMapper;
        cameraTarget: PositionMapper<VntanaViewerBase>;
        cameraType: OptionMapper<CameraType>;
        cameraAspect: NumberMapper;
    }
}

interface ScreenshotConfig {
    mimeType?: string;
    quality?: number;
    background?: string;
    width?: number;
    height?: number;
    poster?: boolean;
    cameraView?: {
        cameraType?: "perspective" | "orthographic" | null;
        cameraTarget?: string | null;
        cameraDistance?: string | null;
        cameraRotation?: string | null;
        cameraAspect?: string | null;
        fieldOfView?: string | null;
        orthographicSize?: string | null;
    };
}
declare const utilityInterfaceProps: readonly ["background"];
declare interface UtilityInterface extends InterfaceProps<typeof utilityInterfaceProps> {
    toDataURL(config: ScreenshotConfig): Promise<string>;
    getDimensions(): [number, number, number];
}
declare global {
    interface __VntanaViewerMapper {
        background: StringMapper;
    }
}

declare const VntanaViewer: Constructor<UtilityInterface> & Constructor<ControlsInterface> & Constructor<JewelryInterface> & Constructor<RenderingInterface> & Constructor<LoadingInterface> & Constructor<LightingInterface> & Constructor<SceneInterface> & typeof VntanaViewerBase & LoadingStaticInterface;
type VntanaViewer = InstanceType<typeof VntanaViewer>;
declare global {
    interface HTMLElementTagNameMap {
        'vntana-viewer': VntanaViewer;
    }
}

declare class VntanaHotspot extends ReactiveElement {
    #private;
    static [$propertyTypes]: Map<string, any>;
    [$parsed]: Map<string, any>;
    [$properties]: Map<string, any>;
    accessor position: string | null;
    accessor normal: string | null;
    accessor path: string | null;
    constructor();
    connectedCallback(): void;
    disconnectedCallback(): void;
    queueRender(): void;
    shouldUpdate(changed: Map<PropertyKey, any>): boolean;
    get [$unitTable](): {
        m: number;
        cm: number;
        mm: number;
        r: number;
        w: number;
        h: number;
        d: number;
    };
}

declare global {
    interface HTMLElementTagNameMap {
        'vntana-hotspot': VntanaHotspot;
    }
}

declare const $ancestorViewer: unique symbol;
declare const $contextDisabled: unique symbol;
declare const $i18nVersion: unique symbol;
declare const $element: unique symbol;
declare const $createElement: unique symbol;
declare const $destroyElement: unique symbol;
declare const $onViewerChange: unique symbol;
declare const $onTargetChange: unique symbol;
declare const $onActiveChange: unique symbol;
declare class UIElement extends LitElement {
    #private;
    static get styles(): CSSResultGroup;
    protected [$ancestorViewer]: VntanaViewer | null;
    private [$i18nVersion];
    hidden: boolean;
    disabled: boolean;
    private [$contextDisabled];
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    get contextDisabled(): boolean;
    protected isContextDisabled(): boolean;
    protected queueUpdate: () => void;
}
interface ViewerMixinInterface {
    viewer: VntanaViewer | null;
    readonly computedViewer: VntanaViewer | null;
}
interface TargetMixinInterface {
    target: HTMLElement | null;
    readonly computedTarget: HTMLElement | null;
}
interface ActiveMixinInterface {
    active: boolean;
}
/** BUTTONS **/
declare class ButtonBase extends UIElement {
    static get styles(): CSSResultGroup;
    updated(changes: Map<PropertyKey, any>): void;
}
declare const ElementButton_base: Constructor<ActiveMixinInterface> & Constructor<TargetMixinInterface> & Constructor<ViewerMixinInterface> & typeof ButtonBase;
declare abstract class ElementButton<T extends HTMLElement> extends ElementButton_base {
    #private;
    protected [$element]: T | null;
    protected abstract [$createElement](): T;
    protected [$destroyElement](): void;
    disconnectedCallback(): void;
    protected [$onActiveChange](): void;
    updated(changes: Map<PropertyKey, any>): void;
}
declare const ViewerButton: Constructor<ViewerMixinInterface> & typeof ButtonBase;
type ViewerButton = InstanceType<typeof ViewerButton>;

declare const VntanaFSButton_base: Constructor<ActiveMixinInterface> & Constructor<TargetMixinInterface> & typeof ButtonBase;
declare class VntanaFSButton extends VntanaFSButton_base {
    #private;
    protected [$onTargetChange](oldTarget: Element | null, newTarget: Element | null): void;
    protected [$onActiveChange](): void;
    protected isContextDisabled(): boolean;
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-fs-button': VntanaFSButton;
    }
}

declare abstract class VntanaQRButtonBase<T extends HTMLElement> extends ElementButton<T> {
    static get styles(): CSSResultGroup;
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    protected isContextDisabled(): boolean;
    render(): lit_html.TemplateResult<1>;
}

declare class VntanaQROverlay extends UIElement {
    static get styles(): CSSResultGroup;
    url: string;
    constructor();
    protected shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    updated(changes: Map<PropertyKey, any>): void;
    isContextDisabled(): boolean;
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-qr-overlay': VntanaQROverlay;
    }
}

declare class VntanaQRButton extends VntanaQRButtonBase<VntanaQROverlay> {
    #private;
    protected [$createElement](): VntanaQROverlay;
    shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    updated(changes: Map<PropertyKey, any>): void;
    get url(): string | null;
    set url(value: string | null | undefined);
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-qr-button': VntanaQRButton;
    }
}

declare abstract class VntanaARButtonBase<T extends HTMLElement & {
    viewer: VntanaViewer | null;
}> extends ElementButton<T> {
    #private;
    static get styles(): CSSResultGroup;
    abstract paths(): {
        src: string;
        usdzSrc: string;
    } | Promise<{
        src: string;
        usdzSrc: string;
    }>;
    constructor();
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    protected viewerHost(): boolean;
    protected isActivatable(): boolean;
    render(): lit_html.TemplateResult<1>;
}

declare const $state: unique symbol;
declare const $layout: unique symbol;
declare const VntanaAROverlay_base: Constructor<ViewerMixinInterface> & typeof UIElement;
declare class VntanaAROverlay extends VntanaAROverlay_base {
    #private;
    static get styles(): CSSResultGroup;
    private [$state];
    private [$layout];
    constructor();
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    protected shouldUpdate(changes: Map<any, any>): boolean;
    protected isContextDisabled(): boolean;
    render(): lit_html.TemplateResult<1> | undefined;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-ar-overlay': VntanaAROverlay;
    }
}

declare class VntanaARButton extends VntanaARButtonBase<VntanaAROverlay> {
    #private;
    protected [$createElement](): VntanaAROverlay;
    shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    protected isContextDisabled(): boolean;
    paths(): {
        src: string;
        usdzSrc: string;
    };
    get src(): string | null;
    set src(value: string | null | undefined);
    get usdzSrc(): string | null;
    set usdzSrc(value: string | null | undefined);
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-ar-button': VntanaARButton;
    }
}

declare const VntanaCenterButton_base: Constructor<ViewerMixinInterface> & typeof ButtonBase;
declare class VntanaCenterButton extends VntanaCenterButton_base {
    constructor();
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-center-button': VntanaCenterButton;
    }
}

declare class ZoomButton extends ViewerButton {
    #private;
    factor: number;
    constructor();
    disconnectedCallback(): void;
    protected [$onViewerChange](_oldViewer: VntanaViewer | null, _newViewer: VntanaViewer | null): void;
}
declare class VntanaZoomInButton extends ZoomButton {
    constructor();
    render(): lit_html.TemplateResult<1>;
}
declare class VntanaZoomOutButton extends ZoomButton {
    constructor();
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-zoom-in-button': VntanaZoomInButton;
        'vntana-zoom-out-button': VntanaZoomOutButton;
    }
}

declare class PointerDragController {
    protected host: HTMLElement;
    protected target: HTMLElement | null;
    protected prevX: number;
    protected prevY: number;
    protected minWidth: number;
    protected maxWidth: number;
    protected minHeight: number;
    protected maxHeight: number;
    protected rect: DOMRect | null;
    protected parentRect: DOMRect | null;
    constructor(host: HTMLElement);
    start: (event: PointerEvent) => void;
    protected onEnd: () => void;
    protected onMove: (_event: PointerEvent) => void;
}
declare class PanController extends PointerDragController {
    protected onMove: (event: PointerEvent) => void;
}
declare class ResizeController extends PointerDragController {
    protected onMove: (event: PointerEvent) => void;
}

declare const $pan: unique symbol;
declare const $resize: unique symbol;
declare const WindowElement_base: Constructor<ViewerMixinInterface> & typeof UIElement;
declare class WindowElement extends WindowElement_base {
    #private;
    static get styles(): (lit.CSSResultOrNative | lit.CSSResultArray)[];
    collapsed: boolean;
    protected [$pan]?: PanController;
    protected [$resize]?: ResizeController;
    constructor();
    connectedCallback(): void;
    disconnectedCallback(): void;
    renderHeader(title: string): lit_html.TemplateResult<1>;
    renderFooter(): lit_html.TemplateResult<1>;
    protected shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    protected updated(changes: Map<PropertyKey, any>): void;
}

declare const $items: unique symbol;
declare const $searchQuery: unique symbol;
declare class VntanaSceneGraph extends WindowElement {
    #private;
    static get styles(): (lit.CSSResultOrNative | lit.CSSResultArray)[];
    private [$searchQuery];
    private [$items];
    constructor();
    connectedCallback(): void;
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    protected shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    shouldRender(): boolean;
    render(): lit_html.TemplateResult<1>;
    private renderItems;
    private renderSearchResults;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-scene-graph': VntanaSceneGraph;
    }
}

declare class VntanaSceneGraphButton extends ElementButton<VntanaSceneGraph> {
    protected [$createElement](): VntanaSceneGraph;
    protected isContextDisabled(): boolean;
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-scene-graph-button': VntanaSceneGraphButton;
    }
}

declare class VntanaExplodedView extends ViewerButton {
    #private;
    static get styles(): CSSResultGroup;
    constructor();
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    render(): lit_html.TemplateResult<1>;
    get value(): number;
}

declare const units: readonly ["m", "cm", "mm", "ft", "in"];
declare const precisions: readonly [0, 1, 2, 3, 4, 5];
type Unit = typeof units[number];
type Precision = typeof precisions[number];

type MeasurementsEvents = {
    add: {};
    remove: {};
    select: {};
    deselect: {};
    clear: {};
    edit: {};
};
type MeasurementsEventType = keyof MeasurementsEvents;

declare class VntanaMeasurements extends WindowElement {
    #private;
    static get styles(): (lit.CSSResultOrNative | lit.CSSResultArray)[];
    used: boolean;
    selected: boolean;
    unit: Unit;
    precision: Precision;
    constructor();
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    protected shouldUpdate(changes: Map<PropertyKey, any>): boolean;
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-measurements': VntanaMeasurements;
    }
}

type MeasurementsAction = Exclude<MeasurementsEventType, "select" | "deselect">;
declare class VntanaMeasurementsButton extends ElementButton<VntanaMeasurements> {
    #private;
    protected [$createElement](): VntanaMeasurements;
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    protected isContextDisabled(): boolean;
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-measurements-button': VntanaMeasurementsButton;
    }
}

declare const VntanaDimensionsButton_base: Constructor<ActiveMixinInterface> & Constructor<ViewerMixinInterface> & typeof ButtonBase;
declare class VntanaDimensionsButton extends VntanaDimensionsButton_base {
    protected [$onViewerChange](oldViewer: VntanaViewer | null, newViewer: VntanaViewer | null): void;
    protected [$onActiveChange](): void;
    render(): lit_html.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'vntana-dimensions-button': VntanaDimensionsButton;
    }
}

export { VntanaARButton, VntanaAROverlay, VntanaCenterButton, VntanaDimensionsButton, VntanaExplodedView, VntanaFSButton, VntanaHotspot, VntanaMeasurements, VntanaMeasurementsButton, VntanaQRButton, VntanaQROverlay, VntanaSceneGraph, VntanaSceneGraphButton, VntanaViewer, VntanaZoomInButton, VntanaZoomOutButton };
export type { MeasurementsAction };