@liveroom-tech/react-immersive 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,672 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ComponentProps, ReactNode, MutableRefObject } from 'react';
+import { CameraControls } from '@react-three/drei';
+import { Object3D, WebGLRenderer, Scene, Camera } from 'three';
+import { XRStore } from '@react-three/xr';
+import { Canvas } from '@react-three/fiber';
+import { PresetsType } from '@react-three/drei/helpers/environment-assets';
+
+declare const LIGHT_TYPES: readonly ["none", "directional", "point", "hemisphere"];
+type SceneLightType = (typeof LIGHT_TYPES)[number];
+type SceneLight = {
+    id: string;
+    type: SceneLightType;
+    color: string;
+    intensity: number;
+    position: [number, number, number];
+    attachedToCamera: boolean;
+    castShadow: boolean;
+    shadowBias: number;
+    visible: boolean;
+};
+type SceneLightingConfig = {
+    ambient: {
+        intensity: number;
+        color: string;
+    };
+    lights: SceneLight[];
+};
+type SceneModelConfig = {
+    rotation: [number, number, number];
+    showAdvancedRotation: boolean;
+    renderer: "pbr" | "matcap";
+    shading: "lit" | "unlit" | "normals";
+};
+type SceneCameraConfig = {
+    fieldOfView: number;
+    showAdvancedSettings: boolean;
+};
+type SceneShadowConfig = {
+    enabled: boolean;
+    mapSize: number;
+    bias: number;
+    normalBias: number;
+    radius: number;
+};
+declare const ENVIRONMENT_PRESETS: readonly ["apartment", "city", "dawn", "forest", "lobby", "night", "park", "studio", "sunset", "warehouse"];
+type EnvironmentPreset = (typeof ENVIRONMENT_PRESETS)[number];
+type SceneEnvironmentConfig = {
+    source: "preset" | "custom";
+    preset: EnvironmentPreset;
+    customEnvironmentUrl: string;
+    intensity: number;
+    rotation: number;
+    shadowLight: {
+        enabled: boolean;
+        intensity: number;
+        bias: number;
+    };
+};
+type SceneWireframeConfig = {
+    enabled: boolean;
+    color: string;
+    opacity: number;
+};
+type SceneBackgroundConfig = {
+    enabled: boolean;
+    type: "environment" | "image" | "color";
+    color: string;
+    imageUrl: string;
+};
+type SceneGroundShadowConfig = {
+    enabled: boolean;
+    mode: "shadowCatcher" | "bakedAO";
+    intensity: number;
+    borderFade: number;
+    height: number;
+    size: number;
+};
+declare const ANIMATION_LOOP_MODES: readonly ["repeat", "once"];
+type AnimationLoopMode = (typeof ANIMATION_LOOP_MODES)[number];
+type SceneAnimationClipConfig = {
+    sourceName: string;
+    displayName: string;
+    hidden: boolean;
+    loopMode: AnimationLoopMode;
+    speed: number;
+};
+type SceneAnimationConfig = {
+    clips: SceneAnimationClipConfig[];
+    autoplayClip: string | null;
+};
+declare const GLITCH_MODES: readonly ["sporadic", "constantMild", "constantWild"];
+type GlitchModeName = (typeof GLITCH_MODES)[number];
+declare const RAMP_TYPES: readonly ["linear", "radial", "mirroredLinear"];
+type RampTypeName = (typeof RAMP_TYPES)[number];
+declare const KERNEL_SIZE_NAMES: readonly ["verySmall", "small", "medium", "large", "veryLarge", "huge"];
+type KernelSizeName = (typeof KERNEL_SIZE_NAMES)[number];
+type ScenePostProcessingConfig = {
+    autofocus: {
+        enabled: boolean;
+        focusDistance: number;
+        focusRange: number;
+        focalLength: number;
+        bokehScale: number;
+        target: [number, number, number];
+        mouse: boolean;
+        debug: number;
+        manual: boolean;
+        smoothTime: number;
+    };
+    toneMapping: {
+        enabled: boolean;
+        mode: "linear" | "reinhard" | "aces";
+        exposure: number;
+        resolution: number;
+        whitePoint: number;
+        middleGrey: number;
+        minLuminance: number;
+        averageLuminance: number;
+        adaptationRate: number;
+    };
+    brightnessContrast: {
+        enabled: boolean;
+        brightness: number;
+        contrast: number;
+    };
+    hueSaturation: {
+        enabled: boolean;
+        hue: number;
+        saturation: number;
+    };
+    colorAverage: {
+        enabled: boolean;
+    };
+    dotScreen: {
+        enabled: boolean;
+        angle: number;
+        scale: number;
+    };
+    glitch: {
+        enabled: boolean;
+        mode: GlitchModeName;
+        delay: [number, number];
+        duration: [number, number];
+        strength: [number, number];
+        chromaticAberrationOffset: [number, number];
+        columns: number;
+        ratio: number;
+    };
+    ssao: {
+        enabled: boolean;
+        samples: number;
+        rings: number;
+        intensity: number;
+        radius: number;
+        bias: number;
+        luminanceInfluence: number;
+        fade: number;
+        minRadiusScale: number;
+        worldDistanceThreshold: number;
+        worldDistanceFalloff: number;
+        worldProximityThreshold: number;
+        worldProximityFalloff: number;
+    };
+    bloom: {
+        enabled: boolean;
+        intensity: number;
+        luminanceThreshold: number;
+        luminanceSmoothing: number;
+        mipmapBlur: boolean;
+        radius: number;
+        levels: number;
+    };
+    godRays: {
+        enabled: boolean;
+        sunPosition: [number, number, number];
+        samples: number;
+        density: number;
+        decay: number;
+        weight: number;
+        exposure: number;
+        clampMax: number;
+        blur: boolean;
+        kernelSize: KernelSizeName;
+    };
+    grid: {
+        enabled: boolean;
+        scale: number;
+        lineWidth: number;
+    };
+    noise: {
+        enabled: boolean;
+        opacity: number;
+        premultiply: boolean;
+    };
+    depthOfField: {
+        enabled: boolean;
+        focusDistance: number;
+        focusRange: number;
+        focalLength: number;
+        bokehScale: number;
+    };
+    chromaticAberration: {
+        enabled: boolean;
+        offsetX: number;
+        offsetY: number;
+        radialModulation: boolean;
+        modulationOffset: number;
+    };
+    lensflare: {
+        enabled: boolean;
+        lensPosition: [number, number, number];
+        smoothTime: number;
+        glareSize: number;
+        flareSize: number;
+        flareSpeed: number;
+        flareShape: number;
+        animated: boolean;
+        anamorphic: boolean;
+        colorGain: string;
+        haloScale: number;
+        secondaryGhosts: boolean;
+        aditionalStreaks: boolean;
+        ghostScale: number;
+        opacity: number;
+        starBurst: boolean;
+    };
+    vignette: {
+        enabled: boolean;
+        offset: number;
+        darkness: number;
+        eskil: boolean;
+    };
+    smaa: {
+        enabled: boolean;
+    };
+    sepia: {
+        enabled: boolean;
+        intensity: number;
+    };
+    scanline: {
+        enabled: boolean;
+        density: number;
+    };
+    pixelation: {
+        enabled: boolean;
+        granularity: number;
+    };
+    outline: {
+        enabled: boolean;
+        selectionLayer: number;
+        edgeStrength: number;
+        pulseSpeed: number;
+        visibleEdgeColor: string;
+        hiddenEdgeColor: string;
+        kernelSize: KernelSizeName;
+        blur: boolean;
+        xRay: boolean;
+    };
+    selectiveBloom: {
+        enabled: boolean;
+        selectionLayer: number;
+        intensity: number;
+        luminanceThreshold: number;
+        luminanceSmoothing: number;
+        kernelSize: KernelSizeName;
+        mipmapBlur: boolean;
+        inverted: boolean;
+        ignoreBackground: boolean;
+    };
+    ramp: {
+        enabled: boolean;
+        rampType: RampTypeName;
+        rampStart: [number, number];
+        rampEnd: [number, number];
+        startColor: string;
+        endColor: string;
+        rampBias: number;
+        rampGain: number;
+        rampMask: boolean;
+        rampInvert: boolean;
+    };
+};
+type SceneAnnotationMarker = {
+    id: number;
+    worldPosition: [number, number, number];
+    localPosition: [number, number, number];
+    worldNormal?: [number, number, number];
+    anchorNodeName?: string;
+    anchorLocalPosition?: [number, number, number];
+    title: string;
+    description: string;
+};
+type SceneConfig = {
+    model: SceneModelConfig;
+    camera: SceneCameraConfig;
+    lighting: SceneLightingConfig;
+    wireframe: SceneWireframeConfig;
+    shadows: SceneShadowConfig;
+    environment: SceneEnvironmentConfig;
+    background: SceneBackgroundConfig;
+    groundShadows: SceneGroundShadowConfig;
+    postProcessing: ScenePostProcessingConfig;
+    animations: SceneAnimationConfig;
+    annotations: SceneAnnotationMarker[];
+};
+
+type CanvasCamera = ComponentProps<typeof Canvas>["camera"];
+
+type RendererCapture = {
+    gl: WebGLRenderer;
+    scene: Scene;
+    camera: Camera;
+    invalidate: () => void;
+};
+type Props = {
+    children: ReactNode;
+    camera?: CanvasCamera;
+    backgroundColor?: string;
+    shadows?: boolean;
+    sceneConfig?: SceneConfig;
+    selectedObjectRef?: Object3D | null;
+    hoveredObjectRef?: Object3D | null;
+    highlightOnHover?: boolean;
+    renderMode?: "always" | "demand";
+    maxDpr?: number;
+    xrStore?: XRStore | null;
+    rendererCaptureRef?: MutableRefObject<RendererCapture | null>;
+    reduceGpuLoad?: boolean;
+};
+declare function Viewer({ children, camera, backgroundColor, shadows, sceneConfig, selectedObjectRef, hoveredObjectRef, highlightOnHover, renderMode, maxDpr, xrStore, rendererCaptureRef, reduceGpuLoad, }: Props): react_jsx_runtime.JSX.Element;
+
+type PerformanceProfile = "auto" | "high" | "low";
+
+type MouseControllerPosition = 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right' | 'center' | 'center-bottom' | 'center-top';
+
+type ObjectBindingAction = {
+    id: "change-color" | "apply-texture" | "toggle-visibility" | string;
+    label: string;
+    type: "command";
+};
+type ObjectBindingType = "body" | "other" | "glass" | "windshield" | "rear-windshield" | "window" | "sunroof" | "wheel" | "rim" | "tire" | "brake-caliper" | "brake-disc" | "suspension" | "spring" | "shock-absorber" | "axle" | "control-arm" | "interior" | "seat" | "headrest" | "seatbelt" | "dashboard" | "steering-wheel" | "gear-shift" | "center-console" | "armrest" | "door-panel" | "carpet" | "headliner" | "sun-visor" | "pedal" | "instrument-cluster" | "infotainment" | "glove-box" | "engine" | "gearbox" | "radiator" | "battery" | "fuel-tank" | "air-filter" | "intercooler" | "alternator" | "turbo" | "light" | "headlight" | "taillight" | "fog-light" | "indicator" | "daytime-running-light" | "interior-light" | "ambient-light" | "floor" | "floor-tile" | "floor-board" | "floor-mat" | "ceiling" | "ceiling-tile" | "wall" | "wall-tile" | "wall-panel" | "wall-trim" | "baseboard" | "crown-molding" | "column" | "pillar" | "beam" | "arch" | "stairs" | "step" | "railing" | "balustrade" | "window-frame" | "window-sill" | "blind" | "curtain" | "shutter" | "door" | "door-frame" | "door-knob" | "furniture" | "sofa" | "armchair" | "ottoman" | "bed" | "headboard" | "mattress" | "nightstand" | "dresser" | "wardrobe" | "closet" | "shelf" | "bookcase" | "desk" | "office-chair" | "dining-table" | "dining-chair" | "bar-stool" | "bench" | "cabinet" | "sideboard" | "coffee-table" | "side-table" | "tv-stand" | "kitchen-island" | "countertop" | "sink" | "bathtub" | "shower" | "toilet" | "vanity" | "decor" | "rug" | "cushion" | "throw" | "curtain-rod" | "artwork" | "mirror" | "vase" | "plant" | "pot" | "candle" | "frame" | "sculpture" | "clock" | "lamp" | "floor-lamp" | "table-lamp" | "pendant-light" | "chandelier" | "sconce" | "ceiling-fan" | "electronics" | "tv" | "monitor" | "speaker" | "soundbar" | "projector" | "remote" | "console" | "router" | "smart-hub" | "thermostat" | "appliance" | "refrigerator" | "oven" | "microwave" | "dishwasher" | "washing-machine" | "dryer" | "air-conditioner" | "heater" | "ventilation" | "root" | "bone" | "joint" | "socket" | "pivot" | "head" | "face" | "eye" | "eyelid" | "eyebrow" | "mouth" | "teeth" | "tongue" | "ear" | "nose" | "hair" | "beard" | "neck" | "torso" | "chest" | "abdomen" | "back" | "shoulder" | "upper-arm" | "forearm" | "hand" | "finger" | "thumb" | "hip" | "thigh" | "shin" | "foot" | "toe" | "tail" | "wing" | "tentacle" | "clothing" | "hat" | "helmet" | "visor" | "mask" | "goggles" | "glasses" | "jacket" | "shirt" | "pants" | "skirt" | "shoes" | "boots" | "gloves" | "belt" | "watch" | "bag" | "backpack" | "jewelry" | "necklace" | "ring" | "armor" | "chest-plate" | "pauldron" | "gauntlet" | "greave" | "shield" | "weapon" | "blade" | "edge" | "tip" | "guard" | "grip" | "pommel" | "barrel" | "stock" | "scope" | "trigger" | "magazine" | "muzzle" | "gear" | "piston" | "lever" | "valve" | "pump" | "motor" | "rotor" | "blade-prop" | "nozzle" | "pipe" | "tube" | "cable" | "wire" | "connector" | "panel" | "hatch" | "vent" | "antenna" | "sensor" | "camera" | "screen" | "dial" | "button" | "knob" | "switch" | "gauge" | "terrain" | "ground" | "rock" | "cliff" | "water" | "ocean" | "river" | "lake" | "wave" | "foam" | "sky" | "cloud" | "sun" | "moon" | "star" | "fog" | "foliage" | "tree" | "branch" | "leaf" | "grass" | "bush" | "flower" | "soil" | "sand" | "snow" | "ice" | "facade" | "foundation" | "roof-structure" | "chimney" | "balcony" | "porch" | "pathway" | "fence" | "gate" | "wall-exterior";
+type ObjectBindingStatus = "normal" | "hidden" | "selected" | "disabled";
+type ObjectBindingTextureSlot = {
+    path: string;
+};
+declare const MATERIAL_SIDES: readonly ["front", "back", "double"];
+type ObjectBindingMaterialSide = (typeof MATERIAL_SIDES)[number];
+declare const MATERIAL_BLENDING_MODES: readonly ["normal", "additive"];
+type ObjectBindingMaterialBlendingMode = (typeof MATERIAL_BLENDING_MODES)[number];
+type ObjectBindingMaterial = {
+    texture?: ObjectBindingTextureSlot;
+    baseColor?: string;
+    metalness?: number;
+    metalnessMap?: ObjectBindingTextureSlot;
+    roughness?: number;
+    roughnessMap?: ObjectBindingTextureSlot;
+    emissive?: string;
+    emissiveIntensity?: number;
+    emissiveMap?: ObjectBindingTextureSlot;
+    opacity?: number;
+    alphaMap?: ObjectBindingTextureSlot;
+    alphaTest?: number;
+    alphaHash?: boolean;
+    dithering?: boolean;
+    blendingMode?: ObjectBindingMaterialBlendingMode;
+    side?: ObjectBindingMaterialSide;
+    normalMap?: ObjectBindingTextureSlot;
+    normalScale?: number;
+    flipNormalY?: boolean;
+    bumpMap?: ObjectBindingTextureSlot;
+    bumpScale?: number;
+    aoMap?: ObjectBindingTextureSlot;
+    aoMapIntensity?: number;
+    displacementMap?: ObjectBindingTextureSlot;
+    displacementScale?: number;
+    displacementBias?: number;
+    clearcoat?: number;
+    clearcoatMap?: ObjectBindingTextureSlot;
+    clearcoatRoughness?: number;
+    clearcoatRoughnessMap?: ObjectBindingTextureSlot;
+    clearcoatNormalMap?: ObjectBindingTextureSlot;
+    clearcoatNormalScale?: number;
+    flipClearcoatNormalY?: boolean;
+    sheen?: number;
+    sheenColor?: string;
+    sheenColorMap?: ObjectBindingTextureSlot;
+    sheenRoughness?: number;
+    sheenRoughnessMap?: ObjectBindingTextureSlot;
+    anisotropy?: number;
+    anisotropyRotation?: number;
+    anisotropyMap?: ObjectBindingTextureSlot;
+    transmission?: number;
+    transmissionMap?: ObjectBindingTextureSlot;
+    thickness?: number;
+    thicknessMap?: ObjectBindingTextureSlot;
+    attenuationColor?: string;
+    attenuationDistance?: number;
+    reflectivity?: number;
+    specularIntensity?: number;
+    specularIntensityMap?: ObjectBindingTextureSlot;
+    specularColor?: string;
+    specularColorMap?: ObjectBindingTextureSlot;
+};
+type ObjectBindingCameraState = {
+    position?: [number, number, number];
+    target?: [number, number, number];
+    fov?: number;
+    zoom?: number;
+};
+type ObjectBindingStyle = {
+    material?: ObjectBindingMaterial;
+};
+type ObjectBinding = {
+    id: string;
+    type: ObjectBindingType;
+    modelObjectId: string;
+    label?: string;
+    status?: ObjectBindingStatus;
+    visible?: boolean;
+    selectable?: boolean;
+    hoverable?: boolean;
+    style?: ObjectBindingStyle;
+    actions?: ObjectBindingAction[];
+    metrics?: Record<string, number>;
+    metadata?: Record<string, unknown>;
+    cameraState?: ObjectBindingCameraState;
+};
+type ObjectActionEvent = {
+    objectId: string;
+    action: ObjectBindingAction;
+    binding?: ObjectBinding;
+    screenX?: number;
+    screenY?: number;
+};
+
+type CaptureImageOptions = {
+    width?: number;
+    height?: number;
+    transparent?: boolean;
+};
+
+type ViewerCameraState = {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov: number | null;
+    zoom: number;
+};
+type HomeCameraState = {
+    position: [number, number, number];
+    target: [number, number, number];
+};
+type ViewerReadyState = {
+    controls: CameraControls;
+    scene: Object3D | null;
+    objectBindings: Record<string, ObjectBinding>;
+    nodeRefs: Record<string, Object3D>;
+    homeCameraState: HomeCameraState | null;
+    captureImage: (options?: CaptureImageOptions) => Promise<string>;
+};
+type ViewerCameraProps = {
+    cameraState: ViewerCameraState | null;
+    resetView: () => Promise<boolean>;
+    focusObject: (objectId: string) => Promise<boolean>;
+    fitScene: () => Promise<boolean>;
+    setCameraTarget: (target: [number, number, number], enableTransition?: boolean) => Promise<boolean>;
+    setCameraState: (state: ViewerCameraState, enableTransition?: boolean) => Promise<boolean>;
+    handleCameraChange: (camera: Camera, controls: CameraControls) => void;
+    handleViewerReady: (viewer: ViewerReadyState) => void;
+};
+declare function useViewerCamera(): ViewerCameraProps;
+
+type AnimationClipInfo = {
+    sourceName: string;
+    duration: number;
+};
+type AnimationPlaybackState = {
+    currentClip: string | null;
+    isPlaying: boolean;
+    speed: number;
+    time: number;
+    duration: number;
+};
+type AnimationControls = {
+    clips: string[];
+    clipDetails?: AnimationClipInfo[];
+    play: (clipName: string) => void;
+    pause: () => void;
+    stop: () => void;
+    setSpeed: (speed: number) => void;
+    seek?: (time: number) => void;
+    getState?: () => AnimationPlaybackState;
+    subscribe?: (listener: (state: AnimationPlaybackState) => void) => () => void;
+};
+type ViewerAnimationsProps = {
+    clips: string[];
+    clipDetails: AnimationClipInfo[];
+    currentClip: string | null;
+    isPlaying: boolean;
+    speed: number;
+    time: number;
+    duration: number;
+    play: (clipName: string) => void;
+    pause: () => void;
+    stop: () => void;
+    setSpeed: (speed: number) => void;
+    seek: (time: number) => void;
+    handleAnimationsReady: (controls: AnimationControls) => void;
+};
+declare function useViewerAnimations(): ViewerAnimationsProps;
+
+type ViewerCamera = React.ComponentProps<typeof Viewer>["camera"];
+type AnnotationMarker = SceneAnnotationMarker & {
+    markerId?: string;
+};
+type CustomObjectBindingDataPanelProps = {
+    isOpen: boolean;
+    selectedObject: ObjectBinding | null;
+    currentAction: ObjectActionEvent | null;
+    onClose: () => void;
+    onAction: (event: ObjectActionEvent) => void;
+};
+type CustomSceneObjectsPanelProps = {
+    objectBindings: Record<string, ObjectBinding>;
+    onAction?: (event: ObjectActionEvent) => void;
+    onFocus?: (binding: ObjectBinding) => void;
+    onHover?: (binding: ObjectBinding | null) => void;
+};
+type ModelViewerProps = {
+    modelUrl: string;
+    licenseKey: string;
+    objectBindings: Record<string, ObjectBinding>;
+    selectedObject?: ObjectBinding | null;
+    panelHoveredObject?: ObjectBinding | null;
+    onObjectBindingsChange?: (next: Record<string, ObjectBinding>) => void;
+    onObjectSelect?: (binding: ObjectBinding | null) => void;
+    onObjectHover?: (binding: ObjectBinding | null) => void;
+    onModelLoaded?: (scene: Object3D) => void;
+    onLoadError?: (error: unknown) => void;
+    onAction?: (event: ObjectActionEvent) => void;
+    onHiddenObjectsChange?: (next: Record<string, boolean>) => void;
+    onCameraChange?: (camera: Camera, controls: CameraControls) => void;
+    onViewerReady?: (viewer: ViewerReadyState) => void;
+    onTextureUpload?: (file: File, objectId: string) => Promise<string>;
+    onAnimationsReady?: (controls: AnimationControls) => void;
+    onAnnotationsChange?: (annotations: AnnotationMarker[]) => void;
+    activeAnnotation?: AnnotationMarker | null;
+    onActiveAnnotationChange?: (annotation: AnnotationMarker | null) => void;
+    lights?: ReactNode;
+    camera?: ViewerCamera;
+    backgroundColor?: string;
+    shadows?: boolean;
+    showObjectBindingDataPanel?: boolean;
+    customObjectBindingDataPanel?: (props: CustomObjectBindingDataPanelProps) => ReactNode;
+    customSceneObjectsPanel?: (props: CustomSceneObjectsPanelProps) => ReactNode;
+    showSceneObjectsPanel?: boolean;
+    showDownloadButton?: boolean;
+    downloadFilename?: string;
+    showResetButton?: boolean;
+    showDownloadButtons?: boolean;
+    showLoadingOverlay?: boolean;
+    showMouseController?: boolean;
+    mouseControllerPosition?: MouseControllerPosition;
+    mouseControllerOpacity?: number;
+    moveSensitivity?: number;
+    zoomSensitivity?: number;
+    sceneConfig?: SceneConfig;
+    disableZoom?: boolean;
+    zoomOnSelected?: boolean;
+    highlightOnHover?: boolean;
+    onAutoFit?: () => Promise<boolean>;
+    refitOnResize?: boolean;
+    renderMode?: "always" | "demand";
+    maxDpr?: number;
+    performanceProfile?: PerformanceProfile;
+    dracoDecoderPath?: string | false;
+    ktx2TranscoderPath?: string | false;
+    meshopt?: boolean;
+    showMeasureTools?: boolean;
+    measurementUnit?: string;
+    enableXR?: boolean;
+    usdzUrl?: string;
+    showAnnotationNavigation?: boolean;
+};
+declare function ModelViewer({ modelUrl, licenseKey, objectBindings, selectedObject, panelHoveredObject, onObjectBindingsChange, onObjectSelect, onObjectHover, onModelLoaded, onLoadError, onAction, onHiddenObjectsChange, onCameraChange, onViewerReady, onTextureUpload, onAnimationsReady, onAnnotationsChange, activeAnnotation: controlledActiveAnnotation, onActiveAnnotationChange, lights, camera, backgroundColor, shadows, showObjectBindingDataPanel, customObjectBindingDataPanel, customSceneObjectsPanel, showSceneObjectsPanel, showDownloadButton, downloadFilename, showResetButton, showDownloadButtons, showLoadingOverlay, showMouseController, mouseControllerPosition, mouseControllerOpacity, moveSensitivity, zoomSensitivity, sceneConfig, disableZoom, zoomOnSelected, highlightOnHover, onAutoFit, refitOnResize, renderMode, maxDpr, performanceProfile, dracoDecoderPath, ktx2TranscoderPath, meshopt, showMeasureTools, measurementUnit, enableXR, usdzUrl, showAnnotationNavigation, }: ModelViewerProps): react_jsx_runtime.JSX.Element;
+
+declare function BindingBuilder({ licenseKey }: {
+    licenseKey: string;
+}): react_jsx_runtime.JSX.Element;
+
+type SimpleModelViewerProps = {
+    modelUrl: string;
+    backgroundColor?: string;
+    showSceneObjectsPanel?: boolean;
+    showSceneSettingsPanel?: boolean;
+    enableModelUpload?: boolean;
+    zoomOnSelected?: boolean;
+    highlightOnHover?: boolean;
+    showLoadingOverlay?: boolean;
+    refitOnResize?: boolean;
+    backgroundEnabled?: boolean;
+    autoRotate?: boolean;
+    envPreset?: PresetsType;
+    exposure?: number;
+    ambientIntensity?: number;
+    ambientColor?: string;
+    directionalIntensity?: number;
+    directionalColor?: string;
+    onModelLoaded?: (scene: Object3D) => void;
+    onLoadError?: (error: unknown) => void;
+};
+declare function SimpleModelViewer({ modelUrl, backgroundColor, showSceneObjectsPanel, showSceneSettingsPanel, enableModelUpload, zoomOnSelected, highlightOnHover, showLoadingOverlay, refitOnResize, backgroundEnabled, autoRotate, envPreset, exposure, ambientIntensity, ambientColor, directionalIntensity, directionalColor, onModelLoaded, onLoadError, }: SimpleModelViewerProps): react_jsx_runtime.JSX.Element;
+
+type ViewerSelectionProps = {
+    selectedObjectBinding: ObjectBinding | null;
+    setSelectedObjectBinding: (binding: ObjectBinding | null) => void;
+    handleObjectSelect: (binding: ObjectBinding | null) => void;
+    clearSelection: () => void;
+};
+declare function useViewerSelection(initialSelectedObjectBinding?: ObjectBinding | null): ViewerSelectionProps;
+
+declare function useObjectBinding(objectBindings: Record<string, ObjectBinding>, objectId: string | null | undefined): ObjectBinding | null;
+
+declare function useObjectBindingIds(objectBindings: Record<string, ObjectBinding>): string[];
+
+type HiddenObjectsState = Record<string, boolean>;
+type ObjectVisibilityProps = {
+    hiddenObjects: HiddenObjectsState;
+    hiddenObjectIds: string[];
+    hideObject: (objectId: string) => void;
+    showObject: (objectId: string) => void;
+    toggleObjectVisibility: (objectId: string) => void;
+    isObjectHidden: (objectId: string) => boolean;
+    clearHiddenObjects: () => void;
+};
+declare function useObjectVisibility(objectBindings: Record<string, ObjectBinding>, onObjectBindingsChange: (next: Record<string, ObjectBinding>) => void): ObjectVisibilityProps;
+
+type ViewerHoverProps = {
+    hoveredObjectBinding: ObjectBinding | null;
+    handleHoveredObject: (binding: ObjectBinding | null) => void;
+};
+declare function useViewerHover(): ViewerHoverProps;
+
+type ViewerModelBounds = {
+    min: [number, number, number];
+    max: [number, number, number];
+    center: [number, number, number];
+    size: [number, number, number];
+};
+type ViewerModelProps = {
+    isLoading: boolean;
+    isReady: boolean;
+    error: unknown;
+    bounds: ViewerModelBounds | null;
+    objectCount: number;
+    handleModelLoaded: (scene: Object3D) => void;
+    handleLoadError: (error: unknown) => void;
+    resetModelState: () => void;
+};
+declare function useViewerModel(): ViewerModelProps;
+
+type ViewerActionsOptions = {
+    onAction?: (event: ObjectActionEvent) => void;
+    onObjectBindingsChange?: (next: Record<string, ObjectBinding>) => void;
+};
+type ViewerActionsProps = {
+    getActionsForObject: (objectId: string) => ObjectBindingAction[];
+    runAction: (objectId: string, actionId: string) => ObjectActionEvent | null;
+};
+declare function useViewerActions(objectBindings: Record<string, ObjectBinding>, options?: ViewerActionsOptions): ViewerActionsProps;
+
+export { type AnimationClipInfo, type AnimationControls, type AnimationLoopMode, type AnimationPlaybackState, BindingBuilder, type CaptureImageOptions, type CustomObjectBindingDataPanelProps, type CustomSceneObjectsPanelProps, type HiddenObjectsState, type HomeCameraState, MATERIAL_BLENDING_MODES, MATERIAL_SIDES, ModelViewer, type ModelViewerProps, type ObjectActionEvent, type ObjectBinding, type ObjectBindingAction, type ObjectBindingMaterial, type ObjectBindingMaterialBlendingMode, type ObjectBindingMaterialSide, type ObjectBindingTextureSlot, type ObjectVisibilityProps, type SceneAnimationClipConfig, type SceneAnimationConfig, type SceneConfig, SimpleModelViewer, type SimpleModelViewerProps, type ViewerActionsOptions, type ViewerActionsProps, type ViewerAnimationsProps, type ViewerCameraProps, type ViewerCameraState, type ViewerModelBounds, type ViewerModelProps, type ViewerReadyState, type ViewerSelectionProps, useObjectBinding, useObjectBindingIds, useObjectVisibility, useViewerActions, useViewerAnimations, useViewerCamera, useViewerHover, useViewerModel, useViewerSelection };