@layoutit/polycss-vue 0.2.0 → 0.2.1

package/dist/index.d.cts

@@ -1,20 +1,18 @@
 import * as vue from 'vue';
 import { PropType, Ref, InjectionKey, VNode, ComputedRef, MaybeRef } from 'vue';
-import { Vec3, CameraState, CameraHandle, Polygon, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, LoadMeshOptions, PolyMaterial, Vec2, PolyAnimationTarget, PolyAnimationMixer, PolyAnimationClip, PolyAnimationAction, ParseAnimationController } from '@layoutit/polycss-core';
-export { ApproximateMergeOptions, ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, BoxFace, BoxFaceOptions, BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, CoverPlanarPolygonsOptions, CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, GltfParseOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MeshResolution, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SolidTextureSampleOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, boxPolygons, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, formatColor, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, ringPolygons, rotateVec3, shadeColor } from '@layoutit/polycss-core';
+import { Vec3, CameraState, CameraHandle, Polygon, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, TextureQuality, PolySeamBleed, PolyRenderStrategiesOption, MeshResolution, LoadMeshOptions, ParseResult, PolyMaterial, Vec2, PolyAnimationTarget, PolyAnimationMixer, PolyAnimationClip, PolyAnimationAction, ParseAnimationController } from '@layoutit/polycss-core';
+export { ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, BoxFace, BoxFaceOptions, BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, ConePolygonsOptions, CoverPlanarPolygonsOptions, CullInteriorOptions, CylinderPolygonsOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, DEFAULT_SEAM_FACET_SPLIT_OPTIONS, DEFAULT_SEAM_OVERLAP_OPTIONS, DodecahedronPolygonsOptions, GltfParseOptions, IcosahedronPolygonsOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MeshResolution, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeAnimatedMeshPolygonsOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, PlanePolygonsOptions, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyRenderStrategiesOption, PolyRenderStrategy, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SeamFacetSplitCandidate, SeamFacetSplitCandidateReason, SeamFacetSplitOptions, SeamFacetSplitReport, SeamOverlapCandidate, SeamOverlapCandidateKind, SeamOverlapDiagnostics, SeamOverlapOptions, SolidTextureSampleOptions, TetrahedronPolygonsOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, TorusPolygonsOptions, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, boxPolygons, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, conePolygons, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, cylinderPolygons, dodecahedronPolygons, formatColor, icosahedronPolygons, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeAnimatedMeshPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, repairMeshSeams, ringPolygons, rotateVec3, seamFacetSplitPolygons, seamFacetSplitReport, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, tetrahedronPolygons, torusPolygons } from '@layoutit/polycss-core';
 
