@liveroom-tech/react-immersive 6.2.0 → 6.2.1

package/dist/modelFileResolver-CVmON8hg.d.ts

@@ -0,0 +1,1724 @@
+type ViewerCameraState = {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov: number | null;
+    zoom: number;
+    /**
+     * The camera's orbit angles, in radians, captured so setCameraState can
+     * restore the exact rotation (position and target alone are ambiguous
+     * straight above or below the target). Pass the state back as-is; to move
+     * the camera to angles you choose, use orbitTo, which takes degrees.
+     */
+    azimuthAngle?: number;
+    polarAngle?: number;
+};
+/** Where ModelViewer's camera starts. Setting it skips the automatic fit. */
+type ViewerCameraConfig = {
+    position?: [number, number, number];
+    /** Vertical field of view in degrees. */
+    fov?: number;
+    near?: number;
+    far?: number;
+    zoom?: number;
+};
+
+type DeepPartial<T> = T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+
+type ObjectBindingSelector = {
+    group: string;
+} | {
+    tag: string;
+} | {
+    type: ObjectBindingType;
+};
+type ObjectBindingTarget = string | readonly string[] | ObjectBindingSelector;
+/**
+ * Resolves IDs and selectors to binding-map keys in stable record order.
+ * Explicit ID arrays keep their supplied order. Duplicate matches are removed.
+ */
+declare function selectBindingKeys(bindings: Record<string, ObjectBinding>, target: ObjectBindingTarget): string[];
+/** Selects bindings by ID, group, tag, or binding type. */
+declare function selectBindings(bindings: Record<string, ObjectBinding>, target: ObjectBindingTarget): ObjectBinding[];
+
+type ObjectBindingPatch = DeepPartial<ObjectBinding>;
+type BindingEdit = {
+    ids: ObjectBindingTarget;
+    patch: ObjectBindingPatch;
+};
+/**
+ * Applies field-level patches to object bindings and returns the updated
+ * record. Pure — nothing is mutated, and the original reference comes back
+ * untouched when no id matched, so React can skip the re-render.
+ *
+ * Ids resolve the same way everywhere else in the library: binding key first,
+ * then `binding.id`, then `binding.modelObjectId`.
+ */
+declare function patchBindings(bindings: Record<string, ObjectBinding>, target: ObjectBindingTarget, patch: ObjectBindingPatch): Record<string, ObjectBinding>;
+declare function patchBindings(bindings: Record<string, ObjectBinding>, edits: BindingEdit[]): Record<string, ObjectBinding>;
+/** Shorthand for the common `{ style: { material: … } }` nesting. */
+declare function material(value: ObjectBindingMaterial): ObjectBindingPatch;
+
+type SequenceVector3 = [number, number, number];
+type SequenceEasing = "linear" | "ease-in" | "ease-out" | "ease-in-out" | "step";
+type SequenceCameraView = {
+    position: SequenceVector3;
+    target: SequenceVector3;
+    fov: number | null;
+    zoom: number;
+};
+type SequenceValue = number | boolean | string | SequenceVector3 | SequenceCameraView;
+type SequenceKeyframe = {
+    id: string;
+    /** Seconds on the sequence timeline. */
+    time: number;
+    value: SequenceValue;
+    /** Interpolation from this keyframe to the next. Default ease-in-out. */
+    easing?: SequenceEasing;
+};
+type SequenceObjectProperty = "position" | "rotation" | "scale" | "visible" | "baseColor" | "emissive" | "opacity" | "roughness" | "metalness" | "emissiveIntensity";
+type SequenceTarget = {
+    kind: "object";
+    objectId: string;
+    property: SequenceObjectProperty;
+} | {
+    kind: "camera";
+} | {
+    kind: "clip";
+    clip: string;
+};
+type SequenceTrack = {
+    id: string;
+    name: string;
+    target: SequenceTarget;
+    muted?: boolean;
+    keyframes: SequenceKeyframe[];
+};
+/** All object/clip ids are scoped to the model that owns this scene config. */
+type SceneSequence = {
+    id: string;
+    name: string;
+    duration: number;
+    loop: boolean;
+    autoPlay: boolean;
+    tracks: SequenceTrack[];
+};
+type SequencePlaybackState = {
+    sequenceId: string | null;
+    time: number;
+    duration: number;
+    status: "stopped" | "playing" | "paused" | "finished";
+    previewing: boolean;
+    ready: boolean;
+    issues: string[];
+};
+type SequenceControls = {
+    /** Stable snapshot for useSyncExternalStore. UI updates are throttled during playback. */
+    getState: () => SequencePlaybackState;
+    subscribe: (listener: () => void) => () => void;
+    select: (sequenceId: string) => boolean;
+    play: (sequenceId?: string) => boolean;
+    pause: () => void;
+    /** Restore the authored object, material, clip and camera state. */
+    stop: () => void;
+    /** Deterministic scrubbing, including backwards, without changing authored bindings. */
+    seek: (time: number) => boolean;
+    /** Read the live value for capture in the authoring UI. */
+    capture: (target: SequenceTarget) => SequenceValue | null;
+};
+
+type MeasurementUnit = "m" | "cm" | "mm" | "in" | "ft";
+type MeasurementTool = "distance" | "angle" | "area" | "pointToPlane" | "wrap" | "wrapHorizontal";
+type MeasurementPosition = [number, number, number];
+type MeasurementSettings = {
+    /** Authored model units. Default metres. Changing this should clear calibration. */
+    sourceUnit?: MeasurementUnit;
+    /** Unit used for lengths and areas. Default metres (or measurementUnit). */
+    displayUnit?: MeasurementUnit;
+    /** Calibration override: metres represented by one model unit. */
+    metersPerUnit?: number;
+};
+type MeasurementAnchor = {
+    nodeId: string;
+    localPosition: MeasurementPosition;
+    localNormal?: MeasurementPosition;
+    localFaceVertices?: MeasurementPosition[];
+    instanceId?: number;
+    /** Deterministic fingerprint of source geometry, independent of rigid transforms. */
+    geometrySignature: string;
+    /** Posed measurements are snapshots; a different pose requires remeasurement. */
+    poseSignature: string;
+};
+type MeasurementPoint = {
+    id: number;
+    position: MeasurementPosition;
+    normal?: MeasurementPosition;
+    faceVertices?: MeasurementPosition[];
+    snapped?: "vertex" | "edge";
+    anchor?: MeasurementAnchor;
+};
+type SavedMeasurement = {
+    id: string;
+    name: string;
+    /** Stable model identity; defaults to the canonical model URL. */
+    modelId: string;
+    tilesetUrl?: string | null;
+    tool: MeasurementTool;
+    points: MeasurementPoint[];
+    createdAt: string;
+    visible?: boolean;
+    /** Streamed geometry may represent a coarser LOD than the source model. */
+    approximate?: boolean;
+};
+/** Stored with sceneConfig, JSON exports, and shareable configurations. */
+type MeasurementCollection = {
+    settings: MeasurementSettings;
+    items: SavedMeasurement[];
+};
+type MeasurementStatus = "ready" | "approximate" | "model-changed" | "missing-object" | "geometry-changed" | "pose-changed" | "hidden-object" | "invalid";
+type MeasurementResult = {
+    id: string;
+    status: MeasurementStatus;
+    rawValue: number | null;
+    value: number | null;
+    unit: string;
+};
+
+type SceneSelectionSet = {
+    id: string;
+    name: string;
+    /** Stable modelObjectId values, scoped to this model. */
+    objectIds: string[];
+};
+/** Validate saved selections from scene JSON, shared state, or browser storage. */
+declare function parseSelectionSets(input: unknown): SceneSelectionSet[];
+
+type ProductSelections = Record<string, string | null>;
+type ProductOptionRef = {
+    groupId: string;
+    optionId: string;
+};
+type ProductAppearance = {
+    target: ObjectBindingTarget;
+    material?: ObjectBindingMaterial;
+    visible?: boolean;
+};
+type ProductOption = {
+    id: string;
+    label: string;
+    sku?: string;
+    /** Shown under the label. */
+    description?: string;
+    /** A hex color, shown as this option's swatch. */
+    swatch?: string;
+    /** Added to the price, in the currency's smallest unit. Can be negative. */
+    priceDeltaMinor?: number;
+    appearance?: ProductAppearance[];
+    variants?: string[];
+};
+/** Single-choice group. Optional groups may have no selected option. */
+type ProductOptionGroup = {
+    id: string;
+    label: string;
+    required?: boolean;
+    defaultOptionId?: string;
+    display?: ProductGroupDisplay;
+    options: ProductOption[];
+};
+type ProductGroupDisplay = "list" | "chips" | "swatches";
+/** A price worked out from the definition, for products without a pricing service. */
+type ProductPricing = {
+    currency: string;
+    basePriceMinor: number;
+};
+/**
+ * A link to buy this configuration, with no code. The URL can use {sku},
+ * {quantity}, {productId}, {revision} and {selections}.
+ */
+type ProductCheckoutLink = {
+    urlTemplate: string;
+    label?: string;
+};
+type ProductOptionRule = {
+    id: string;
+    when: ProductOptionRef;
+    requires?: ProductOptionRef[];
+    excludes?: ProductOptionRef[];
+    message?: string;
+};
+/** Exact combination-to-SKU mapping, including null for unselected optional groups. */
+type ProductSku = {
+    sku: string;
+    selections: ProductSelections;
+};
+type ProductDefinition = {
+    id: string;
+    label: string;
+    revision: string;
+    groups: ProductOptionGroup[];
+    pricing?: ProductPricing;
+    checkout?: ProductCheckoutLink;
+    rules?: ProductOptionRule[];
+    skus?: ProductSku[];
+};
+type SceneProductConfig = {
+    definition: ProductDefinition;
+    selections: ProductSelections;
+};
+type ProductConfigurationIssue = {
+    code: "required" | "unknown-group" | "unknown-option" | "requires" | "excludes" | "sku";
+    message: string;
+    groupIds: string[];
+    ruleId?: string;
+};
+type ProductConfiguration = {
+    version: 1;
+    productId: string;
+    revision: string;
+    /** Canonical JSON identity of product, revision, quantity, and sorted selections. */
+    key: string;
+    quantity: number;
+    selections: ProductSelections;
+    sku: string | null;
+    items: Array<{
+        groupId: string;
+        optionId: string;
+        label: string;
+        sku?: string;
+    }>;
+    valid: boolean;
+    issues: ProductConfigurationIssue[];
+};
+type ProductOptionState = {
+    groupId: string;
+    optionId: string;
+    selected: boolean;
+    available: boolean;
+    reasons: string[];
+    /** For a choice blocked by a rule: the other choices that would have to change to allow it. */
+    fix?: ProductOptionRef[];
+};
+/** Something in a definition that won't work as its author expects. */
+type ProductDefinitionWarning = {
+    code: "missing-sku" | "no-objects" | "missing-variant" | "invalid-default" | "unreachable" | "nothing-changes";
+    message: string;
+    groupId?: string;
+    optionId?: string;
+};
+type ProductAvailability = {
+    available: boolean;
+    message?: string;
+    options?: Array<ProductOptionRef & {
+        available: boolean;
+        reason?: string;
+    }>;
+};
+/** Display-only price supplied by the host's pricing service. */
+type ProductPrice = {
+    amountMinor: number;
+    currency: string;
+    expiresAt?: string;
+    label?: string;
+};
+type ProductCommerceResult = {
+    id?: string;
+    message?: string;
+};
+type ProductCommerceContext = {
+    signal: AbortSignal;
+};
+type ProductCheckoutContext = ProductCommerceContext & {
+    idempotencyKey: string;
+    price: ProductPrice | null;
+};
+/** Implement these methods in your application; validate/reprice again on your server. */
+type ProductCommerceAdapter = {
+    /** Stable backend/pricing-context identity; change when provider, currency, or customer context changes. */
+    key: string;
+    resolveSku?: (configuration: ProductConfiguration, context: ProductCommerceContext) => string | null | Promise<string | null>;
+    getAvailability?: (configuration: ProductConfiguration, context: ProductCommerceContext) => ProductAvailability | Promise<ProductAvailability>;
+    getPrice?: (configuration: ProductConfiguration, context: ProductCommerceContext) => ProductPrice | Promise<ProductPrice>;
+    addToCart?: (configuration: ProductConfiguration, context: ProductCheckoutContext) => ProductCommerceResult | Promise<ProductCommerceResult>;
+    requestQuote?: (configuration: ProductConfiguration, context: ProductCheckoutContext) => ProductCommerceResult | Promise<ProductCommerceResult>;
+};
+
+declare const LIGHT_TYPES: readonly ["none", "directional", "point", "spot", "hemisphere"];
+type SceneLightType = (typeof LIGHT_TYPES)[number];
+type SceneLightAttachment = {
+    /** Binding key, binding id, modelObjectId, or raw model node name. */
+    objectId: string;
+    /** Local-space offset from the attached model object. */
+    offset: [number, number, number];
+};
+type SceneLight = {
+    id: string;
+    type: SceneLightType;
+    color: string;
+    intensity: number;
+    position: [number, number, number];
+    rotation?: [number, number, number];
+    /** Point-light range. Zero means no distance limit. */
+    distance?: number;
+    /** Point-light physically correct decay. */
+    decay?: number;
+    angle?: number;
+    penumbra?: number;
+    /** Spot/directional aim point; unset aims at the origin (model centre with shadows). */
+    target?: [number, number, number];
+    attachedToCamera: boolean;
+    /** Follow a model object instead of using the world-space position. */
+    attachment?: SceneLightAttachment;
+    castShadow: boolean;
+    shadowBias: number;
+    visible: boolean;
+};
+type SceneLightingConfig = {
+    ambient: {
+        intensity: number;
+        color: string;
+    };
+    lights: SceneLight[];
+};
+declare const SCENE_MODEL_RENDERERS: readonly ["pbr", "matcap", "uv-checker"];
+type SceneModelRenderer = (typeof SCENE_MODEL_RENDERERS)[number];
+type SceneModelConfig = {
+    rotation: [number, number, number];
+    showAdvancedRotation: boolean;
+    renderer: SceneModelRenderer;
+    shading: "lit" | "unlit" | "normals";
+    autoRotate?: boolean;
+    autoRotateSpeed?: number;
+    /**
+     * The glTF material variants (KHR_materials_variants) to show, by name: at
+     * most one from each option group (see `MaterialVariantGroup`). Empty, or
+     * left out, for the model's default materials.
+     */
+    activeVariants?: string[];
+};
+type SceneCameraConfig = {
+    fieldOfView: number;
+    showAdvancedSettings: boolean;
+};
+type SceneShadowConfig = {
+    enabled: boolean;
+    mapSize: number;
+    bias: number;
+    normalBias: number;
+    radius: number;
+};
+declare const ENVIRONMENT_PRESETS: readonly ["neutral", "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", "ping-pong"];
+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;
+        opacity?: number;
+        rampBias: number;
+        rampGain: number;
+        rampMask: boolean;
+        rampInvert: boolean;
+    };
+};
+type SceneAnnotationCameraView = {
+    position: [number, number, number];
+    target: [number, number, number];
+    azimuthAngle?: number;
+    polarAngle?: number;
+    fov?: number | null;
+    zoom?: number;
+};
+type SceneAnnotationImage = {
+    src: string;
+    alt?: string;
+};
+type SceneAnnotationLink = {
+    href: string;
+    label: string;
+};
+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;
+    /** World-space camera framing restored on selection and during tours. */
+    cameraView?: SceneAnnotationCameraView;
+    images?: SceneAnnotationImage[];
+    links?: SceneAnnotationLink[];
+    category?: string;
+    /** Inclusive camera-to-marker distance bounds, in scene units. */
+    minDistance?: number;
+    maxDistance?: number;
+};
+type SceneCinematicWaypoint = {
+    position: [number, number, number];
+    target: [number, number, number];
+    /**
+     * Orbit angles in radians, captured with the view in BindingBuilder. They
+     * keep the rotation when position and target are vertically aligned; older
+     * scene configs without them still work.
+     */
+    azimuthAngle?: number;
+    polarAngle?: number;
+    segmentDuration?: number;
+};
+type SceneCinematicConfig = {
+    enabled: boolean;
+    waypoints: SceneCinematicWaypoint[];
+    duration?: number;
+    loop: boolean;
+    autoPlay: boolean;
+};
+declare const SECTION_AXES: readonly ["x", "y", "z"];
+type SceneSectionAxis = (typeof SECTION_AXES)[number];
+type SceneSectionPlane = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    axis: SceneSectionAxis;
+    position: number;
+    flip: boolean;
+    /** Optional world-space normal; normalized when used. Overrides axis. */
+    normal?: [number, number, number];
+};
+type SceneSectionSettings = {
+    enabled: boolean;
+    /** The world axis the cut runs across; `"y"` gives a floor-plan cut. */
+    axis: SceneSectionAxis;
+    /**
+     * Where the cut is along the axis, as a share of the model's size: 0 at
+     * its minimum, 1 at its maximum.
+     */
+    position: number;
+    /**
+     * Keep the part above the cut (the higher side along the axis) instead of
+     * the part below it.
+     */
+    flip: boolean;
+    /** Default: the original single plane. */
+    mode?: "plane" | "planes" | "box";
+    /** Up to six independently enabled cuts. */
+    planes?: SceneSectionPlane[];
+    activePlaneId?: string;
+    /** Custom normal for the single plane. */
+    normal?: [number, number, number];
+    /** Normalized bounds within the model bounds. Default: the full model. */
+    box?: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+    /** Keep the outside of a section box instead of its inside. */
+    invertBox?: boolean;
+};
+type SceneSectionPreset = {
+    id: string;
+    name: string;
+    settings: SceneSectionSettings;
+};
+type SceneSectionConfig = SceneSectionSettings & {
+    presets?: SceneSectionPreset[];
+};
+declare const DEFAULT_SECTION_CONFIG: SceneSectionConfig;
+/**
+ * What an object's data must look like for a rule to apply to it. A list
+ * applies when every condition in it matches.
+ */
+type SceneStyleCondition = {
+    /** A key of `binding.metrics`. */
+    metric: string;
+    /** Applies when the value is greater than this. */
+    above?: number;
+    /** Applies when the value is less than this. */
+    below?: number;
+} | {
+    status: ObjectBindingStatus | ObjectBindingStatus[];
+} | {
+    /** A key of `binding.metadata`; dots reach into nested objects. */
+    metadata: string;
+    equals: string | number | boolean | null;
+};
+type SceneStyleColorScale = {
+    /** A key of `binding.metrics`. */
+    metric: string;
+    /**
+     * `[value, "#rrggbb"]` pairs. Values between two stops blend their colours;
+     * values outside the stops take the nearest one.
+     */
+    stops: [number, string][];
+    /** The material colour it sets. Default `"baseColor"`. */
+    channel?: "baseColor" | "emissive";
+};
+type SceneStylePulse = {
+    /** The glow colour at the pulse's peak. Default `"#ff3b30"`. */
+    color?: string;
+    /** Pulses per second. Default `1`. */
+    speed?: number;
+};
+type SceneStyleRule = {
+    id: string;
+    label?: string;
+    /** The objects the rule considers; every bound object when left out. */
+    target?: ObjectBindingTarget;
+    /** When the rule applies; always, when left out. */
+    when?: SceneStyleCondition | SceneStyleCondition[];
+    /** Material overrides, over the object's own `style.material`. */
+    material?: ObjectBindingMaterial;
+    /** A colour taken from a metric's value. */
+    colorScale?: SceneStyleColorScale;
+    /** A glow that fades in and out, to draw attention. */
+    pulse?: boolean | SceneStylePulse;
+};
+type SceneConfig = {
+    model: SceneModelConfig;
+    camera: SceneCameraConfig;
+    lighting: SceneLightingConfig;
+    wireframe: SceneWireframeConfig;
+    shadows: SceneShadowConfig;
+    environment: SceneEnvironmentConfig;
+    background: SceneBackgroundConfig;
+    groundShadows: SceneGroundShadowConfig;
+    postProcessing: ScenePostProcessingConfig;
+    animations: SceneAnimationConfig;
+    annotations: SceneAnnotationMarker[];
+    cinematic?: SceneCinematicConfig;
+    /**
+     * Data-driven looks for bound objects, applied in order, so a later rule
+     * wins over an earlier one where both set something.
+     */
+    styleRules?: SceneStyleRule[];
+    /** A cut-away view across the model. Off when left out. */
+    section?: SceneSectionConfig;
+    /** Named measurements and model-unit calibration, owned by this model. */
+    measurements?: MeasurementCollection;
+    /** Named object selections scoped to this model's stable object ids. */
+    selectionSets?: SceneSelectionSet[];
+    /** Product choices, constraints, appearance overrides, and selected options for this model. */
+    product?: SceneProductConfig;
+    /** Authored timed camera, object, appearance and clip tracks. Model-local IDs. */
+    sequences?: SceneSequence[];
+};
+declare const DEFAULT_SCENE_CONFIG: SceneConfig;
+
+type SceneConfigPatch = DeepPartial<SceneConfig>;
+/**
+ * Applies a nested scene-config patch without mutating either input. Objects
+ * are merged recursively, while arrays and tuples are replaced wholesale.
+ */
+declare function patchSceneConfig(sceneConfig: SceneConfig, patch: SceneConfigPatch): SceneConfig;
+
+type AnimationClipInfo = {
+    sourceName: string;
+    duration: number;
+};
+/** How `play` starts a clip. */
+type AnimationPlayOptions = {
+    /**
+     * Keep the clips already playing, instead of stopping them, so several
+     * clips run at once (a left and a right door, say). Default `false`.
+     */
+    alongside?: boolean;
+    /**
+     * Seconds to fade the clip in, and to fade out the clips it replaces, for a
+     * smooth blend between them. Default `0`.
+     */
+    fade?: number;
+    /**
+     * Play backwards, from wherever the clip is, or from its end. Plays a
+     * "door opens" clip as the door closing. Default `false`.
+     */
+    reverse?: boolean;
+};
+/**
+ * `"finished"`: a play-once clip that reached its end and holds its last pose
+ * until it's stopped or played again.
+ */
+type AnimationClipStatus = "playing" | "paused" | "finished";
+/** One clip that is playing, paused, or holding its finished pose. */
+type AnimationClipState = {
+    clip: string;
+    status: AnimationClipStatus;
+    /** Position in the clip, in seconds. */
+    time: number;
+    /** Length of the clip, in seconds. */
+    duration: number;
+    speed: number;
+    reverse: boolean;
+};
+type AnimationPlaybackState = {
+    /** Playback intent is preserved while offscreen rendering is suspended. */
+    isRenderPaused?: boolean;
+    /** The clip played most recently, while it's active. */
+    currentClip: string | null;
+    /** Whether any clip is playing. */
+    isPlaying: boolean;
+    speed: number;
+    time: number;
+    duration: number;
+    /** Every active clip, most recently played last. */
+    active: AnimationClipState[];
+};
+/**
+ * Leave out `clip` to act on every active clip; pass one to act on that clip
+ * alone.
+ */
+type AnimationControls = {
+    clips: string[];
+    clipDetails?: AnimationClipInfo[];
+    play: (clipName: string, options?: AnimationPlayOptions) => void;
+    pause: (clipName?: string) => void;
+    /** Stops and resets the pose. */
+    stop: (clipName?: string) => void;
+    /** Without a clip, also the speed of clips played later without their own. */
+    setSpeed: (speed: number, clipName?: string) => void;
+    seek?: (time: number, clipName?: string) => void;
+    getState?: () => AnimationPlaybackState;
+    subscribe?: (listener: (state: AnimationPlaybackState) => void) => () => void;
+};
+type ViewerAnimationsProps = {
+    isRenderPaused: boolean;
+    clips: string[];
+    clipDetails: AnimationClipInfo[];
+    currentClip: string | null;
+    isPlaying: boolean;
+    speed: number;
+    time: number;
+    duration: number;
+    /** Every active clip, most recently played last. */
+    active: AnimationClipState[];
+    play: (clipName: string, options?: AnimationPlayOptions) => void;
+    pause: (clipName?: string) => void;
+    stop: (clipName?: string) => void;
+    setSpeed: (speed: number, clipName?: string) => void;
+    seek: (time: number, clipName?: string) => void;
+    handleAnimationsReady: (controls: AnimationControls) => void;
+    /** Disconnect the previous model while the next one is loading. */
+    clearAnimations: () => void;
+};
+declare function useViewerAnimations(): ViewerAnimationsProps;
+
+/** A glow cycling on one object, from its style rules. */
+type StyledObjectPulse = {
+    color: string;
+    /** Pulses per second. */
+    speed: number;
+};
+type StyledObjectBindings = {
+    /**
+     * The bindings as the rules style them. A binding no rule changed is the
+     * same object as the one passed in.
+     */
+    bindings: Record<string, ObjectBinding>;
+    /** Pulsing objects, by binding key. */
+    pulses: Record<string, StyledObjectPulse>;
+    /** The binding a styled one came from (itself when no rule changed it). */
+    sourceOf: (binding: ObjectBinding) => ObjectBinding;
+};
+/**
+ * The colour a colour scale gives a value: a blend of the two stops around it,
+ * or the nearest stop outside them. Null when there's no usable stop.
+ */
+declare function colorScaleValue(stops: SceneStyleColorScale["stops"], value: number): string | null;
+/**
+ * Styles bindings with scene style rules, for rendering. Rules apply in order
+ * over each object's own `style.material`, so a later rule wins where two set
+ * the same thing. The bindings passed in are never changed.
+ */
+declare function applyStyleRules(bindings: Record<string, ObjectBinding>, rules: readonly SceneStyleRule[] | undefined): StyledObjectBindings;
+
+/**
+ * Objects to focus on. Everything else is ghosted (drawn faintly) or hidden
+ * until the isolation is cleared, without changing any binding.
+ */
+type ViewerIsolation = {
+    /** The objects that stay: an id, a list of ids, `{ group }`, `{ tag }`, or `{ type }`. */
+    target: ObjectBindingTarget;
+    /** What happens to everything else. Default `"ghost"`. */
+    mode?: "ghost" | "hide";
+    /** How visible ghosted objects are, 0–1. Default `0.12`. */
+    ghostOpacity?: number;
+};
+type IsolatedObjectBindings = StyledObjectBindings & {
+    /** Binding keys that are ghosted or hidden. Pointer picking ignores them. */
+    setAside: Set<string>;
+};
+/** The binding keys an isolation keeps; empty when it keeps nothing. */
+declare function isolatedBindingKeys(bindings: Record<string, ObjectBinding>, isolation: ViewerIsolation | null | undefined): Set<string>;
+/**
+ * Ghosts or hides every object an isolation doesn't keep, for rendering. The
+ * bindings passed in are never changed. An isolation that keeps nothing (a
+ * target matching no object) changes nothing either, rather than fading out
+ * the whole model.
+ */
+declare function applyIsolation(styled: StyledObjectBindings, isolation: ViewerIsolation | null | undefined): IsolatedObjectBindings;
+
+type ObjectBindingsActionEffect = {
+    target: ObjectBindingTarget;
+    objectBindings: ObjectBindingPatch;
+};
+type SceneConfigActionEffect = {
+    sceneConfig: SceneConfigPatch;
+};
+type VisibilityActionEffect = {
+    target: ObjectBindingTarget;
+    visibility: "show" | "hide" | "toggle";
+};
+type CameraAction = {
+    type: "focus-object";
+    objectId?: string;
+} | {
+    type: "fit-scene";
+} | {
+    type: "reset";
+} | {
+    type: "set-target";
+    target: [number, number, number];
+    transition?: boolean;
+} | {
+    type: "set-state";
+    state: ViewerCameraState;
+    transition?: boolean;
+};
+type CameraActionEffect = {
+    camera: CameraAction;
+};
+/**
+ * `play` replaces the clips already playing unless `alongside` is set. The
+ * others act on `clip`, or on every active clip when it's left out.
+ */
+type AnimationAction = ({
+    type: "play";
+    clip: string;
+} & AnimationPlayOptions) | {
+    type: "pause";
+    clip?: string;
+} | {
+    type: "stop";
+    clip?: string;
+} | {
+    type: "set-speed";
+    speed: number;
+    clip?: string;
+} | {
+    type: "seek";
+    time: number;
+    clip?: string;
+};
+type AnimationActionEffect = {
+    animation: AnimationAction;
+};
+/** Isolates objects, or with `null` shows everything again. */
+type IsolationActionEffect = {
+    isolation: ViewerIsolation | null;
+};
+type ObjectActionEffect = IsolationActionEffect | ObjectBindingsActionEffect | SceneConfigActionEffect | VisibilityActionEffect | CameraActionEffect | AnimationActionEffect;
+
+type ObjectBindingAction = {
+    id: "change-color" | "change-material" | "toggle-visibility" | string;
+    label: string;
+    type: "command";
+    effects?: ObjectActionEffect[];
+};
+/**
+ * What kind of object a binding is, for grouping and filtering. The listed
+ * values are suggestions; any string works.
+ */
+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" | (string & {});
+type ObjectBindingStatus = "normal" | "hidden" | "selected" | "disabled";
+type ObjectBindingTextureSlot = {
+    path: string;
+    /** UV position offset [u, v]. */
+    offset?: [number, number];
+    /** UV zoom scale. 1 = default, >1 = zoom in, <1 = zoom out. */
+    scale?: number;
+    rotation?: number;
+};
+type ObjectBindingTextureChannel = "baseColor" | "metalness" | "roughness" | "emissive" | "alpha" | "normal" | "bump" | "ao" | "displacement" | "clearcoat" | "clearcoatRoughness" | "clearcoatNormal" | "anisotropy" | "transmission" | "thickness" | "sheenColor" | "sheenRoughness" | "specularIntensity" | "specularColor";
+type ObjectBindingTransform = {
+    /** Local xy/xz/yz shear, applied between rotation and scale. Preserves rigid world edits under non-uniform parents. */
+    shear?: [number, number, number];
+    /** Local-space node-origin position, or the reference-pose position when pivot is set. */
+    position?: [number, number, number];
+    /** Local-space Euler rotation in radians. */
+    rotation?: [number, number, number];
+    /** Local-space scale. */
+    scale?: [number, number, number];
+    /**
+     * Opt-in centered editing. Legacy transforms without this field remain direct
+     * local P/R/S. The reference offset keeps position independent of later
+     * rotation/scale edits: rendered origin = position + offset - R * H * S * point (H is shear).
+     */
+    pivot?: {
+        point: [number, number, number];
+        offset: [number, number, number];
+    };
+};
+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;
+};
+/**
+ * An image or a line of text printed onto the object's surface: a logo, a
+ * label, a personalisation.
+ */
+type ObjectBindingDecal = {
+    id: string;
+    /** The image to show: a URL or public path. */
+    image?: string;
+    /** Text to show, when there's no image. */
+    text?: string;
+    /** Text colour. Default `"#ffffff"`. */
+    color?: string;
+    /** CSS font family for the text. Default `"sans-serif"`. */
+    fontFamily?: string;
+    /** Default `"bold"`. */
+    fontWeight?: "normal" | "bold";
+    /** Where it sits on the object, in the object's own (local) space. */
+    position: [number, number, number];
+    /** The way the surface faces there, in the object's own space. */
+    normal: [number, number, number];
+    /** Width, in model units; the height follows the image or text's shape. */
+    size: number;
+    /** A turn around the surface normal, in radians. Default `0`. */
+    rotation?: number;
+    /** 0–1. Default `1`. */
+    opacity?: number;
+};
+type ObjectBindingStyle = {
+    material?: ObjectBindingMaterial;
+};
+type ObjectBinding = {
+    id: string;
+    /** Defaults to `"other"`. */
+    type?: ObjectBindingType;
+    modelObjectId: string;
+    label?: string;
+    group?: string;
+    tags?: string[];
+    status?: ObjectBindingStatus;
+    removed?: boolean;
+    visible?: boolean;
+    selectable?: boolean;
+    hoverable?: boolean;
+    transform?: ObjectBindingTransform;
+    style?: ObjectBindingStyle;
+    /** Images and text printed on the object's surface. */
+    decals?: ObjectBindingDecal[];
+    actions?: ObjectBindingAction[];
+    metrics?: Record<string, number>;
+    metadata?: Record<string, unknown>;
+    cameraState?: ObjectBindingCameraState;
+};
+type ObjectActionEvent = {
+    objectId: string;
+    action: ObjectBindingAction;
+    binding?: ObjectBinding;
+    screenX?: number;
+    screenY?: number;
+};
+/** A point on an object's surface, in the object's own (local) space. */
+type ObjectSurfacePoint = {
+    position: [number, number, number];
+    /** The way the surface faces at that point. */
+    normal: [number, number, number];
+};
+/** A double-click, right-click, or long-press on a model object. */
+type ObjectPointerEvent = {
+    binding: ObjectBinding;
+    /** Viewport coordinates, e.g. to place a menu with `position: fixed`. */
+    clientX: number;
+    clientY: number;
+    /** `"mouse"`, `"pen"`, or `"touch"`. */
+    pointerType: string;
+    /**
+     * Where on the object the pointer was, e.g. to place a decal there. Not
+     * reported for streamed (3D Tiles) models.
+     */
+    surface?: ObjectSurfacePoint;
+};
+
+/** One choice in a row of material variants. */
+type MaterialVariantOption = {
+    /** The variant's name, as `sceneConfig.model.activeVariants` lists it. */
+    name: string;
+    /** The name without its group, for display: "Red" for "Paint: Red". */
+    label: string;
+    /**
+     * The colour of the variant's main material, as a CSS colour, when that
+     * material is a plain colour rather than a texture.
+     */
+    swatch?: string;
+};
+/**
+ * Variants that take turns: choosing one replaces the group's other choice.
+ * Variants in different groups combine, like a paint colour and a wheel style.
+ */
+type MaterialVariantGroup = {
+    /** "Paint" for variants named "Paint: Red" or "Paint / Red"; null otherwise. */
+    name: string | null;
+    variants: MaterialVariantOption[];
+};
+/**
+ * The active variants after choosing `name`: it replaces any other variant of
+ * its group, so a paint colour swaps for another while the wheels stay.
+ */
+declare function chooseMaterialVariant(activeVariants: readonly string[], name: string, groups: readonly MaterialVariantGroup[]): string[];
+
+type ViewerModelBounds = {
+    min: [number, number, number];
+    max: [number, number, number];
+    center: [number, number, number];
+    size: [number, number, number];
+};
+/** What `onModelLoaded` reports about a model that finished loading. */
+type ViewerModelInfo = {
+    /** Bounds in world space, where the viewer placed the model. */
+    bounds: ViewerModelBounds;
+    /** Number of meshes in the loaded scene. */
+    objectCount: number;
+    /**
+     * Names of the glTF material variants (KHR_materials_variants) the model
+     * offers, in file order; empty when it has none. Show them by setting
+     * `sceneConfig.model.activeVariants`.
+     */
+    materialVariants: string[];
+    /**
+     * The same variants as option groups, with their display labels and
+     * swatches. One variant from each group can show at once.
+     */
+    materialVariantGroups: MaterialVariantGroup[];
+};
+
+/** Built-in viewer text. Override only the keys your application needs. */
+declare const DEFAULT_MODEL_VIEWER_LABELS: {
+    readonly verifyingLicense: "Verifying License";
+    readonly checkingYourLicenseKey: "Checking your license key...";
+    readonly createDevelopmentKey: "Create a free development key";
+    readonly invalidLicense: "Invalid License";
+    readonly licenseHasBeenRevokedOrHasExpired: "License has been revoked or has expired";
+    readonly failedToLoadPleaseContactTheSiteAdministrator: "Failed to load. Please contact the site administrator.";
+    readonly contextRestoringTitle: "Reloading viewer…";
+    readonly contextLostTitle: "3D view interrupted";
+    readonly contextRestoringMessage: "Rebuilding the 3D view. Please wait…";
+    readonly contextLostMessage: "The graphics connection was interrupted. The viewer will rebuild when it returns, or you can reload it now.";
+    readonly reloadViewer: "Reload viewer";
+    readonly texturePositioningHint: "Drag to move · Scroll to zoom · Click elsewhere to finish";
+    readonly texturePositioningStartHint: "Double-click to move or zoom";
+    readonly dismiss: "Dismiss";
+    readonly missingUVsAreShownInMagenta: "Missing UVs are shown in magenta.";
+    readonly viewThisModelInARWithAppleQuickLook: "View this model in AR with Apple Quick Look";
+    readonly sequencePlayer: "Sequence player";
+    readonly sequenceSelect: "Sequence";
+    readonly sequencePlay: "Play sequence";
+    readonly sequencePause: "Pause sequence";
+    readonly sequenceStop: "Stop and restore scene";
+    readonly sequencePlayhead: "Sequence playhead";
+    readonly sequenceTime: "Sequence time";
+    readonly sequenceIssues: "Unavailable sequence targets";
+    readonly arConfiguredButton: "AR handoff";
+    readonly arConfiguredTitle: "Take this configuration to AR";
+    readonly arConfiguredDescription: "Your current materials, visible models and placements are included.";
+    readonly arSnapshotStale: "Updating AR to include your latest changes…";
+    readonly arPreparing: "Preparing your scene…";
+    readonly arStart: "Start AR";
+    readonly arStarting: "Starting AR…";
+    readonly arCheckingSupport: "Checking AR support…";
+    readonly arUnavailable: "AR is unavailable in this browser. Open this link in an AR-capable browser on your phone.";
+    readonly arStartFailed: "Could not start AR. Check camera permissions and try again.";
+    readonly arAnimations: "AR animations";
+    readonly arAnimationSelect: "Animation";
+    readonly arAnimationSaved: "Default";
+    readonly arAnimationNone: "No animation";
+    readonly arAnimationClips: "Model clips";
+    readonly arAnimationSequences: "Sequences";
+    readonly arAnimationPlay: "Play animation";
+    readonly arAnimationPause: "Pause animation";
+    readonly arRefresh: "Refresh AR";
+    readonly arRetry: "Try again";
+    readonly arExportDetails: "Export details";
+    readonly arPrepare: "Prepare AR";
+    readonly arPrepareAgain: "Prepare again";
+    readonly arDownloadUSDZ: "Download USDZ for iPhone/iPad";
+    readonly arScanConfigured: "Scan to open this configuration on your phone.";
+    readonly arOpenConfiguredLink: "Open configuration link";
+    readonly viewInAR: "View in AR";
+    readonly openThisExperienceOnAPhoneForAR: "Open this experience on a phone for AR";
+    readonly openOnPhone: "Open on phone";
+    readonly viewThisModelInYourSpace: "View this model in your space";
+    readonly viewThisModelInVR: "View this model in VR";
+    readonly closePhoneHandoff: "Close phone handoff";
+    readonly arScanCode: "Scan the code and choose AR.";
+    readonly qrCodeToOpenThisModelOnAPhone: "QR code to open this model on a phone";
+    readonly disableUVChecker: "Disable UV checker";
+    readonly enableUVChecker: "Enable UV checker";
+    readonly explodedView: "Exploded view";
+    readonly explodeAmount: "Explode amount";
+    readonly removeSectionCut: "Remove section cut";
+    readonly sectionCut: "Section cut";
+    readonly sectionAxis: "Section axis";
+    readonly sectionPosition: "Section position";
+    readonly keepTheOtherSide: "Keep the other side";
+    readonly pauseCinematic: "Pause cinematic";
+    readonly playCinematic: "Play cinematic";
+    readonly stopCinematicAndResetCamera: "Stop cinematic and reset camera";
+    readonly cancel: "Cancel";
+    readonly annotationCategories: "Annotation categories";
+    readonly annotations: "Annotations";
+    readonly all: "All";
+    readonly uncategorized: "Uncategorized";
+    readonly decalDragHint: "Drag the decal on the object. Release to save; Escape to cancel.";
+    readonly showAll: "Show all";
+    readonly materialVariants: "Material variants";
+    readonly startGuidedTour: "Start guided tour";
+    readonly guidedTour: "Guided Tour";
+    readonly previousAnnotation: "Previous annotation";
+    readonly previous: "Prev";
+    readonly stopGuidedTour: "Stop guided tour";
+    readonly nextAnnotation: "Next annotation";
+    readonly next: "Next";
+    readonly exitFullscreen: "Exit fullscreen";
+    readonly enterFullscreen: "Enter fullscreen";
+    readonly resetCameraView: "Reset camera view";
+    readonly orbitControl: "Orbit Control";
+    readonly pointLock: "Pointer lock";
+    readonly cameraController: "Camera controller";
+    readonly cameraControllerSettings: "Camera controller settings";
+    readonly downloadGLB: "Download GLB";
+    readonly downloadGLBDescription: "All visible models, material edits and animations in one file. No annotations or separate editor model slots. Duplicate mesh names may change on reimport.";
+    readonly downloadCombinedGLB: "Download as one GLB";
+    readonly downloadSeparateGLBs: "Download separate GLBs";
+    readonly downloadSeparateGLBsDescription: "One GLB file per model";
+    readonly downloadPNG: "Download PNG";
+    readonly downloadUVLayout: "Download UV Layout";
+    readonly videoFormat: "Video format";
+    readonly auto: "Auto";
+    readonly recordTurntableVideo: "Record turntable video";
+    readonly recordCinematicVideo: "Record cinematic video";
+    readonly videoUnsupported: "Video recording is not supported in this browser.";
+    readonly downloadOptions: "Download options";
+    readonly exporting: "Exporting…";
+    readonly download: "Download";
+    readonly annotationTitlePlaceholder: "Title *";
+    readonly description: "Description";
+    readonly ok: "OK";
+    readonly arRelocate: "Relocate";
+    readonly tapToPlace: "Tap to place";
+    readonly closeAnnotation: "Close annotation";
+    readonly learnMore: "Learn more";
+    readonly stopMeasuring: "Stop measuring";
+    readonly startMeasuring: "Start measuring";
+    readonly toggleBoundingDimensions: "Toggle bounding dimensions";
+    readonly measurementTool: "Measurement tool";
+    readonly distance: "Distance";
+    readonly angle: "Angle";
+    readonly area: "Area";
+    readonly pointToPlane: "Point to plane";
+    readonly wrap: "Circumference (Edge)";
+    readonly wrapHorizontal: "Circumference (Horizontal)";
+    readonly measurementSnapping: "Measurement snapping";
+    readonly noSnapping: "No snapping";
+    readonly snapAuto: "Snap: auto";
+    readonly snapVertex: "Snap: vertex";
+    readonly snapEdge: "Snap: edge";
+    readonly undoMeasurementPoint: "Undo measurement point";
+    readonly clearMeasurements: "Clear measurements";
+    readonly finishArea: "Finish area";
+    readonly savedMeasurements: "Saved measurements ({count})";
+    readonly noSavedMeasurements: "No saved measurements yet. Pick points in the preview, then save a measurement here.";
+    readonly measurementFiles: "Import / export";
+    readonly measurementSourceUnit: "Model units";
+    readonly measurementDisplayUnit: "Display units";
+    readonly measurementName: "Name";
+    readonly measurementNamePlaceholder: "e.g. Door width";
+    readonly saveMeasurement: "Save";
+    readonly knownMeasurementDistance: "Known length";
+    readonly calibrationUnit: "Calibration unit";
+    readonly calibrateMeasurement: "Calibrate";
+    readonly measurementCalibrationHint: "Pick two distance points, enter their known length, then calibrate.";
+    readonly measurementCalibratedScale: "Calibrated: 1 model unit = {scale} m";
+    readonly resetMeasurementCalibration: "Reset calibration";
+    readonly showSavedMeasurement: "Show {name}";
+    readonly renameSavedMeasurement: "Rename {name}";
+    readonly deleteSavedMeasurement: "Delete {name}";
+    readonly exportMeasurementJson: "Export JSON";
+    readonly exportMeasurementCsv: "Export CSV";
+    readonly importMeasurementJson: "Import JSON";
+    readonly measurementReady: "Ready";
+    readonly measurementApproximate: "Approximate LOD";
+    readonly measurementModelChanged: "Different model";
+    readonly measurementObjectMissing: "Object unavailable";
+    readonly measurementGeometryChanged: "Geometry changed — measure again";
+    readonly measurementPoseChanged: "Pose changed — measure again";
+    readonly measurementObjectHidden: "Object hidden";
+    readonly measurementInvalid: "Invalid measurement";
+    readonly measurementWaiting: "Waiting for model";
+    readonly openSceneObjectsPanel: "Open scene objects panel";
+    readonly sceneObjects: "Scene Objects";
+    readonly searchNodesLabels: "Search nodes, labels";
+    readonly closeSceneObjectsPanel: "Close scene objects panel";
+    readonly objectNavigator: "Objects in the 3D view";
+    readonly compareBefore: "Before";
+    readonly compareAfter: "After";
+    readonly compareDivider: "Comparison divider";
+    readonly viewIn3D: "View in 3D";
+    readonly objectNavigatorHint: "Arrow keys browse · Enter selects · Esc clears";
+    readonly selectionCleared: "Selection cleared";
+    readonly cameraKeyboardHelp: "3D view. Arrow keys orbit, Shift with Up or Down zooms, and W, A, S, D, Space and C move the camera.";
+    readonly isolate: "Isolate";
+    readonly hide: "Hide";
+    readonly show: "Show";
+    readonly closePanel: "Close panel";
+    readonly actions: "Actions";
+    readonly openPanel: "Open panel";
+    readonly close: "Close";
+    readonly position: "Position";
+    readonly decalNudgeHint: "Click to fine-tune · Hold to move";
+    readonly decalNudgeControls: "Move decal in small steps";
+    readonly text: "Text";
+    readonly yourText: "Your text";
+    readonly textToAdd: "Text to add";
+    readonly textColour: "Text color";
+    readonly addText: "Add text";
+    readonly image: "Image";
+    readonly chooseImage: "Choose image";
+    readonly imageToAdd: "Image to add";
+    readonly added: "Added";
+    readonly colour: "Color";
+    readonly size: "Size";
+    readonly turn: "Turn";
+    readonly rotation: "Rotation";
+    readonly dragTheDecalAcrossTheObjectsSurface: "Drag the decal across the object's surface";
+    readonly move: "Move";
+    readonly remove: "Remove";
+    readonly noneAddedYet: "None added yet";
+    readonly done: "Done";
+    readonly moveForward: "Move forward";
+    readonly moveLeft: "Move left";
+    readonly moveRight: "Move right";
+    readonly moveBackward: "Move backward";
+    readonly productOptions: "Options";
+    readonly productOptionsFor: "{product} options";
+    readonly productReset: "Reset";
+    readonly productOptional: "optional";
+    readonly productNone: "None";
+    readonly productAlsoChanges: "Also changes: {changes}";
+    readonly productUnavailable: "Currently unavailable.";
+    readonly productQuantity: "Quantity";
+    readonly productCheckingPrice: "Checking price and availability…";
+    readonly productTotal: "Total";
+    readonly productAddToCart: "Add to cart";
+    readonly productAddingToCart: "Adding…";
+    readonly productRequestQuote: "Request quote";
+    readonly productRequestingQuote: "Requesting…";
+    readonly productRefresh: "Refresh";
+    readonly productBuy: "Buy now";
+    readonly productCopyLink: "Copy link";
+    readonly productLinkCopied: "Link copied";
+    readonly productShowOptions: "Show options";
+    readonly productHideOptions: "Hide options";
+    readonly productIssues: "Configuration issues";
+    readonly productRequestDone: "Request completed.";
+    readonly productSaved: "Saved: {id}";
+    readonly sceneSettings: "Scene Settings";
+    readonly background: "Background";
+    readonly backgroundColor: "Background Color";
+    readonly showEnvironmentAsBackground: "Show as background";
+    readonly backgroundBlur: "Background Blur";
+    readonly environmentPreset: "Preset";
+    readonly environmentIntensity: "Intensity";
+    readonly toneMapping: "Tone Mapping";
+    readonly toneMappingAces: "ACES Filmic";
+    readonly toneMappingAgx: "AgX";
+    readonly toneMappingNeutral: "Neutral";
+    readonly toneMappingNone: "None";
+    readonly ground: "Ground";
+    readonly groundShadow: "Ground Shadow";
+    readonly groundShadowOpacity: "Shadow Opacity";
+    readonly floorGrid: "Floor Grid";
+    readonly display: "Display";
+    readonly wireframe: "Wireframe";
+    readonly autoRotateSpeed: "Rotation Speed";
+    readonly fieldOfView: "Field of View";
+    readonly modelInfo: "Model";
+    readonly modelInfoObjects: "Objects";
+    readonly modelInfoTriangles: "Triangles";
+    readonly modelInfoMaterials: "Materials";
+    readonly resetSettings: "Reset Settings";
+    readonly environment: "Environment";
+    readonly autoRotate: "Auto Rotate";
+    readonly lighting: "Lighting";
+    readonly exposure: "Exposure";
+    readonly ambientLightIntensity: "Ambient Light Intensity";
+    readonly ambientLightColor: "Ambient Light Color";
+    readonly directLightIntensity: "Direct Light Intensity";
+    readonly directLightColor: "Direct Light Color";
+    readonly searchObjects: "Search objects";
+    readonly uploadedModel: "Uploaded model";
+    readonly clear: "Clear";
+    readonly chooseModel: "Choose model";
+    readonly loadingModel: "Loading model...";
+    readonly releaseToLoadYourModel: "Release to load your model";
+    readonly arFindSurface: "Move your device over a flat surface";
+    readonly arReleaseToPlace: "Release to place";
+    readonly arGestureHint: "Pinch to resize · Twist to rotate";
+    readonly angleFirstArmHint: "Pick the first arm";
+    readonly angleVertexHint: "Pick the angle's vertex";
+    readonly angleSecondArmHint: "Pick the second arm";
+    readonly angleNewHint: "Pick a point to start a new angle";
+    readonly areaNewHint: "Pick a point to start a new area";
+    readonly areaCornersHint: "Pick polygon corners in order, then Finish area";
+    readonly pointToPlaneFaceHint: "Pick the reference face";
+    readonly pointToPlanePointHint: "Pick a point to measure its perpendicular distance";
+    readonly pointToPlaneNewHint: "Pick a face to start a new measurement";
+    readonly distanceHint: "Pick points on the model to measure distances";
+    readonly wrapHint: "Click a point on the surface to measure its circumference, following the surface (best for limbs)";
+    readonly wrapHorizontalHint: "Click a point to measure a level circumference around it (best for the torso/waist)";
+    readonly visibleEntries: "{count} visible entries";
+    readonly objectCount: "{count} objects";
+    readonly annotationMarker: "Annotation {id}: {title}";
+    readonly recordingVideo: "Recording video · {progress}%";
+    readonly isolatedObjects: "Isolated: {count} objects";
+    readonly largeModelWarning: "Very large model ({millions}M triangles) — it may render and move slowly on this device, and click/hover selection on the model is disabled. Use the objects panel to select parts.";
+    readonly preparingLargeModel: "Preparing large model ({millions}M triangles) — the first display can take a while on this device...";
+    readonly enterAR: "Enter AR";
+    readonly enterVR: "Enter VR";
+    readonly decalImage: "Image {index}";
+    readonly decalText: "Text {index}";
+    readonly decalAdded: "{count} added";
+    readonly up: "up";
+    readonly down: "down";
+    readonly left: "left";
+    readonly right: "right";
+    readonly moveDecal: "Move decal {direction}";
+    readonly moveDecalOnSurface: "Move {direction} on the visible surface";
+    readonly showAllObject: "Show all {name}";
+    readonly isolateObject: "Isolate {name}";
+    readonly isolatedObject: "Isolated: {name}";
+    readonly hideObject: "Hide {name}";
+    readonly showObject: "Show {name}";
+    readonly objectSelected: "{name} selected";
+    readonly objectNavigatorPosition: "{position} of {count}";
+    readonly compareDividerValue: "{before} {percent}%, {after} {rest}%";
+    readonly bindingMismatchOne: "1 object binding doesn't match this model";
+    readonly bindingMismatchMany: "{count} object bindings don't match this model";
+    readonly simpleLargeModelWarning: "Very large model detected ({millions}M triangles) — it may render and move slowly on this device, and click/hover selection on the model is disabled. Use the scene objects panel to select parts.";
+    readonly dropModelHint: "Drag and drop {formats} here";
+    readonly retryModelLoad: "Retry loading model";
+    readonly loadErrorTitle: "This model couldn't be loaded";
+    readonly loadErrorNotFound: "Nothing was found at this address ({status}). Check that modelUrl points to the file.";
+    readonly loadErrorDenied: "The server refused access to the file ({status}). Check that the file is public, or that a signed URL hasn't expired.";
+    readonly loadErrorStatus: "The server responded with {status} when the file was requested.";
+    readonly loadErrorNetwork: "The download was blocked or failed. Check that the URL is correct and, if the file is on another domain, that its server allows cross-origin requests (CORS) from this site.";
+    readonly loadErrorHtml: "The server sent back a web page instead of a model. There's probably no file at this path: many servers answer a missing file with their index.html.";
+    readonly loadErrorInvalidFile: "The file couldn't be read as {format}. Check that it's a valid {format} file.";
+    readonly loadErrorInvalidExplicitFormat: "The file couldn't be read as {format}. Check that it's a valid {format} file and that modelFormat matches it.";
+    readonly loadErrorMissingFormat: "The file couldn't be read as {format}. The URL has no file extension, so set modelFormat to the file's format.";
+    readonly loadErrorPointCloud: "This PLY file is a point cloud: it has points but no faces, and the viewer shows meshes. Turn it into a mesh first, for example with MeshLab or Blender.";
+    readonly measurementReferenceFaceRequired: "Pick a triangle face to define the reference plane.";
+    readonly measurementTooManyPoints: "Finish or clear this measurement before adding more points.";
+    readonly measurementAngleDistinct: "Pick a point away from the angle's vertex.";
+    readonly areaMinimumPoints: "Pick at least three points to finish the area.";
+    readonly areaDistinctPoints: "Area points must be distinct.";
+    readonly areaStraightLine: "Area points must not lie on one straight line.";
+    readonly areaNotPlanar: "Area points must lie on one plane.";
+    readonly areaEdgesCross: "Area edges must not cross or touch each other.";
+    readonly areaZero: "The polygon has no measurable area.";
+    readonly decalSurfaceMissing: "Could not find a surface on this object for the decal.";
+    readonly decalDirectionMissing: "No visible surface in that direction. Try another arrow or rotate the view.";
+    readonly fullscreenExitFailed: "Could not exit fullscreen. Press Escape to exit.";
+    readonly fullscreenEnterFailed: "Could not enter fullscreen. Check your browser or iframe fullscreen permissions and try again.";
+    readonly uvCoordinatesMissing: "This model does not contain UV coordinates.";
+    readonly uvExportFailed: "Could not create the UV layout archive.";
+    readonly videoExportFailed: "Could not export the video.";
+    readonly videoNotReady: "Viewer not ready for video export.";
+    readonly videoExitXR: "Exit the XR session before recording a video.";
+    readonly videoAlreadyRecording: "A video export is already in progress.";
+    readonly videoPathRequired: "Enable a cinematic camera path before recording it.";
+    readonly videoDurationInvalid: "Video duration must be greater than 0 and at most 300 seconds.";
+    readonly videoFrameRateInvalid: "Video frame rate must be between 1 and 60.";
+    readonly videoBitrateInvalid: "Video bitrate must be a positive number.";
+    readonly videoContextLost: "Video export stopped because the WebGL context was lost.";
+    readonly videoTimedOut: "Video export timed out. Keep the viewer tab visible while recording.";
+    readonly videoEncodingFailed: "The browser could not encode the video.";
+    readonly videoEmpty: "The browser produced an empty video.";
+    readonly videoDidNotStart: "Video recording did not start.";
+    readonly videoWebMUnsupported: "Video recording as WEBM is not supported in this browser.";
+    readonly videoMP4Unsupported: "Video recording as MP4 is not supported in this browser.";
+    readonly videoGIFUnsupported: "Video recording as GIF is not supported in this browser.";
+    readonly videoGifWidthInvalid: "GIF width must be a whole number of pixels from 16 to 4096.";
+    readonly environmentNeutral: "neutral";
+    readonly environmentApartment: "apartment";
+    readonly environmentCity: "city";
+    readonly environmentDawn: "dawn";
+    readonly environmentForest: "forest";
+    readonly environmentLobby: "lobby";
+    readonly environmentNight: "night";
+    readonly environmentPark: "park";
+    readonly environmentStudio: "studio";
+    readonly environmentSunset: "sunset";
+    readonly environmentWarehouse: "warehouse";
+    readonly color: "Color";
+    readonly material: "Material";
+    readonly texturePreview: "texture preview";
+    readonly noTextureApplied: "No texture applied";
+    readonly noTextureCoordinates: "This part has no texture coordinates, so an image can't be placed on it.";
+    readonly replaceImage: "Replace image";
+    readonly uploadImage: "Upload image";
+    readonly removeTexture: "Remove texture";
+    readonly texturePosition: "Texture position";
+    readonly offsetX: "Offset X";
+    readonly offsetY: "Offset Y";
+    readonly confirmTexturePosition: "Confirm this texture position and exit positioning mode";
+    readonly donePositioning: "Done positioning";
+    readonly textureOffsetHint: "Double-click the object in the preview to drag its texture directly (scroll to zoom), or edit its offset numerically.";
+    readonly actionToggleLight: "Toggle Light";
+    readonly actionChangeLightColor: "Change Light Color";
+    readonly actionSetBrightness: "Set Brightness";
+    readonly actionChangeColor: "Change Color";
+    readonly actionChangeMaterial: "Change Material";
+    readonly actionToggleVisibility: "Toggle Visibility";
+};
+type ModelViewerLabelKey = keyof typeof DEFAULT_MODEL_VIEWER_LABELS;
+/** Plain-text overrides; dynamic labels use named {placeholders}. */
+type ModelViewerLabels = Partial<Record<ModelViewerLabelKey, string>>;
+
+/**
+ * When a viewer starts its 3D view on its own. `"lazy"` waits until it's on
+ * or near the screen and shares the page's live 3D views with the other lazy
+ * viewers, so a page of viewers stays within the browser's limit. `"eager"`
+ * starts at once and keeps its view.
+ */
+type ViewerLoading = "lazy" | "eager";
+/**
+ * Whether the 3D view starts on its own (`"auto"`) or waits on the poster
+ * until the visitor asks for it with a "View in 3D" button (`"interaction"`).
+ */
+type ViewerReveal = "auto" | "interaction";
+
+type CameraLimits = {
+    /** Closest the camera can get to its target, in scene units. Default 0. */
+    minDistance?: number;
+    /** Farthest the camera can get from its target, in scene units. Default Infinity. */
+    maxDistance?: number;
+    /**
+     * Lowest vertical angle, in degrees: 0 looks straight down from above, 90 is
+     * level with the target, 180 looks straight up from below. Default 0.
+     */
+    minPolarAngle?: number;
+    /** Highest vertical angle, in degrees (see minPolarAngle). Default 180. */
+    maxPolarAngle?: number;
+    /**
+     * Leftmost horizontal angle, in degrees around the vertical axis: 0 views
+     * the target from the front (+Z), 90 from its right (+X), -90 from its
+     * left. Default -Infinity (no limit).
+     */
+    minAzimuthAngle?: number;
+    /** Rightmost horizontal angle, in degrees (see minAzimuthAngle). Default Infinity. */
+    maxAzimuthAngle?: number;
+    /** An axis-aligned world-space box the camera's target can pan within. */
+    panBoundary?: [min: [number, number, number], max: [number, number, number]];
+    /** Keeps the camera itself, not just its target, inside panBoundary. Default false. */
+    boundaryEnclosesCamera?: boolean;
+    /** How strongly panning slows near panBoundary, 0–1. Default 0. */
+    boundaryFriction?: number;
+};
+
+/**
+ * Whether the viewer cuts motion that starts on its own: `"user"` follows the
+ * visitor's `prefers-reduced-motion` setting, `"always"` and `"never"` override
+ * it.
+ */
+type ReducedMotionSetting = "user" | "always" | "never";
+
+type ModelFormat = "glb" | "gltf" | "obj" | "fbx" | "usdz" | "stl" | "ply";
+
+export { type ObjectBindingTextureSlot as $, type AnimationAction as A, type BindingEdit as B, type CameraAction as C, DEFAULT_MODEL_VIEWER_LABELS as D, type EnvironmentPreset as E, type ModelFormat as F, type GlitchModeName as G, type ModelViewerLabelKey as H, type IsolatedObjectBindings as I, type ModelViewerLabels as J, type KernelSizeName as K, type ObjectActionEvent as L, MATERIAL_BLENDING_MODES as M, type ObjectBinding as N, type ObjectActionEffect as O, type ObjectBindingAction as P, type ObjectBindingCameraState as Q, type ObjectBindingDecal as R, type ObjectBindingMaterial as S, type ObjectBindingMaterialBlendingMode as T, type ObjectBindingMaterialSide as U, type ObjectBindingPatch as V, type ObjectBindingSelector as W, type ObjectBindingStatus as X, type ObjectBindingStyle as Y, type ObjectBindingTarget as Z, type ObjectBindingTextureChannel as _, type AnimationActionEffect as a, type SceneStyleRule as a$, type ObjectBindingTransform as a0, type ObjectBindingType as a1, type ObjectBindingsActionEffect as a2, type ObjectPointerEvent as a3, type ObjectSurfacePoint as a4, type ProductAppearance as a5, type ProductAvailability as a6, type ProductCheckoutContext as a7, type ProductCheckoutLink as a8, type ProductCommerceAdapter as a9, type SceneCameraConfig as aA, type SceneCinematicConfig as aB, type SceneCinematicWaypoint as aC, type SceneConfig as aD, type SceneConfigActionEffect as aE, type SceneConfigPatch as aF, type SceneEnvironmentConfig as aG, type SceneGroundShadowConfig as aH, type SceneLight as aI, type SceneLightAttachment as aJ, type SceneLightType as aK, type SceneLightingConfig as aL, type SceneModelConfig as aM, type SceneModelRenderer as aN, type ScenePostProcessingConfig as aO, type SceneProductConfig as aP, type SceneSectionAxis as aQ, type SceneSectionConfig as aR, type SceneSectionPlane as aS, type SceneSectionPreset as aT, type SceneSectionSettings as aU, type SceneSelectionSet as aV, type SceneSequence as aW, type SceneShadowConfig as aX, type SceneStyleColorScale as aY, type SceneStyleCondition as aZ, type SceneStylePulse as a_, type ProductCommerceContext as aa, type ProductCommerceResult as ab, type ProductConfiguration as ac, type ProductConfigurationIssue as ad, type ProductDefinition as ae, type ProductDefinitionWarning as af, type ProductGroupDisplay as ag, type ProductOption as ah, type ProductOptionGroup as ai, type ProductOptionRef as aj, type ProductOptionRule as ak, type ProductOptionState as al, type ProductPrice as am, type ProductPricing as an, type ProductSelections as ao, type ProductSku as ap, type RampTypeName as aq, type ReducedMotionSetting as ar, type SavedMeasurement as as, type SceneAnimationClipConfig as at, type SceneAnimationConfig as au, type SceneAnnotationCameraView as av, type SceneAnnotationImage as aw, type SceneAnnotationLink as ax, type SceneAnnotationMarker as ay, type SceneBackgroundConfig as az, type AnimationClipInfo as b, type SceneWireframeConfig as b0, type SequenceCameraView as b1, type SequenceControls as b2, type SequenceEasing as b3, type SequenceKeyframe as b4, type SequenceObjectProperty as b5, type SequencePlaybackState as b6, type SequenceTarget as b7, type SequenceTrack as b8, type SequenceValue as b9, type SequenceVector3 as ba, type StyledObjectBindings as bb, type StyledObjectPulse as bc, type ViewerAnimationsProps as bd, type ViewerCameraConfig as be, type ViewerCameraState as bf, type ViewerIsolation as bg, type ViewerLoading as bh, type ViewerModelBounds as bi, type ViewerModelInfo as bj, type ViewerReveal as bk, type VisibilityActionEffect as bl, applyIsolation as bm, applyStyleRules as bn, chooseMaterialVariant as bo, colorScaleValue as bp, isolatedBindingKeys as bq, material as br, parseSelectionSets as bs, patchBindings as bt, patchSceneConfig as bu, selectBindingKeys as bv, selectBindings as bw, useViewerAnimations as bx, type AnimationClipState as c, type AnimationClipStatus as d, type AnimationControls as e, type AnimationLoopMode as f, type AnimationPlayOptions as g, type AnimationPlaybackState as h, type CameraActionEffect as i, type CameraLimits as j, DEFAULT_SCENE_CONFIG as k, DEFAULT_SECTION_CONFIG as l, type DeepPartial as m, type IsolationActionEffect as n, MATERIAL_SIDES as o, type MaterialVariantGroup as p, type MaterialVariantOption as q, type MeasurementAnchor as r, type MeasurementCollection as s, type MeasurementPoint as t, type MeasurementPosition as u, type MeasurementResult as v, type MeasurementSettings as w, type MeasurementStatus as x, type MeasurementTool as y, type MeasurementUnit as z };