@crystaldesign/real-time-viewer-next 26.11.0-beta.18

package/build/types/real-time-viewer-next/src/config/environment.config.d.ts

@@ -0,0 +1,511 @@
+import { type ConfigInput, type ConfigResolved } from './descriptor';
+/**
+ * The whole environment as one descriptor: each subsystem contributes the tree it declares next to
+ * its renderer. `EnvironmentConfig` / `ResolvedEnvironmentConfig`, the defaults, `resolveEnvironment`
+ * and the analyzer's export round-trip all derive from this — see `config/descriptor.ts`.
+ *
+ * The `dimensionLine*` fields are spread in rather than nested — they sit at the top level of the
+ * config, not under a `dimensionLines` group.
+ */
+export declare const ENVIRONMENT_CONFIG: import("./descriptor").GroupDescriptor<{
+    renderer: import("./descriptor").GroupDescriptor<{
+        dpr: import("./descriptor").ValueField<number | [min: number, max: number]>;
+        powerPreference: import("./descriptor").EnumField<"default" | "high-performance" | "low-power">;
+        frameloop: import("./descriptor").EnumField<"always" | "never" | "demand">;
+        maxFps: import("./descriptor").NumberField;
+        transmissionResolutionScale: import("./descriptor").NumberField;
+        precision: import("./descriptor").EnumField<"highp" | "mediump" | "lowp">;
+    }>;
+    adaptive: import("./descriptor").GroupDescriptor<{
+        adaptiveDpr: import("./descriptor").BooleanField;
+        adaptiveEvents: import("./descriptor").BooleanField;
+        bakeShadows: import("./descriptor").BooleanField;
+    }>;
+    /**
+     * Production ground plane (`PlainGround`) + planner-grid visibility. Analyzer-driven, but routed
+     * through the standard env pipeline (`patchActiveProfile` → bundle auto-save → Import/Export) so
+     * the panel needs no persistence channel of its own.
+     */
+    ground: import("./descriptor").GroupDescriptor<{
+        enabled: import("./descriptor").BooleanField;
+        surface: import("./descriptor").EnumField<"shadow" | "plain">;
+        color: import("./descriptor").ColorField;
+        roughness: import("./descriptor").NumberField;
+        shadowOpacity: import("./descriptor").NumberField;
+        shape: import("./descriptor").EnumField<"rectangular" | "circular">;
+        size: import("./descriptor").NumberField;
+        radius: import("./descriptor").NumberField;
+        yOffset: import("./descriptor").NumberField;
+        plannerGridMode: import("./descriptor").EnumField<"off" | "on" | "2d">;
+        plannerGrid2D: import("./descriptor").GroupDescriptor<{
+            cellSize: import("./descriptor").NumberField;
+            sectionSize: import("./descriptor").NumberField;
+            cellColor: import("./descriptor").ColorField;
+            sectionColor: import("./descriptor").ColorField;
+            cellThickness: import("./descriptor").NumberField;
+            sectionThickness: import("./descriptor").NumberField;
+            fadeDistance: import("./descriptor").NumberField;
+            fadeStrength: import("./descriptor").NumberField;
+            cellHideDistance: import("./descriptor").NumberField;
+            sceneFitFactor: import("./descriptor").NumberField;
+        }>;
+    }>;
+    /**
+     * The standalone environment-scene GLB (deck / backdrop), plus its transform and cutout rules.
+     * Ships in production presets and is edited live by the analyzer; same layering rationale as
+     * `ground`.
+     */
+    scene: import("./descriptor").GroupDescriptor<{
+        sceneUrl: import("./descriptor").ValueField<string | null>;
+        sceneTransform: import("./descriptor").GroupDescriptor<{
+            position: import("./descriptor").TupleField<[number, number, number]>;
+            rotation: import("./descriptor").TupleField<[number, number, number]>;
+            scale: import("./descriptor").NumberField;
+        }>;
+        sceneParts: import("./descriptor").ArrayDescriptor<import("./descriptor").ValueField<string>>;
+        deckCutout: import("./descriptor").GroupDescriptor<{
+            enabled: import("./descriptor").BooleanField;
+            nodeMatch: import("./descriptor").ValueField<string>;
+            authoredHole: import("./descriptor").GroupDescriptor<{
+                centerX: import("./descriptor").NumberField;
+                centerZ: import("./descriptor").NumberField;
+                halfExtentX: import("./descriptor").NumberField;
+                halfExtentZ: import("./descriptor").NumberField;
+            }>;
+            articleSync: import("./descriptor").GroupDescriptor<{
+                enabled: import("./descriptor").BooleanField;
+                margin: import("./descriptor").NumberField;
+            }>;
+            elementAnchor: import("./descriptor").GroupDescriptor<{
+                enabled: import("./descriptor").BooleanField;
+                offsetX: import("./descriptor").NumberField;
+                offsetZ: import("./descriptor").NumberField;
+                alignTopToDeck: import("./descriptor").BooleanField;
+                offsetY: import("./descriptor").NumberField;
+                anchorX: import("./descriptor").EnumField<"center" | "min" | "max">;
+                anchorZ: import("./descriptor").EnumField<"center" | "min" | "max">;
+            }>;
+            waterSync: import("./descriptor").GroupDescriptor<{
+                enabled: import("./descriptor").BooleanField;
+                inset: import("./descriptor").NumberField;
+                offsetX: import("./descriptor").NumberField;
+                offsetZ: import("./descriptor").NumberField;
+            }>;
+            articleRules: import("./descriptor").ArrayDescriptor<import("./descriptor").GroupDescriptor<{
+                match: import("./descriptor").ValueField<string>;
+                footprintFromGeometry: import("./descriptor").BooleanField;
+                footprintSliceDepth: import("./descriptor").NumberField;
+            }>>;
+            collar: import("./descriptor").GroupDescriptor<{
+                recess: import("./descriptor").NumberField;
+                skirtDepth: import("./descriptor").NumberField;
+                overlap: import("./descriptor").NumberField;
+                color: import("./descriptor").ColorField;
+                roughness: import("./descriptor").NumberField;
+                material: import("./descriptor").GroupDescriptor<{
+                    mapUrl: import("./descriptor").ValueField<string>;
+                    normalMapUrl: import("./descriptor").ValueField<string>;
+                    roughnessMapUrl: import("./descriptor").ValueField<string>;
+                    textureScale: import("./descriptor").NumberField;
+                    rotationDeg: import("./descriptor").NumberField;
+                    offsetX: import("./descriptor").NumberField;
+                    offsetZ: import("./descriptor").NumberField;
+                }>;
+            }>;
+        }>;
+    }>;
+    dimensionLineUnit: import("./descriptor").EnumField<"in" | "cm" | "m" | "mm">;
+    dimensionLineHideUnit: import("./descriptor").BooleanField;
+    dimensionLineColor: import("./descriptor").ColorField;
+    dome: import("./descriptor").GroupDescriptor<{
+        hdr: import("./descriptor").AssetField;
+        showBackground: import("./descriptor").BooleanField;
+        backgroundBlur: import("./descriptor").NumberField;
+        intensity: import("./descriptor").NumberField;
+        iblHighlightBoost: import("./descriptor").NumberField;
+        rotation: import("./descriptor").NumberField;
+        rotationX: import("./descriptor").NumberField;
+        rotationZ: import("./descriptor").NumberField;
+        tileX: import("./descriptor").NumberField;
+        tileY: import("./descriptor").NumberField;
+        offsetX: import("./descriptor").NumberField;
+        offsetY: import("./descriptor").NumberField;
+        backgroundColor: import("./descriptor").ValueField<string | false>;
+        backgroundIntensity: import("./descriptor").NumberField;
+        skydome: import("./descriptor").GroupDescriptor<{
+            url: import("./descriptor").ValueField<string | false>;
+            enabled: import("./descriptor").BooleanField;
+            kind: import("./descriptor").EnumField<"image" | "procedural">;
+            size: import("./descriptor").NumberField;
+            rotation: import("./descriptor").NumberField;
+            shape: import("./descriptor").EnumField<"sphere" | "hemisphere">;
+            height: import("./descriptor").NumberField;
+            tileX: import("./descriptor").NumberField;
+            tileY: import("./descriptor").NumberField;
+            offsetX: import("./descriptor").NumberField;
+            offsetY: import("./descriptor").NumberField;
+            procedural: import("./descriptor").GroupDescriptor<{
+                distance: import("./descriptor").NumberField;
+                turbidity: import("./descriptor").NumberField;
+                rayleigh: import("./descriptor").NumberField;
+                mieCoefficient: import("./descriptor").NumberField;
+                mieDirectionalG: import("./descriptor").NumberField;
+            }>;
+        }>;
+    }>;
+    lighting: import("./descriptor").GroupDescriptor<{
+        useHemisphere: import("./descriptor").BooleanField;
+        hemisphereConfig: import("./descriptor").GroupDescriptor<{
+            skyColor: import("./descriptor").ColorField;
+            groundColor: import("./descriptor").ColorField;
+            intensity: import("./descriptor").NumberField;
+        }>;
+        ambientIntensity: import("./descriptor").NumberField;
+        keyLight: import("./descriptor").GroupDescriptor<{
+            type: import("./descriptor").EnumField<"spot" | "directional">;
+            position: import("./descriptor").TupleField<[number, number, number]>;
+            intensity: import("./descriptor").NumberField;
+            color: import("./descriptor").ColorField;
+            angle: import("./descriptor").NumberField;
+            penumbra: import("./descriptor").NumberField;
+            distance: import("./descriptor").NumberField;
+            decay: import("./descriptor").NumberField;
+        }>;
+        fillLight: import("./descriptor").GroupDescriptor<{
+            type: import("./descriptor").EnumField<"spot" | "directional">;
+            position: import("./descriptor").TupleField<[number, number, number]>;
+            intensity: import("./descriptor").NumberField;
+            color: import("./descriptor").ColorField;
+            angle: import("./descriptor").NumberField;
+            penumbra: import("./descriptor").NumberField;
+            distance: import("./descriptor").NumberField;
+            decay: import("./descriptor").NumberField;
+        }>;
+        rimLight: import("./descriptor").GroupDescriptor<{
+            type: import("./descriptor").EnumField<"spot" | "directional">;
+            position: import("./descriptor").TupleField<[number, number, number]>;
+            intensity: import("./descriptor").NumberField;
+            color: import("./descriptor").ColorField;
+            angle: import("./descriptor").NumberField;
+            penumbra: import("./descriptor").NumberField;
+            distance: import("./descriptor").NumberField;
+            decay: import("./descriptor").NumberField;
+        }>;
+        backLight: import("./descriptor").ToggleDescriptor<{
+            type: import("./descriptor").EnumField<"spot" | "directional">;
+            position: import("./descriptor").TupleField<[number, number, number]>;
+            intensity: import("./descriptor").NumberField;
+            color: import("./descriptor").ColorField;
+            angle: import("./descriptor").NumberField;
+            penumbra: import("./descriptor").NumberField;
+            distance: import("./descriptor").NumberField;
+            decay: import("./descriptor").NumberField;
+        }>;
+        sun: import("./descriptor").ToggleDescriptor<{
+            enabled: import("./descriptor").BooleanField;
+            azimuth: import("./descriptor").NumberField;
+            elevation: import("./descriptor").NumberField;
+            direction: import("./descriptor").TupleField<[number, number, number]>;
+            color: import("./descriptor").ColorField;
+            intensity: import("./descriptor").NumberField;
+            lensflare: import("./descriptor").ToggleDescriptor<{
+                enabled: import("./descriptor").BooleanField;
+                color: import("./descriptor").ColorField;
+                distanceScale: import("./descriptor").NumberField;
+                sizeScale: import("./descriptor").NumberField;
+                occlusionEnabled: import("./descriptor").BooleanField;
+            }>;
+        }>;
+    }>;
+    water: import("./descriptor").GroupDescriptor<{
+        enabled: import("./descriptor").BooleanField;
+        volume: import("./descriptor").GroupDescriptor<{
+            center: import("./descriptor").TupleField<[number, number, number]>;
+            size: import("./descriptor").TupleField<[number, number, number]>;
+        }>;
+        wallColor: import("./descriptor").ColorField;
+        skyHorizonColor: import("./descriptor").ColorField;
+        skyZenithColor: import("./descriptor").ColorField;
+        ambientDropPeriod: import("./descriptor").NumberField;
+        pointerStrength: import("./descriptor").NumberField;
+        heightfieldSize: import("./descriptor").NumberField;
+        causticTextureSize: import("./descriptor").NumberField;
+        causticIntensity: import("./descriptor").NumberField;
+        waveSpeed: import("./descriptor").NumberField;
+        waterClarity: import("./descriptor").NumberField;
+        causticReceivers: import("./descriptor").BooleanField;
+        causticDebugMode: import("./descriptor").EnumField<"off" | "mask" | "overlay" | "isolate" | "landing" | "heightmap">;
+        causticSun: import("./descriptor").ToggleDescriptor<{
+            azimuth: import("./descriptor").NumberField;
+            elevation: import("./descriptor").NumberField;
+        }>;
+        useScreenSpaceRefraction: import("./descriptor").BooleanField;
+        refractionFallbackColor: import("./descriptor").ColorField;
+        fresnelMax: import("./descriptor").NumberField;
+    }>;
+    shadows: import("./descriptor").GroupDescriptor<{
+        enabled: import("./descriptor").BooleanField;
+        mapSize: import("./descriptor").NumberField;
+        maxMapSize: import("./descriptor").NumberField;
+        radius: import("./descriptor").NumberField;
+        bias: import("./descriptor").NumberField;
+        normalBias: import("./descriptor").NumberField;
+        fitMultiplier: import("./descriptor").NumberField;
+        casters: import("./descriptor").GroupDescriptor<{
+            sceneGeo: import("./descriptor").BooleanField;
+        }>;
+        receivers: import("./descriptor").GroupDescriptor<{
+            sceneGeo: import("./descriptor").BooleanField;
+        }>;
+        lights: import("./descriptor").GroupDescriptor<{
+            sun: import("./descriptor").BooleanField;
+            key: import("./descriptor").BooleanField;
+        }>;
+        soft: import("./descriptor").GroupDescriptor<{
+            enabled: import("./descriptor").BooleanField;
+            size: import("./descriptor").NumberField;
+            focus: import("./descriptor").NumberField;
+            samples: import("./descriptor").NumberField;
+        }>;
+    }>;
+    postProcessing: import("./descriptor").GroupDescriptor<{
+        enabled: import("./descriptor").BooleanField;
+        multisampling: import("./descriptor").NumberField;
+        bloom: import("./descriptor").ToggleDescriptor<{
+            intensity: import("./descriptor").NumberField;
+            opacity: import("./descriptor").NumberField;
+            threshold: import("./descriptor").NumberField;
+            luminanceSmoothing: import("./descriptor").NumberField;
+            mipmapBlur: import("./descriptor").BooleanField;
+            kernelSize: import("./descriptor").NumberField;
+            radius: import("./descriptor").NumberField;
+            blendFunction: import("./descriptor").NumberField;
+        }>;
+        vignette: import("./descriptor").ToggleDescriptor<{
+            intensity: import("./descriptor").NumberField;
+            opacity: import("./descriptor").NumberField;
+            offset: import("./descriptor").NumberField;
+            eskil: import("./descriptor").BooleanField;
+            blendFunction: import("./descriptor").NumberField;
+        }>;
+        depthOfField: import("./descriptor").ToggleDescriptor<{
+            focusDistance: import("./descriptor").NumberField;
+            bokehScale: import("./descriptor").NumberField;
+            focusRange: import("./descriptor").NumberField;
+            blendFunction: import("./descriptor").NumberField;
+            resolutionScale: import("./descriptor").NumberField;
+            targetPosition: import("./descriptor").ValueField<[number, number, number] | null>;
+        }>;
+        chromaticAberration: import("./descriptor").ToggleDescriptor<{
+            intensity: import("./descriptor").NumberField;
+            offsetX: import("./descriptor").NumberField;
+            offsetY: import("./descriptor").NumberField;
+            modulationOffset: import("./descriptor").NumberField;
+            radialModulation: import("./descriptor").BooleanField;
+            blendFunction: import("./descriptor").NumberField;
+            opacity: import("./descriptor").NumberField;
+        }>;
+        colorGrading: import("./descriptor").ToggleDescriptor<{
+            saturation: import("./descriptor").NumberField;
+            brightness: import("./descriptor").NumberField;
+            contrast: import("./descriptor").NumberField;
+            hue: import("./descriptor").NumberField;
+            hueSaturationOpacity: import("./descriptor").NumberField;
+            brightnessContrastOpacity: import("./descriptor").NumberField;
+            hueSaturationBlendFunction: import("./descriptor").NumberField;
+            brightnessContrastBlendFunction: import("./descriptor").NumberField;
+        }>;
+        noise: import("./descriptor").ToggleDescriptor<{
+            intensity: import("./descriptor").NumberField;
+            premultiply: import("./descriptor").BooleanField;
+            blendFunction: import("./descriptor").NumberField;
+        }>;
+        outlineEffect: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            edgeStrength: import("./descriptor").NumberField;
+            pulseSpeed: import("./descriptor").NumberField;
+            visibleEdgeColor: import("./descriptor").NumberField;
+            hiddenEdgeColor: import("./descriptor").NumberField;
+            resolutionScale: import("./descriptor").NumberField;
+            blur: import("./descriptor").BooleanField;
+            xRay: import("./descriptor").BooleanField;
+            kernelSize: import("./descriptor").NumberField;
+        }>;
+        outlineHoverEffect: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            edgeStrength: import("./descriptor").NumberField;
+            pulseSpeed: import("./descriptor").NumberField;
+            visibleEdgeColor: import("./descriptor").NumberField;
+            hiddenEdgeColor: import("./descriptor").NumberField;
+            resolutionScale: import("./descriptor").NumberField;
+            blur: import("./descriptor").BooleanField;
+            xRay: import("./descriptor").BooleanField;
+            kernelSize: import("./descriptor").NumberField;
+        }>;
+        selectiveBloomEffect: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            intensity: import("./descriptor").NumberField;
+            threshold: import("./descriptor").NumberField;
+            luminanceSmoothing: import("./descriptor").NumberField;
+            mipmapBlur: import("./descriptor").BooleanField;
+            kernelSize: import("./descriptor").NumberField;
+            inverted: import("./descriptor").BooleanField;
+            ignoreBackground: import("./descriptor").BooleanField;
+        }>;
+        godRaysEffect: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            samples: import("./descriptor").NumberField;
+            density: import("./descriptor").NumberField;
+            decay: import("./descriptor").NumberField;
+            weight: import("./descriptor").NumberField;
+            exposure: import("./descriptor").NumberField;
+            clampMax: import("./descriptor").NumberField;
+            resolutionScale: import("./descriptor").NumberField;
+            blur: import("./descriptor").BooleanField;
+            sunMeshName: import("./descriptor").ValueField<string>;
+        }>;
+        autofocusEffect: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            bokehScale: import("./descriptor").NumberField;
+            resolutionScale: import("./descriptor").NumberField;
+            mouse: import("./descriptor").BooleanField;
+            smoothTime: import("./descriptor").NumberField;
+            debug: import("./descriptor").NumberField;
+        }>;
+        ssrEffect: import("./descriptor").ToggleDescriptor<{
+            temporalResolve: import("./descriptor").BooleanField;
+            temporalResolveMix: import("./descriptor").NumberField;
+            intensity: import("./descriptor").NumberField;
+            maxRoughness: import("./descriptor").NumberField;
+            rayStep: import("./descriptor").NumberField;
+            maxDepth: import("./descriptor").NumberField;
+            thickness: import("./descriptor").NumberField;
+            ENABLE_BLUR: import("./descriptor").BooleanField;
+            blurMix: import("./descriptor").NumberField;
+            USE_MRT: import("./descriptor").BooleanField;
+            USE_ROUGHNESSMAP: import("./descriptor").BooleanField;
+            USE_NORMALMAP: import("./descriptor").BooleanField;
+        }>;
+        n8aoEffect: import("./descriptor").ToggleDescriptor<{
+            aoRadius: import("./descriptor").NumberField;
+            distanceFalloff: import("./descriptor").NumberField;
+            intensity: import("./descriptor").NumberField;
+            quality: import("./descriptor").EnumField<"high" | "low" | "medium" | "performance" | "ultra">;
+            halfRes: import("./descriptor").BooleanField;
+            screenSpaceRadius: import("./descriptor").BooleanField;
+        }>;
+        lutEffect: import("./descriptor").ToggleDescriptor<{
+            url: import("./descriptor").ValueField<string>;
+            blendFunction: import("./descriptor").NumberField;
+            tetrahedralInterpolation: import("./descriptor").BooleanField;
+        }>;
+        screenLensFlare: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            opacity: import("./descriptor").NumberField;
+            glareSize: import("./descriptor").NumberField;
+            flareSize: import("./descriptor").NumberField;
+            lensPosition: import("./descriptor").TupleField<[number, number, number]>;
+            followSun: import("./descriptor").BooleanField;
+            lensDirtUrl: import("./descriptor").ValueField<string | null>;
+        }>;
+        toneMapping: import("./descriptor").BooleanField;
+        toneMappingBlendFunction: import("./descriptor").NumberField;
+        toneMappingOpacity: import("./descriptor").NumberField;
+        toneMappingAdaptive: import("./descriptor").ToggleDescriptor<{
+            resolution: import("./descriptor").NumberField;
+            maxLuminance: import("./descriptor").NumberField;
+            whitePoint: import("./descriptor").NumberField;
+            middleGrey: import("./descriptor").NumberField;
+            minLuminance: import("./descriptor").NumberField;
+            averageLuminance: import("./descriptor").NumberField;
+            adaptationRate: import("./descriptor").NumberField;
+        }>;
+        toneMappingMode: import("./descriptor").EnumField<"linear" | "neutral" | "aces" | "reinhard" | "cineon">;
+        exposure: import("./descriptor").NumberField;
+        antiAliasMode: import("./descriptor").EnumField<"none" | "smaa" | "fxaa" | "msaa-only">;
+        ssao: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            intensity: import("./descriptor").NumberField;
+            radius: import("./descriptor").NumberField;
+            samples: import("./descriptor").NumberField;
+            rings: import("./descriptor").NumberField;
+            worldDistanceThreshold: import("./descriptor").NumberField;
+            worldDistanceFalloff: import("./descriptor").NumberField;
+            worldProximityThreshold: import("./descriptor").NumberField;
+            worldProximityFalloff: import("./descriptor").NumberField;
+            distanceThreshold: import("./descriptor").NumberField;
+            distanceFalloff: import("./descriptor").NumberField;
+            rangeThreshold: import("./descriptor").NumberField;
+            rangeFalloff: import("./descriptor").NumberField;
+            minRadiusScale: import("./descriptor").NumberField;
+            distanceScaling: import("./descriptor").BooleanField;
+            depthAwareUpsampling: import("./descriptor").BooleanField;
+            resolutionScale: import("./descriptor").NumberField;
+            luminanceInfluence: import("./descriptor").NumberField;
+            bias: import("./descriptor").NumberField;
+            fade: import("./descriptor").NumberField;
+            color: import("./descriptor").ColorField;
+        }>;
+        ssaoFine: import("./descriptor").ToggleDescriptor<{
+            blendFunction: import("./descriptor").NumberField;
+            intensity: import("./descriptor").NumberField;
+            radius: import("./descriptor").NumberField;
+            samples: import("./descriptor").NumberField;
+            rings: import("./descriptor").NumberField;
+            worldDistanceThreshold: import("./descriptor").NumberField;
+            worldDistanceFalloff: import("./descriptor").NumberField;
+            worldProximityThreshold: import("./descriptor").NumberField;
+            worldProximityFalloff: import("./descriptor").NumberField;
+            distanceThreshold: import("./descriptor").NumberField;
+            distanceFalloff: import("./descriptor").NumberField;
+            rangeThreshold: import("./descriptor").NumberField;
+            rangeFalloff: import("./descriptor").NumberField;
+            minRadiusScale: import("./descriptor").NumberField;
+            distanceScaling: import("./descriptor").BooleanField;
+            depthAwareUpsampling: import("./descriptor").BooleanField;
+            resolutionScale: import("./descriptor").NumberField;
+            luminanceInfluence: import("./descriptor").NumberField;
+            bias: import("./descriptor").NumberField;
+            fade: import("./descriptor").NumberField;
+            color: import("./descriptor").ColorField;
+        }>;
+    }>;
+    materials: import("./descriptor").GroupDescriptor<{
+        envMapIntensity: import("./descriptor").NumberField;
+    }>;
+    selection: import("./descriptor").GroupDescriptor<{
+        hover: import("./descriptor").BooleanField;
+        showPivotIndicator: import("./descriptor").BooleanField;
+        showArticleName: import("./descriptor").BooleanField;
+        rotationPivot: import("./descriptor").EnumField<"center" | "visual-center">;
+        snapRotationDeg: import("./descriptor").NumberField;
+        overlay3d: import("./descriptor").GroupDescriptor<{
+            primaryAnchor: import("./descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+            primaryDirection: import("./descriptor").EnumField<"left" | "right" | "up" | "down">;
+            trashAnchor: import("./descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+            buttonSize: import("./descriptor").NumberField;
+            showPosNr: import("./descriptor").BooleanField;
+            showMove: import("./descriptor").BooleanField;
+            showRotate: import("./descriptor").BooleanField;
+            showTrash: import("./descriptor").BooleanField;
+        }>;
+        overlay2d: import("./descriptor").GroupDescriptor<{
+            primaryAnchor: import("./descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+            primaryDirection: import("./descriptor").EnumField<"left" | "right" | "up" | "down">;
+            trashAnchor: import("./descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+            buttonSize: import("./descriptor").NumberField;
+            showPosNr: import("./descriptor").BooleanField;
+            showMove: import("./descriptor").BooleanField;
+            showRotate: import("./descriptor").BooleanField;
+            showTrash: import("./descriptor").BooleanField;
+        }>;
+    }>;
+}>;
+export type EnvironmentConfig = ConfigInput<typeof ENVIRONMENT_CONFIG>;
+export type ResolvedEnvironmentConfig = ConfigResolved<typeof ENVIRONMENT_CONFIG>;
+/**
+ * Every environment field at its default — the baseline `resolveEnvironment()` fills overrides on
+ * top of. Frozen by construction: `resolveConfig` always returns a fresh tree.
+ */
+export declare const DEFAULT_ENVIRONMENT: ResolvedEnvironmentConfig;
+//# sourceMappingURL=environment.config.d.ts.map

package/build/types/real-time-viewer-next/src/config/environment.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.config.d.ts","sourceRoot":"","sources":["../../../../../src/config/environment.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAc5F;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;IAW7B;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACvE,MAAM,MAAM,yBAAyB,GAAG,cAAc,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAElF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,yBAA8D,CAAC"}

package/build/types/real-time-viewer-next/src/config/environment.config.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @jest-environment jsdom
+ */
+import '../testUtils/structuredClonePolyfill';
+//# sourceMappingURL=environment.config.test.d.ts.map

package/build/types/real-time-viewer-next/src/config/environment.config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.config.test.d.ts","sourceRoot":"","sources":["../../../../../src/config/environment.config.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH,OAAO,sCAAsC,CAAC"}

package/build/types/real-time-viewer-next/src/core/BBoxPreloader.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedScene } from '../parser/parseRenderScript';
+/**
+ * Downloads every geo GLB the scene references into the shared `loadGLTFCached` map, then names
+ * the standard materials those GLBs need.
+ *
+ * WHY: on the render path a geo is only fetched once its `GeoLoader` mounts, and the std material
+ * it needs is only requested from behind `MaterialProvider`'s suspend — which React 18 retries one
+ * boundary child at a time. Pulling the GLBs here (same cache the render path suspends on, so
+ * nothing is downloaded twice) makes the whole std-material wave resolvable up front and lets it
+ * overlap the product-material wave instead of trailing it.
+ *
+ * Idempotent per url: both caches dedupe, so re-running it for a re-parsed scene is nearly free.
+ */
+export declare function preloadGeoAssets(scene: ParsedScene): Promise<void>;
+//# sourceMappingURL=BBoxPreloader.d.ts.map

package/build/types/real-time-viewer-next/src/core/BBoxPreloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BBoxPreloader.d.ts","sourceRoot":"","sources":["../../../../../src/core/BBoxPreloader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,6BAA6B,CAAC;AAuB1E;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBxE"}

package/build/types/real-time-viewer-next/src/core/FloorGrid.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function FloorGrid(): React.JSX.Element;
+//# sourceMappingURL=FloorGrid.d.ts.map

package/build/types/real-time-viewer-next/src/core/FloorGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloorGrid.d.ts","sourceRoot":"","sources":["../../../../../src/core/FloorGrid.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA0B,MAAM,OAAO,CAAC;AA8E/C,wBAAgB,SAAS,sBA8BxB"}

package/build/types/real-time-viewer-next/src/core/GeoBBoxReporter.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedScene } from '../parser/parseRenderScript';
+/**
+ * Placed inside the Suspense boundary so it only renders after all geos of the article are loaded
+ * — the moment the article's geometry becomes live in the Three.js scene. Publishes that edge to
+ * the store; it renders nothing itself.
+ */
+export declare function GeoBBoxReporter({ scene }: {
+    scene: ParsedScene;
+}): null;
+//# sourceMappingURL=GeoBBoxReporter.d.ts.map

package/build/types/real-time-viewer-next/src/core/GeoBBoxReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeoBBoxReporter.d.ts","sourceRoot":"","sources":["../../../../../src/core/GeoBBoxReporter.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,QAiBhE"}

package/build/types/real-time-viewer-next/src/core/GeoInstance.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { GeoRef, GeoAsset, MatRef } from '../parser/parseRenderScript';
+interface GeoInstanceProps {
+    geoRef: GeoRef;
+    geoAssets: GeoAsset[];
+    archiveBaseUrl: string;
+    matRefs: MatRef[];
+    /** Optional name set on the wrapper group so the geo can be found via scene.getObjectByName. */
+    geoName?: string;
+}
+export declare function GeoInstance({ geoRef, geoAssets, archiveBaseUrl, matRefs, geoName }: GeoInstanceProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=GeoInstance.d.ts.map

package/build/types/real-time-viewer-next/src/core/GeoInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeoInstance.d.ts","sourceRoot":"","sources":["../../../../../src/core/GeoInstance.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6B,MAAM,OAAO,CAAC;AAGlD,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAS5E,UAAU,gBAAgB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,gGAAgG;IAChG,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,gBAAgB,4BAcpG"}

package/build/types/real-time-viewer-next/src/core/PaletteDragPreview.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { GeoAsset, MatRef, SceneNode } from '../parser/parseRenderScript';
+import type { ResolvedGridCell } from '../types/accessoryGrids';
+interface PaletteDragPreviewProps {
+    /** The targeted drop cell — its transform is local to the parent element group this mounts in. */
+    cell: ResolvedGridCell;
+    node: SceneNode;
+    geoAssets: GeoAsset[];
+    archiveBaseUrl: string;
+    matRefs: MatRef[];
+}
+/**
+ * Preview of the palette-dragged accessory at the targeted drop cell: the article's real glb when
+ * resolvable, else a translucent bbox proxy. The glb anchors at `localPosition − geoLocalOffset`
+ * (a cell's localPosition is the bbox center; same identity as the variant re-centering).
+ */
+export declare function PaletteDragPreview({ cell, node, geoAssets, archiveBaseUrl, matRefs }: PaletteDragPreviewProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=PaletteDragPreview.d.ts.map

package/build/types/real-time-viewer-next/src/core/PaletteDragPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PaletteDragPreview.d.ts","sourceRoot":"","sources":["../../../../../src/core/PaletteDragPreview.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAU,MAAM,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAQhE,UAAU,uBAAuB;IAC/B,kGAAkG;IAClG,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,EAAE,uBAAuB,qBA8B7G"}