-interface PolyPerspectiveCameraProps {
+interface PolyOrthographicCameraProps {
     zoom?: number;
     target?: Vec3;
     rotX?: number;
     rotY?: number;
     /** Camera pull-back in CSS pixels (dolly). Default 0. */
     distance?: number;
-    /** CSS perspective distance in pixels. Defaults to 8000. */
-    perspective?: number;
     class?: string;
 }
-declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     zoom: {
         type: NumberConstructor;
     };
@@ -30,10 +28,6 @@ declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
-    perspective: {
-        type: NumberConstructor;
-        default: undefined;
-    };
     class: {
         type: StringConstructor;
     };
@@ -55,27 +49,23 @@ declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
-    perspective: {
-        type: NumberConstructor;
-        default: undefined;
-    };
     class: {
         type: StringConstructor;
     };
-}>> & Readonly<{}>, {
-    perspective: number;
-}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface PolyOrthographicCameraProps {
+interface PolyPerspectiveCameraProps {
     zoom?: number;
     target?: Vec3;
     rotX?: number;
     rotY?: number;
     /** Camera pull-back in CSS pixels (dolly). Default 0. */
     distance?: number;
+    /** CSS perspective distance in pixels. Defaults to 8000. */
+    perspective?: number;
     class?: string;
 }
-declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     zoom: {
         type: NumberConstructor;
     };
@@ -91,6 +81,10 @@ declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -112,13 +106,19 @@ declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {
+    perspective: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 /**
- * Lightweight reactive store for polycss scene state.
+ * Lightweight reactive store for PolyCSS scene state.
  * Components subscribe to specific slices via selectors,
  * so only the components that care about a changed value re-render.
  */
@@ -207,15 +207,13 @@ interface PolyShadowOptions {
     color?: string;
     opacity?: number;
     lift?: number;
-}
-
-type TextureQuality = number | "auto";
-type PolyRenderStrategy = "b" | "i" | "u";
-interface PolyRenderStrategiesOption {
-    /** Strategies to skip; polygons that would normally use them fall through
-     *  the chain (b → i → s, u → i → s, i → s). `<s>` is the universal
-     *  fallback and cannot be disabled — textured polys have no other path. */
-    disable?: readonly PolyRenderStrategy[];
+    /**
+     * Maximum CSS pixels the shadow may extend beyond the mesh's
+     * footprint. Caps the SVG backing store at low light elevations to
+     * prevent repaint flicker. Default: `2000`. Pass `Infinity` to
+     * disable the cap entirely.
+     */
+    maxExtend?: number;
 }
 
 interface PolySceneProps {
@@ -232,6 +230,8 @@ interface PolySceneProps {
      *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
      *  raster scale and the 64px sprite. */
     textureQuality?: TextureQuality;
+    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+    seamBleed?: PolySeamBleed;
     /** Opt out of specific render strategies. Disabled strategies fall through the chain (b→i→s, u→i→s, i→s). `<s>` cannot be disabled. */
     strategies?: PolyRenderStrategiesOption;
     /**
@@ -242,9 +242,11 @@ interface PolySceneProps {
      */
     autoCenter?: boolean;
     /**
-     * Shadow appearance for meshes with `castShadow: true`. Only applies in
-     * dynamic lighting mode — baked mode does not emit shadow leaves.
-     * Defaults: `{ color: "#000000", opacity: 0.25, lift: 0.05 }`.
+     * Shadow appearance for meshes with `castShadow: true`. Works in both
+     * lighting modes — dynamic mode projects via CSS vars so shadows
+     * follow a moving light, baked mode CPU-bakes the projection into
+     * each leaf's inline `matrix3d` and drops back-facing polys from the
+     * DOM entirely. Defaults: `{ color: "#000000", opacity: 0.25, lift: 0.05, maxExtend: 2000 }`.
      */
     shadow?: PolyShadowOptions;
     class?: string;
@@ -287,6 +289,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
     strategies: {
         type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
@@ -355,6 +361,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
     strategies: {
         type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
@@ -396,6 +406,7 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     polygons: Polygon[];
     ambientLight: PolyAmbientLight;
     textureQuality: TextureQuality;
+    seamBleed: PolySeamBleed;
     strategies: PolyRenderStrategiesOption;
     autoCenter: boolean;
     shadow: PolyShadowOptions;
@@ -407,7 +418,7 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
 /**
  * Pointer event API for `<PolyMesh>` (Vue). Mirrors @react-three/fiber's
  * mesh event surface (handler names + payload shape) so devs migrating
- * from three.js use the same mental model. polycss is DOM-native so
+ * from three.js use the same mental model. PolyCSS is DOM-native so
  * we get native pointer events for free — no raycaster, no canvas
  * event synthesis.
  *
@@ -429,6 +440,12 @@ interface PolyMeshHandle {
     getRotation(): Vec3 | undefined;
     getScale(): number | Vec3 | undefined;
     getPolygons(): Polygon[];
+    /**
+     * Replace the mesh polygons imperatively. Animated solid-triangle meshes use
+     * a stable DOM update path that mutates mounted leaves directly; unsupported
+     * topology falls back to the normal framework render path.
+     */
+    setPolygons(polygons: Polygon[]): void;
     /**
      * Update a single polygon in place. `target` is either a polygon
      * reference (as returned by `getPolygons()`) or its index. `partial`
@@ -514,6 +531,8 @@ interface PolyMeshProps extends InteractionProps {
      *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
      *  raster scale and the 64px sprite. */
     textureQuality?: TextureQuality;
+    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+    seamBleed?: PolySeamBleed;
     /**
      * When `true` and the scene is in dynamic lighting mode, the renderer emits
      * a flat shadow leaf sibling for each non-duplicate polygon. The shadow is
@@ -521,6 +540,10 @@ interface PolyMeshProps extends InteractionProps {
      * Defaults to `false`.
      */
     castShadow?: boolean;
+    /** Mesh optimization intent. Defaults to "lossy"; set "lossless" to keep
+     *  authored surface fidelity. Top-level prop wins over any meshResolution
+     *  that might be set inside parseOptions. */
+    meshResolution?: MeshResolution;
     class?: string;
     position?: Vec3;
     scale?: number | Vec3;
@@ -555,10 +578,18 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
     castShadow: {
         type: PropType<boolean>;
         default: boolean;
     };
+    meshResolution: {
+        type: PropType<MeshResolution>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -653,10 +684,18 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
     castShadow: {
         type: PropType<boolean>;
         default: boolean;
     };
+    meshResolution: {
+        type: PropType<MeshResolution>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -728,12 +767,14 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     scale: number | Vec3;
     polygons: Polygon[];
     textureQuality: TextureQuality;
+    seamBleed: PolySeamBleed;
     autoCenter: boolean;
     rotation: Vec3;
     id: string;
     src: string;
     mtl: string;
     castShadow: boolean;
+    meshResolution: MeshResolution;
     onContextMenu: PolyEventHandler<MouseEvent>;
     onDoubleClick: PolyEventHandler<MouseEvent>;
     onPointerDown: PolyEventHandler<PointerEvent>;
@@ -821,7 +862,7 @@ interface UseSceneContextResult {
     };
 }
 /**
- * Vue 3 composable that runs the polycss scene-context pipeline:
+ * Vue 3 composable that runs the PolyCSS scene-context pipeline:
  *   normalizePolygons → mergePolygons by default → bbox compute.
  *
  * Returns a Ref to the processed polygons + the scene-wide axis-aligned bbox.
@@ -832,6 +873,7 @@ declare function usePolySceneContext(polygons: Ref<Polygon[]>, options: Ref<UseS
 type UseMeshOptions = LoadMeshOptions;
 interface UseMeshResult {
     polygons: Ref<Polygon[]>;
+    voxelSource: Ref<ParseResult["voxelSource"]>;
     loading: Ref<boolean>;
     error: Ref<Error | null>;
     warnings: Ref<string[]>;
@@ -999,123 +1041,1049 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
 }>> & Readonly<{}>, {
     data: Record<string, string | number | boolean>;
     pointerEvents: "none" | "auto";
-    uvs: Vec2[];
     textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
     textureQuality: TextureQuality;
     rotation: Vec3;
     material: PolyMaterial;
+    uvs: Vec2[];
     context: PolyContext;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface PolyControlsAnimateOptions {
-    speed?: number;
-    axis?: "x" | "y";
-    pauseOnInteraction?: boolean;
-}
-interface PolyOrbitControlsCamera {
-    rotX: number;
-    rotY: number;
-    zoom: number;
-    target: Vec3;
-    distance: number;
-}
-interface PolyOrbitControlsProps {
-    drag?: boolean;
-    wheel?: boolean;
-    /** When true, wheel changes camera pull-back (distance) instead of zoom scale. */
-    dolly?: boolean;
-    invert?: boolean | number;
-    /** Minimum zoom multiplier (zoom mode). Default 0.1. */
-    minZoom?: number;
-    /** Maximum zoom multiplier (zoom mode). Default 10. */
-    maxZoom?: number;
-    /** Minimum camera pull-back in CSS pixels when dolly=true. Default 0. */
-    minDistance?: number;
-    /** Maximum camera pull-back in CSS pixels when dolly=true. Default 5000. */
-    maxDistance?: number;
-    animate?: false | PolyControlsAnimateOptions;
-}
-declare const PolyOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
-    drag: {
-        type: BooleanConstructor;
-        default: boolean;
+declare const PolyBox: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<number | Vec3>;
+        default: undefined;
     };
-    wheel: {
+    center: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    min: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    max: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    texture: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
-    dolly: {
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    center: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    min: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    max: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    texture: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
-    invert: {
-        type: PropType<boolean | number>;
-        default: boolean;
+    id: {
+        type: StringConstructor;
+        default: undefined;
     };
-    minZoom: {
-        type: NumberConstructor;
-        default: number;
+}>> & Readonly<{}>, {
+    color: string;
+    size: number | Vec3;
+    center: Vec3;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    texture: string;
+    id: string;
+    min: Vec3;
+    max: Vec3;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyPlane: vue.DefineComponent<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
     };
-    maxZoom: {
+    size: {
         type: NumberConstructor;
-        default: number;
+        default: undefined;
     };
-    minDistance: {
+    along: {
         type: NumberConstructor;
-        default: number;
+        default: undefined;
     };
-    maxDistance: {
-        type: NumberConstructor;
-        default: number;
+    color: {
+        type: StringConstructor;
+        default: undefined;
     };
-    animate: {
-        type: PropType<false | PolyControlsAnimateOptions>;
-        default: boolean;
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
-    change: (_camera: PolyOrbitControlsCamera) => true;
-    "interaction-start": (_camera: PolyOrbitControlsCamera) => true;
-    "interaction-end": (_camera: PolyOrbitControlsCamera) => true;
-}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    drag: {
-        type: BooleanConstructor;
-        default: boolean;
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
     };
-    wheel: {
-        type: BooleanConstructor;
-        default: boolean;
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-    dolly: {
+    autoCenter: {
         type: BooleanConstructor;
         default: boolean;
     };
-    invert: {
-        type: PropType<boolean | number>;
-        default: boolean;
+    id: {
+        type: StringConstructor;
+        default: undefined;
     };
-    minZoom: {
-        type: NumberConstructor;
-        default: number;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
     };
-    maxZoom: {
+    size: {
         type: NumberConstructor;
-        default: number;
+        default: undefined;
     };
-    minDistance: {
+    along: {
         type: NumberConstructor;
-        default: number;
+        default: undefined;
     };
-    maxDistance: {
-        type: NumberConstructor;
-        default: number;
+    color: {
+        type: StringConstructor;
+        default: undefined;
     };
-    animate: {
-        type: PropType<false | PolyControlsAnimateOptions>;
-        default: boolean;
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
     };
-}>> & Readonly<{
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    along: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyRing: vue.DefineComponent<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    radius: {
+        type: NumberConstructor;
+        required: true;
+    };
+    halfThickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    segments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    radius: {
+        type: NumberConstructor;
+        required: true;
+    };
+    halfThickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    segments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    halfThickness: number;
+    segments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyOctahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    center: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    center: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyTetrahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyIcosahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyDodecahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolySphere: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    subdivisions: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    subdivisions: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    subdivisions: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyCylinder: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radiusTop: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radiusTop: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    height: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radiusTop: number;
+    radialSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyCone: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    height: number;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radialSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PolyTorus: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tube: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tubularSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tube: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tubularSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radialSegments: number;
+    tube: number;
+    tubularSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolyControlsAnimateOptions {
+    speed?: number;
+    axis?: "x" | "y";
+    pauseOnInteraction?: boolean;
+}
+interface PolyOrbitControlsCamera {
+    rotX: number;
+    rotY: number;
+    zoom: number;
+    target: Vec3;
+    distance: number;
+}
+interface PolyOrbitControlsProps {
+    drag?: boolean;
+    wheel?: boolean;
+    /** When true, wheel changes camera pull-back (distance) instead of zoom scale. */
+    dolly?: boolean;
+    invert?: boolean | number;
+    /** Minimum zoom multiplier (zoom mode). Default 0.1. */
+    minZoom?: number;
+    /** Maximum zoom multiplier (zoom mode). Default 10. */
+    maxZoom?: number;
+    /** Minimum camera pull-back in CSS pixels when dolly=true. Default 0. */
+    minDistance?: number;
+    /** Maximum camera pull-back in CSS pixels when dolly=true. Default 5000. */
+    maxDistance?: number;
+    animate?: false | PolyControlsAnimateOptions;
+}
+declare const PolyOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
+        default: boolean;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (_camera: PolyOrbitControlsCamera) => true;
+    "interaction-start": (_camera: PolyOrbitControlsCamera) => true;
+    "interaction-end": (_camera: PolyOrbitControlsCamera) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
+        default: boolean;
+    };
+}>> & Readonly<{
     onChange?: ((_camera: PolyOrbitControlsCamera) => any) | undefined;
     "onInteraction-start"?: ((_camera: PolyOrbitControlsCamera) => any) | undefined;
     "onInteraction-end"?: ((_camera: PolyOrbitControlsCamera) => any) | undefined;
@@ -1781,6 +2749,29 @@ declare const PolyDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTyp
 
 declare function injectPolyBaseStyles(doc?: Document): void;
 
+interface PolyRenderSurfaceLeafCounts {
+    quad: number;
+    clippedSolid: number;
+    atlas: number;
+    stableTriangle: number;
+}
+interface PolyRenderStats {
+    polygonCount: number;
+    mountedPolygonLeafCount: number;
+    shadowLeafCount: number;
+    surfaceLeafCounts: PolyRenderSurfaceLeafCounts;
+    bucketCount: number;
+}
+interface PolyRenderStatsOptions {
+    polygonCount?: number;
+    /**
+     * Optional subtree selector for diagnostics that only want model leaves and
+     * not helpers/floors/gizmos sharing the same scene root.
+     */
+    scopeSelector?: string;
+}
+declare function collectPolyRenderStats(root: ParentNode | null | undefined, optionsOrPolygonCount?: number | PolyRenderStatsOptions): PolyRenderStats;
+
 interface UsePolyAnimationResultVue {
     /** Attach to a mesh handle when not passing `root` directly. */
     ref: Ref<PolyAnimationTarget | null>;
@@ -1798,4 +2789,4 @@ interface UsePolyAnimationResultVue {
 }
 declare function usePolyAnimation(clips: MaybeRef<PolyAnimationClip[] | undefined>, controller: MaybeRef<ParseAnimationController | undefined>, root?: MaybeRef<PolyAnimationTarget | null | undefined>): UsePolyAnimationResultVue;
 
-export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyPerspectiveCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyPerspectiveCameraProps as PolyCameraProps, type PolyContext, type PolyControlsAnimateOptions, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, type PolyEventHandler, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, PolyGround, type PolyGroundProps, PolyMapControls, type PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOrbitControls, type PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, type PolyPointerEvent, type PolyProps, type PolyRenderStrategiesOption, type PolyRenderStrategy, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type PolyWheelEvent, type UseCameraOptions, type UseCameraResult, type UseMeshOptions, type UseMeshResult, type UsePolyAnimationResultVue, type UseSceneContextOptions, type UseSceneContextResult, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };
+export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyBox, PolyOrthographicCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyOrthographicCameraProps as PolyCameraProps, PolyCone, type PolyContext, type PolyControlsAnimateOptions, PolyCylinder, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, PolyDodecahedron, type PolyEventHandler, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, PolyGround, type PolyGroundProps, PolyIcosahedron, PolyMapControls, type PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOctahedron, PolyOrbitControls, type PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, PolyPlane, type PolyPointerEvent, type PolyProps, type PolyRenderStats, type PolyRenderStatsOptions, type PolyRenderSurfaceLeafCounts, PolyRing, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, PolySphere, PolyTetrahedron, PolyTorus, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type PolyWheelEvent, type UseCameraOptions, type UseCameraResult, type UseMeshOptions, type UseMeshResult, type UsePolyAnimationResultVue, type UseSceneContextOptions, type UseSceneContextResult, collectPolyRenderStats, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };