@react-three/drei 11.0.0-alpha.1 → 11.0.0-alpha.4

package/index.d.mts

@@ -1,2567 +1,2166 @@
-import * as React$1 from "react";
-import { CSSProperties, ForwardRefExoticComponent, PropsWithoutRef, ReactNode, RefAttributes, RefObject } from "react";
-import * as FIBER from "@react-three/fiber";
-import { Color, ComputeFunction, Euler, ObjectMap, ReactThreeFiber, ThreeElement, ThreeElements, ThreeEvent, Vector2, Vector3 } from "@react-three/fiber";
-import { SplitStrategy } from "three-mesh-bvh";
-import { RenderPass } from "three/examples/jsm/postprocessing/RenderPass";
-import { ShaderPass } from "three/examples/jsm/postprocessing/ShaderPass";
-import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer";
-import * as THREE from "three";
-import { Color as Color$1, ColorRepresentation, Object3D, WebGLCubeRenderTarget as CubeRenderTarget } from "three";
-import { Line2 } from "three/examples/jsm/lines/Line2.js";
-import { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
-import { LineMaterial, LineMaterialParameters } from "three/examples/jsm/lines/LineMaterial.js";
-import { ArcballControls as ArcballControls$1 } from "three/examples/jsm/controls/ArcballControls.js";
-import { DeviceOrientationControls as DeviceOrientationControls$1 } from "three-stdlib";
-import { FirstPersonControls as FirstPersonControls$1 } from "three/examples/jsm/controls/FirstPersonControls";
-import { FlyControls as FlyControls$1 } from "three/examples/jsm/controls/FlyControls.js";
-import { MapControls as MapControls$1 } from "three/examples/jsm/controls/MapControls.js";
-import { OrbitControls as OrbitControls$1 } from "three/addons/controls/OrbitControls.js";
-import { PointerLockControls as PointerLockControls$1 } from "three/examples/jsm/controls/PointerLockControls.js";
-import { TrackballControls as TrackballControls$1 } from "three/examples/jsm/controls/TrackballControls.js";
-import { Flow } from "three/examples/jsm/modifiers/CurveModifier";
-import { TextGeometry, TextGeometryParameters } from "three/examples/jsm/geometries/TextGeometry";
-import * as three_examples_jsm_loaders_FontLoader0 from "three/examples/jsm/loaders/FontLoader";
-import { TransformControls as TransformControls$1 } from "three/examples/jsm/controls/TransformControls";
-import { GLTF, GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
-import { GroundedSkybox } from "three/examples/jsm/objects/GroundedSkybox";
-import { Sky as Sky$1 } from "three/examples/jsm/objects/Sky.js";
-import { MarchingCubes as MarchingCubes$1 } from "three/examples/jsm/objects/MarchingCubes";
-import * as THREE$1 from "#three";
-import { AnimationAction, AnimationClip, AnimationMixer, Box3, BufferAttribute, BufferGeometry, Camera, Color as Color$2, ColorSpace, CubeCamera as CubeCamera$1, CubeTexture as CubeTexture$1, DepthTexture, Event, EventDispatcher, ExtrudeGeometry, Fog, FogExp2, Group, InstancedBufferAttribute, InstancedMesh, Intersection, LOD, Loader as Loader$2, Material, Matrix4, Mesh as Mesh$1, MeshBasicMaterial as MeshBasicMaterial$1, MeshStandardMaterial, Object3D as Object3D$1, OrthographicCamera as OrthographicCamera$2, PerspectiveCamera as PerspectiveCamera$1, PlaneGeometry as PlaneGeometry$1, PositionalAudio as PositionalAudio$1, Raycaster, RenderTargetOptions, Scene as Scene$1, Sphere as Sphere$1, Texture as Texture$2, Vector3 as Vector3$2 } from "#three";
-import { DragConfig } from "@use-gesture/react";
-import * as zustand0 from "zustand";
-import { StoreApi } from "zustand";
-import { Assign, Falsey } from "utility-types";
-import * as hls_js1 from "hls.js";
-import Hls from "hls.js";
-import * as detect_gpu0 from "detect-gpu";
-import { GetGPUTier } from "detect-gpu";
-import Stats$1 from "stats-gl";
-import CameraControlsImpl from "camera-controls";
-import { FaceLandmarker as FaceLandmarker$1, FaceLandmarkerOptions, FaceLandmarkerResult } from "@mediapipe/tasks-vision";
-
-//#region src/utils/ts-utils.d.ts
+import * as React from 'react';
+import { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, CSSProperties, RefObject, ReactNode } from 'react';
+import * as _react_three_fiber from '@react-three/fiber';
+import { ThreeElements, ReactThreeFiber, ThreeElement, Vector2, Vector3, ThreeEvent, Color as Color$1, ObjectMap, ComputeFunction, Euler } from '@react-three/fiber';
+import * as THREE from 'three';
+import { MeshStandardMaterial, Texture as Texture$1, Matrix4, Color, ColorRepresentation, Object3D, Fog, FogExp2, WebGLCubeRenderTarget, CubeCamera as CubeCamera$1, OrthographicCamera as OrthographicCamera$1, PerspectiveCamera as PerspectiveCamera$1, Event, Camera, Material, Vector3 as Vector3$1, Group, LOD, Mesh, ExtrudeGeometry, PositionalAudio as PositionalAudio$1, AnimationClip, AnimationMixer, AnimationAction, BufferGeometry, BufferAttribute, InstancedMesh as InstancedMesh$1, InstancedBufferAttribute, DepthTexture, CubeTexture as CubeTexture$1, Raycaster, Intersection, RenderTargetOptions, Box3, Sphere as Sphere$1, Loader as Loader$1, ColorSpace, Scene, PlaneGeometry, MeshBasicMaterial, EventDispatcher } from 'three';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { ArcballControls as ArcballControls$1 } from 'three/examples/jsm/controls/ArcballControls.js';
+import { DeviceOrientationControls as DeviceOrientationControls$1 } from 'three-stdlib';
+import { DragConfig } from '@use-gesture/react';
+import { FirstPersonControls as FirstPersonControls$1 } from 'three/examples/jsm/controls/FirstPersonControls.js';
+import { FlyControls as FlyControls$1 } from 'three/examples/jsm/controls/FlyControls.js';
+import * as zustand from 'zustand';
+import { StoreApi } from 'zustand';
+import { MapControls as MapControls$1 } from 'three/examples/jsm/controls/MapControls.js';
+import { OrbitControls as OrbitControls$1 } from 'three/addons/controls/OrbitControls.js';
+import { PointerLockControls as PointerLockControls$1 } from 'three/examples/jsm/controls/PointerLockControls.js';
+import { TrackballControls as TrackballControls$1 } from 'three/examples/jsm/controls/TrackballControls.js';
+import { Line2 } from 'three/examples/jsm/lines/Line2.js';
+import { LineMaterialParameters, LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
+import { Flow } from 'three/examples/jsm/modifiers/CurveModifier.js';
+import { TextGeometry, TextGeometryParameters } from 'three/examples/jsm/geometries/TextGeometry.js';
+import * as three_examples_jsm_loaders_FontLoader_js from 'three/examples/jsm/loaders/FontLoader.js';
+import { TransformControls as TransformControls$1 } from 'three/examples/jsm/controls/TransformControls.js';
+import { Falsey, Assign } from 'utility-types';
+import * as hls_js from 'hls.js';
+import hls_js__default from 'hls.js';
+import { GLTFLoader, GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import * as detect_gpu from 'detect-gpu';
+import { GetGPUTier } from 'detect-gpu';
+import Stats$1 from 'stats-gl';
+import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
+import { Sky as Sky$1 } from 'three/examples/jsm/objects/Sky.js';
+import { SplitStrategy } from 'three-mesh-bvh';
+import CameraControlsImpl from 'camera-controls';
+export { default as CameraControlsImpl } from 'camera-controls';
+import { FaceLandmarkerResult, FaceLandmarkerOptions, FaceLandmarker as FaceLandmarker$1 } from '@mediapipe/tasks-vision';
+import { MarchingCubes as MarchingCubes$1 } from 'three/examples/jsm/objects/MarchingCubes.js';
+
 type NamedArrayTuple<T extends (...args: any) => any> = Parameters<T>;
 type ForwardRefComponent<P, T> = ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;
-type NonFunctionKeys<T> = { [K in keyof T]-?: T[K] extends Function ? never : K }[keyof T];
+type NonFunctionKeys<T> = {
+    [K in keyof T]-?: T[K] extends Function ? never : K;
+}[keyof T];
 type Overwrite<T, O> = Omit<T, NonFunctionKeys<O>> & O;
-//#endregion
-//#region src/legacy/Materials/ContactShadows/ContactShadows.d.ts
+
 type ContactShadowsProps = Omit<ThreeElements['group'], 'ref' | 'scale'> & {
-  opacity?: number;
-  width?: number;
-  height?: number;
-  blur?: number;
-  near?: number;
-  far?: number;
-  smooth?: boolean;
-  resolution?: number;
-  frames?: number;
-  scale?: number | [x: number, y: number];
-  color?: THREE$1.ColorRepresentation;
-  depthWrite?: boolean;
-};
-//#endregion
-//#region src/legacy/Materials/AccumulativeShadows/AccumulativeShadows.d.ts
+    opacity?: number;
+    width?: number;
+    height?: number;
+    blur?: number;
+    near?: number;
+    far?: number;
+    smooth?: boolean;
+    resolution?: number;
+    frames?: number;
+    scale?: number | [x: number, y: number];
+    color?: THREE.ColorRepresentation;
+    depthWrite?: boolean;
+};
+
 type AccumulativeShadowsProps = Omit<ThreeElements['group'], 'ref'> & {
-  frames?: number;
-  blend?: number;
-  limit?: number;
-  scale?: number;
-  temporal?: boolean;
-  opacity?: number;
-  alphaTest?: number;
-  color?: string;
-  colorBlend?: number;
-  resolution?: number;
-  toneMapped?: boolean;
+    frames?: number;
+    blend?: number;
+    limit?: number;
+    scale?: number;
+    temporal?: boolean;
+    opacity?: number;
+    alphaTest?: number;
+    color?: string;
+    colorBlend?: number;
+    resolution?: number;
+    toneMapped?: boolean;
 };
 type SoftShadowMaterialProps = {
-  map: THREE$1.Texture;
-  color?: ReactThreeFiber.Color;
-  alphaTest?: number;
-  blend?: number;
+    map: THREE.Texture;
+    color?: ReactThreeFiber.Color;
+    alphaTest?: number;
+    blend?: number;
 };
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps;
-  }
+    interface ThreeElements {
+        softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps;
+    }
 }
 type RandomizedLightProps = Omit<ThreeElements['group'], 'ref'> & {
-  frames?: number;
-  position?: [x: number, y: number, z: number];
-  radius?: number;
-  amount?: number;
-  intensity?: number;
-  ambient?: number;
-  castShadow?: boolean;
-  bias?: number;
-  mapSize?: number;
-  size?: number;
-  near?: number;
-  far?: number;
-};
-//#endregion
-//#region src/legacy/Materials/Caustics/Caustics.d.ts
+    frames?: number;
+    position?: [x: number, y: number, z: number];
+    radius?: number;
+    amount?: number;
+    intensity?: number;
+    ambient?: number;
+    castShadow?: boolean;
+    bias?: number;
+    mapSize?: number;
+    size?: number;
+    near?: number;
+    far?: number;
+};
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    causticsProjectionMaterial: ThreeElements['meshNormalMaterial'] & {
-      viewMatrix?: {
-        value: THREE$1.Matrix4;
-      };
-      color?: ReactThreeFiber.Color;
-      causticsTexture?: THREE$1.Texture;
-      causticsTextureB?: THREE$1.Texture;
-      lightProjMatrix?: THREE$1.Matrix4;
-      lightViewMatrix?: THREE$1.Matrix4;
-    };
-  }
+    interface ThreeElements {
+        causticsProjectionMaterial: ThreeElements['meshNormalMaterial'] & {
+            viewMatrix?: {
+                value: THREE.Matrix4;
+            };
+            color?: ReactThreeFiber.Color;
+            causticsTexture?: THREE.Texture;
+            causticsTextureB?: THREE.Texture;
+            lightProjMatrix?: THREE.Matrix4;
+            lightViewMatrix?: THREE.Matrix4;
+        };
+    }
 }
-//#endregion
-//#region src/legacy/Materials/MeshTransmissionMaterial/MeshTransmissionMaterial.d.ts
+
 type MeshTransmissionMaterialType = Omit<ThreeElements['meshPhysicalMaterial'], 'args' | 'roughness' | 'thickness' | 'transmission'> & {
-  transmission?: number;
-  thickness?: number;
-  roughness?: number;
-  chromaticAberration?: number;
-  anisotropy?: number;
-  anisotropicBlur?: number;
-  distortion?: number;
-  distortionScale?: number;
-  temporalDistortion?: number;
-  buffer?: THREE$1.Texture;
-  time?: number;
-  args?: [samples: number, transmissionSampler: boolean];
+    transmission?: number;
+    thickness?: number;
+    roughness?: number;
+    chromaticAberration?: number;
+    anisotropy?: number;
+    anisotropicBlur?: number;
+    distortion?: number;
+    distortionScale?: number;
+    temporalDistortion?: number;
+    buffer?: THREE.Texture;
+    time?: number;
+    args?: [samples: number, transmissionSampler: boolean];
 };
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    meshTransmissionMaterial: MeshTransmissionMaterialType;
-  }
+    interface ThreeElements {
+        meshTransmissionMaterial: MeshTransmissionMaterialType;
+    }
 }
-//#endregion
-//#region src/legacy/Materials/MeshReflectorMaterial/MeshReflectorMaterialClass.d.ts
+
 declare class MeshReflectorMaterial extends MeshStandardMaterial {
-  private _tDepth;
-  private _distortionMap;
-  private _tDiffuse;
-  private _tDiffuseBlur;
-  private _textureMatrix;
-  private _hasBlur;
-  private _mirror;
-  private _mixBlur;
-  private _blurStrength;
-  private _minDepthThreshold;
-  private _maxDepthThreshold;
-  private _depthScale;
-  private _depthToBlurRatioBias;
-  private _distortion;
-  private _mixContrast;
-  constructor(parameters?: {});
-  onBeforeCompile(shader: any): void;
-  get tDiffuse(): Texture$2 | null;
-  set tDiffuse(v: Texture$2 | null);
-  get tDepth(): Texture$2 | null;
-  set tDepth(v: Texture$2 | null);
-  get distortionMap(): Texture$2 | null;
-  set distortionMap(v: Texture$2 | null);
-  get tDiffuseBlur(): Texture$2 | null;
-  set tDiffuseBlur(v: Texture$2 | null);
-  get textureMatrix(): Matrix4 | null;
-  set textureMatrix(v: Matrix4 | null);
-  get hasBlur(): boolean;
-  set hasBlur(v: boolean);
-  get mirror(): number;
-  set mirror(v: number);
-  get mixBlur(): number;
-  set mixBlur(v: number);
-  get mixStrength(): number;
-  set mixStrength(v: number);
-  get minDepthThreshold(): number;
-  set minDepthThreshold(v: number);
-  get maxDepthThreshold(): number;
-  set maxDepthThreshold(v: number);
-  get depthScale(): number;
-  set depthScale(v: number);
-  get depthToBlurRatioBias(): number;
-  set depthToBlurRatioBias(v: number);
-  get distortion(): number;
-  set distortion(v: number);
-  get mixContrast(): number;
-  set mixContrast(v: number);
+    private _tDepth;
+    private _distortionMap;
+    private _tDiffuse;
+    private _tDiffuseBlur;
+    private _textureMatrix;
+    private _hasBlur;
+    private _mirror;
+    private _mixBlur;
+    private _blurStrength;
+    private _minDepthThreshold;
+    private _maxDepthThreshold;
+    private _depthScale;
+    private _depthToBlurRatioBias;
+    private _distortion;
+    private _mixContrast;
+    constructor(parameters?: {});
+    onBeforeCompile(shader: any): void;
+    get tDiffuse(): Texture$1 | null;
+    set tDiffuse(v: Texture$1 | null);
+    get tDepth(): Texture$1 | null;
+    set tDepth(v: Texture$1 | null);
+    get distortionMap(): Texture$1 | null;
+    set distortionMap(v: Texture$1 | null);
+    get tDiffuseBlur(): Texture$1 | null;
+    set tDiffuseBlur(v: Texture$1 | null);
+    get textureMatrix(): Matrix4 | null;
+    set textureMatrix(v: Matrix4 | null);
+    get hasBlur(): boolean;
+    set hasBlur(v: boolean);
+    get mirror(): number;
+    set mirror(v: number);
+    get mixBlur(): number;
+    set mixBlur(v: number);
+    get mixStrength(): number;
+    set mixStrength(v: number);
+    get minDepthThreshold(): number;
+    set minDepthThreshold(v: number);
+    get maxDepthThreshold(): number;
+    set maxDepthThreshold(v: number);
+    get depthScale(): number;
+    set depthScale(v: number);
+    get depthToBlurRatioBias(): number;
+    set depthToBlurRatioBias(v: number);
+    get distortion(): number;
+    set distortion(v: number);
+    get mixContrast(): number;
+    set mixContrast(v: number);
 }
-//#endregion
-//#region src/legacy/Materials/MeshReflectorMaterial/MeshReflectorMaterial.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    meshReflectorMaterialImpl: ThreeElement<typeof MeshReflectorMaterial>;
-  }
+    interface ThreeElements {
+        meshReflectorMaterialImpl: ThreeElement<typeof MeshReflectorMaterial>;
+    }
 }
-//#endregion
-//#region src/legacy/Materials/MeshPortalMaterial/MeshPortalMaterial.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    portalMaterialImpl: ThreeElements['shaderMaterial'] & {
-      resolution: ReactThreeFiber.Vector2;
-      blur: number;
-      blend: number;
-      size?: number;
-      sdf?: THREE$1.Texture;
-      map?: THREE$1.Texture;
-    };
-  }
+    interface ThreeElements {
+        portalMaterialImpl: ThreeElements['shaderMaterial'] & {
+            resolution: ReactThreeFiber.Vector2;
+            blur: number;
+            blend: number;
+            size?: number;
+            sdf?: THREE.Texture;
+            map?: THREE.Texture;
+        };
+    }
 }
-//#endregion
-//#region src/legacy/Materials/MeshDistortMaterial/MeshDistortMaterial.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    distortMaterialImpl: ThreeElements['meshPhysicalMaterial'] & {
-      time?: number;
-      distort?: number;
-      radius?: number;
-    };
-  }
+    interface ThreeElements {
+        distortMaterialImpl: ThreeElements['meshPhysicalMaterial'] & {
+            time?: number;
+            distort?: number;
+            radius?: number;
+        };
+    }
 }
-//#endregion
-//#region src/legacy/Materials/MeshWobbleMaterial/MeshWobbleMaterial.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    wobbleMaterialImpl: ThreeElements['meshStandardMaterial'] & {
-      time?: number;
-      factor?: number;
-      speed?: number;
-    };
-  }
+    interface ThreeElements {
+        wobbleMaterialImpl: ThreeElements['meshStandardMaterial'] & {
+            time?: number;
+            factor?: number;
+            speed?: number;
+        };
+    }
 }
-//#endregion
-//#region src/experimental/Effects/Outlines/Outlines.d.ts
+
 type OutlinesProps = Omit<ThreeElements['group'], 'ref'> & {
-  color?: ReactThreeFiber.Color;
-  screenspace?: boolean;
-  opacity?: number;
-  transparent?: boolean;
-  thickness?: number;
-  angle?: number;
-  clippingPlanes?: THREE$1.Plane[];
-  toneMapped?: boolean;
-  polygonOffset?: boolean;
-  polygonOffsetFactor?: number;
-  renderOrder?: number;
-};
-declare function Outlines({
-  color,
-  opacity,
-  transparent,
-  screenspace,
-  toneMapped,
-  polygonOffset,
-  polygonOffsetFactor,
-  renderOrder,
-  thickness,
-  angle,
-  clippingPlanes,
-  ...props
-}: OutlinesProps): React$1.JSX.Element;
-//#endregion
-//#region src/legacy/Abstractions/Effects/Effects.d.ts
+    color?: ReactThreeFiber.Color;
+    screenspace?: boolean;
+    opacity?: number;
+    transparent?: boolean;
+    thickness?: number;
+    angle?: number;
+    clippingPlanes?: THREE.Plane[];
+    toneMapped?: boolean;
+    polygonOffset?: boolean;
+    polygonOffsetFactor?: number;
+    renderOrder?: number;
+};
+declare function Outlines({ color, opacity, transparent, screenspace, toneMapped, polygonOffset, polygonOffsetFactor, renderOrder, thickness, angle, clippingPlanes, ...props }: OutlinesProps): React.JSX.Element;
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    effectComposer: ThreeElement<typeof EffectComposer>;
-    renderPass: ThreeElement<typeof RenderPass>;
-    shaderPass: ThreeElement<typeof ShaderPass>;
-  }
+    interface ThreeElements {
+        effectComposer: ThreeElement<typeof EffectComposer>;
+        renderPass: ThreeElement<typeof RenderPass>;
+        shaderPass: ThreeElement<typeof ShaderPass>;
+    }
 }
-//#endregion
-//#region src/core/Portal/RenderTexture/RenderTexture.d.ts
+
 type RenderTextureProps = Omit<ThreeElements['texture'], 'ref' | 'args'> & {
-  width?: number;
-  height?: number;
-  samples?: number;
-  stencilBuffer?: boolean;
-  depthBuffer?: boolean;
-  generateMipmaps?: boolean;
-  renderPriority?: number;
-  eventPriority?: number;
-  frames?: number;
-  compute?: (event: any, state: any, previous: any) => false | undefined;
-  children: React$1.ReactNode;
-};
-declare const RenderTexture: ForwardRefComponent<RenderTextureProps, THREE$1.Texture>;
-//#endregion
-//#region src/legacy/Geometry/Line/Line.d.ts
+    width?: number;
+    height?: number;
+    samples?: number;
+    stencilBuffer?: boolean;
+    depthBuffer?: boolean;
+    generateMipmaps?: boolean;
+    renderPriority?: number;
+    eventPriority?: number;
+    frames?: number;
+    compute?: (event: any, state: any, previous: any) => false | undefined;
+    children: React.ReactNode;
+};
+declare const RenderTexture: ForwardRefComponent<RenderTextureProps, THREE.Texture>;
+
 type LineProps = Omit<{
-  points: ReadonlyArray<Vector2 | Vector3>;
-  vertexColors?: ReadonlyArray<Color$1 | [number, number, number] | [number, number, number, number]>;
-  lineWidth?: number;
-  segments?: boolean;
+    points: ReadonlyArray<Vector2 | Vector3>;
+    vertexColors?: ReadonlyArray<Color | [number, number, number] | [number, number, number, number]>;
+    lineWidth?: number;
+    segments?: boolean;
 } & Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<ThreeElement<typeof Line2>, 'ref' | 'args'> & Omit<ThreeElement<typeof LineMaterial>, 'ref' | 'color' | 'vertexColors' | 'args'> & {
-  color?: ColorRepresentation;
+    color?: ColorRepresentation;
 }, 'ref'>;
-//#endregion
-//#region src/legacy/Geometry/Segments/Segments.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    segmentObject: ThreeElement<typeof SegmentObject>;
-  }
+    interface ThreeElements {
+        segmentObject: ThreeElement<typeof SegmentObject>;
+    }
 }
 declare class SegmentObject {
-  color: THREE.Color;
-  start: THREE.Vector3;
-  end: THREE.Vector3;
-  constructor();
+    color: THREE.Color;
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+    constructor();
 }
-//#endregion
-//#region src/legacy/Effects/Trail/Trail.d.ts
+
 type Settings$1 = {
-  width: number;
-  length: number;
-  decay: number;
-  local: boolean;
-  stride: number;
-  interval: number;
+    width: number;
+    length: number;
+    decay: number;
+    local: boolean;
+    stride: number;
+    interval: number;
 };
 type TrailProps = {
-  color?: ColorRepresentation;
-  attenuation?: (t: number) => number;
-  target?: React$1.RefObject<Object3D>;
+    color?: ColorRepresentation;
+    attenuation?: (t: number) => number;
+    target?: React.RefObject<Object3D>;
 } & Partial<Settings$1>;
-declare function useTrail(target: Object3D, settings: Partial<Settings$1>, pointCount: number): React$1.RefObject<Float32Array>;
-declare const Trail: ForwardRefComponent<React$1.PropsWithChildren<TrailProps>, Line2>;
-//#endregion
-//#region src/core/Cameras/CubeCamera/CubeCamera.d.ts
+declare function useTrail(target: Object3D, settings: Partial<Settings$1>, pointCount: number): React.RefObject<Float32Array>;
+declare const Trail: ForwardRefComponent<React.PropsWithChildren<TrailProps>, Line2>;
+
 type CubeCameraOptions = {
-  resolution?: number;
-  near?: number;
-  far?: number;
-  envMap?: Texture$2;
-  fog?: Fog | FogExp2;
+    resolution?: number;
+    near?: number;
+    far?: number;
+    envMap?: Texture$1;
+    fog?: Fog | FogExp2;
 };
 type CubeCameraProps = Omit<ThreeElements['group'], 'children'> & {
-  children?: (tex: Texture$2) => React$1.ReactNode;
-  frames?: number;
+    children?: (tex: Texture$1) => React.ReactNode;
+    frames?: number;
 } & CubeCameraOptions;
-declare function useCubeCamera({
-  resolution,
-  near,
-  far,
-  envMap,
-  fog
-}?: CubeCameraOptions): {
-  fbo: CubeRenderTarget;
-  camera: CubeCamera$1;
-  update: () => void;
-};
-declare function CubeCamera({
-  children,
-  frames,
-  resolution,
-  near,
-  far,
-  envMap,
-  fog,
-  ...props
-}: CubeCameraProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Cameras/OrthographicCamera/OrthographicCamera.d.ts
+declare function useCubeCamera({ resolution, near, far, envMap, fog }?: CubeCameraOptions): {
+    fbo: WebGLCubeRenderTarget;
+    camera: CubeCamera$1;
+    update: () => void;
+};
+declare function CubeCamera({ children, frames, resolution, near, far, envMap, fog, ...props }: CubeCameraProps): React.JSX.Element;
+
 type OrthographicCameraProps = Omit<ThreeElements['orthographicCamera'], 'ref' | 'children'> & {
-  makeDefault?: boolean;
-  manual?: boolean;
-  children?: React$1.ReactNode | ((texture: THREE$1.Texture) => React$1.ReactNode);
-  frames?: number;
-  resolution?: number;
-  envMap?: THREE$1.Texture;
-};
-declare const OrthographicCamera: ForwardRefComponent<OrthographicCameraProps, OrthographicCamera$2>;
-//#endregion
-//#region src/core/Cameras/PerspectiveCamera/PerspectiveCamera.d.ts
+    makeDefault?: boolean;
+    manual?: boolean;
+    children?: React.ReactNode | ((texture: THREE.Texture) => React.ReactNode);
+    frames?: number;
+    resolution?: number;
+    envMap?: THREE.Texture;
+};
+declare const OrthographicCamera: ForwardRefComponent<OrthographicCameraProps, OrthographicCamera$1>;
+
 type PerspectiveCameraProps = Omit<ThreeElements['perspectiveCamera'], 'ref' | 'children'> & {
-  makeDefault?: boolean;
-  manual?: boolean;
-  children?: React$1.ReactNode | ((texture: THREE$1.Texture) => React$1.ReactNode);
-  frames?: number;
-  resolution?: number;
-  envMap?: THREE$1.Texture;
+    makeDefault?: boolean;
+    manual?: boolean;
+    children?: React.ReactNode | ((texture: THREE.Texture) => React.ReactNode);
+    frames?: number;
+    resolution?: number;
+    envMap?: THREE.Texture;
 };
 declare const PerspectiveCamera: ForwardRefComponent<PerspectiveCameraProps, PerspectiveCamera$1>;
-//#endregion
-//#region src/core/Controls/ArcballControls/ArcballControls.d.ts
+
 type ArcballControlsProps = Omit<Overwrite<ThreeElement<typeof ArcballControls$1>, {
-  target?: ReactThreeFiber.Vector3;
-  camera?: OrthographicCamera$2 | PerspectiveCamera$1;
-  domElement?: HTMLElement;
-  regress?: boolean;
-  makeDefault?: boolean;
-  onChange?: (e?: Event) => void;
-  onStart?: (e?: Event) => void;
-  onEnd?: (e?: Event) => void;
+    target?: ReactThreeFiber.Vector3;
+    camera?: OrthographicCamera$1 | PerspectiveCamera$1;
+    domElement?: HTMLElement;
+    regress?: boolean;
+    makeDefault?: boolean;
+    onChange?: (e?: Event) => void;
+    onStart?: (e?: Event) => void;
+    onEnd?: (e?: Event) => void;
 }>, 'ref' | 'args'>;
 declare const ArcballControls: ForwardRefComponent<ArcballControlsProps, ArcballControls$1>;
-//#endregion
-//#region src/core/Controls/DeviceOrientationControls/DeviceOrientationControls.d.ts
+
 type DeviceOrientationControlsProps = Omit<ThreeElement<typeof DeviceOrientationControls$1>, 'ref' | 'args'> & {
-  camera?: THREE$1.Camera;
-  onChange?: (e?: THREE$1.Event) => void;
-  makeDefault?: boolean;
+    camera?: THREE.Camera;
+    onChange?: (e?: THREE.Event) => void;
+    makeDefault?: boolean;
 };
 declare const DeviceOrientationControls: ForwardRefComponent<DeviceOrientationControlsProps, DeviceOrientationControls$1>;
-//#endregion
-//#region src/core/Controls/DragControls/DragControls.d.ts
+
 type DragControlsProps = {
-  autoTransform?: boolean;
-  matrix?: THREE$1.Matrix4;
-  axisLock?: 'x' | 'y' | 'z';
-  dragLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
-  onHover?: (hovering: boolean) => void;
-  onDragStart?: (origin: THREE$1.Vector3) => void;
-  onDrag?: (localMatrix: THREE$1.Matrix4, deltaLocalMatrix: THREE$1.Matrix4, worldMatrix: THREE$1.Matrix4, deltaWorldMatrix: THREE$1.Matrix4) => void;
-  onDragEnd?: () => void;
-  children: React$1.ReactNode;
-  dragConfig?: DragConfig;
-};
-declare const DragControls: ForwardRefComponent<DragControlsProps, THREE$1.Group>;
-//#endregion
-//#region src/core/Controls/FirstPersonControls/FirstPersonControls.d.ts
+    autoTransform?: boolean;
+    matrix?: THREE.Matrix4;
+    axisLock?: 'x' | 'y' | 'z';
+    dragLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    onHover?: (hovering: boolean) => void;
+    onDragStart?: (origin: THREE.Vector3) => void;
+    onDrag?: (localMatrix: THREE.Matrix4, deltaLocalMatrix: THREE.Matrix4, worldMatrix: THREE.Matrix4, deltaWorldMatrix: THREE.Matrix4) => void;
+    onDragEnd?: () => void;
+    children: React.ReactNode;
+    dragConfig?: DragConfig;
+};
+declare const DragControls: ForwardRefComponent<DragControlsProps, THREE.Group>;
+
 type FirstPersonControlsProps = Omit<ThreeElement<typeof FirstPersonControls$1>, 'ref' | 'args'> & {
-  domElement?: HTMLElement;
-  makeDefault?: boolean;
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
 };
 declare const FirstPersonControls: ForwardRefComponent<FirstPersonControlsProps, FirstPersonControls$1>;
-//#endregion
-//#region src/core/Controls/FlyControls/FlyControls.d.ts
+
 type FlyControlsProps = Omit<ThreeElement<typeof FlyControls$1>, 'ref' | 'args'> & {
-  onChange?: (e?: THREE$1.Event) => void;
-  domElement?: HTMLElement;
-  makeDefault?: boolean;
+    onChange?: (e?: THREE.Event) => void;
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
 };
 declare const FlyControls: ForwardRefComponent<FlyControlsProps, FlyControls$1>;
-//#endregion
-//#region src/core/Controls/KeyboardControls/KeyboardControls.d.ts
+
 type State = object;
 type StateSelector<T extends State, U> = (state: T) => U;
 type EqualityChecker<T> = (state: T, newState: T) => boolean;
 type StateListener<T> = (state: T, previousState: T) => void;
 type StoreApiWithSubscribeWithSelector<T extends State> = Omit<StoreApi<T>, 'subscribe'> & {
-  subscribe: {
-    (listener: StateListener<T>): () => void;
-    <StateSlice>(selector: StateSelector<T, StateSlice>, listener: StateListener<StateSlice>, options?: {
-      equalityFn?: EqualityChecker<StateSlice>;
-      fireImmediately?: boolean;
-    }): () => void;
-  };
-};
-type KeyboardControlsState<T extends string = string> = { [K in T]: boolean };
+    subscribe: {
+        (listener: StateListener<T>): () => void;
+        <StateSlice>(selector: StateSelector<T, StateSlice>, listener: StateListener<StateSlice>, options?: {
+            equalityFn?: EqualityChecker<StateSlice>;
+            fireImmediately?: boolean;
+        }): () => void;
+    };
+};
+type KeyboardControlsState<T extends string = string> = {
+    [K in T]: boolean;
+};
 type KeyboardControlsEntry<T extends string = string> = {
-  name: T;
-  keys: string[];
-  up?: boolean;
+    name: T;
+    keys: string[];
+    up?: boolean;
 };
 type KeyboardControlsProps = {
-  map: KeyboardControlsEntry[];
-  children: React$1.ReactNode;
-  onChange?: (name: string, pressed: boolean, state: KeyboardControlsState) => void;
-  domElement?: HTMLElement;
-};
-declare function KeyboardControls({
-  map,
-  children,
-  onChange,
-  domElement
-}: KeyboardControlsProps): React$1.JSX.Element;
+    map: KeyboardControlsEntry[];
+    children: React.ReactNode;
+    onChange?: (name: string, pressed: boolean, state: KeyboardControlsState) => void;
+    domElement?: HTMLElement;
+};
+declare function KeyboardControls({ map, children, onChange, domElement }: KeyboardControlsProps): React.JSX.Element;
 type Selector<T extends string = string> = (state: KeyboardControlsState<T>) => boolean;
-declare function useKeyboardControls<T extends string = string>(): [StoreApiWithSubscribeWithSelector<KeyboardControlsState<T>>['subscribe'], StoreApiWithSubscribeWithSelector<KeyboardControlsState<T>>['getState']];
+declare function useKeyboardControls<T extends string = string>(): [
+    StoreApiWithSubscribeWithSelector<KeyboardControlsState<T>>['subscribe'],
+    StoreApiWithSubscribeWithSelector<KeyboardControlsState<T>>['getState']
+];
 declare function useKeyboardControls<T extends string = string>(sel: Selector<T>): ReturnType<Selector<T>>;
-//#endregion
-//#region src/core/Controls/MapControls/MapControls.d.ts
+
 type MapControlsProps = Omit<Overwrite<ThreeElement<typeof MapControls$1>, {
-  target?: ReactThreeFiber.Vector3;
-  camera?: THREE$1.Camera;
-  makeDefault?: boolean;
-  onChange?: (e?: THREE$1.Event) => void;
-  onStart?: (e?: THREE$1.Event) => void;
-  onEnd?: (e?: THREE$1.Event) => void;
-  domElement?: HTMLElement;
+    target?: ReactThreeFiber.Vector3;
+    camera?: THREE.Camera;
+    makeDefault?: boolean;
+    onChange?: (e?: THREE.Event) => void;
+    onStart?: (e?: THREE.Event) => void;
+    onEnd?: (e?: THREE.Event) => void;
+    domElement?: HTMLElement;
 }>, 'ref' | 'args'>;
 declare const MapControls: ForwardRefComponent<MapControlsProps, MapControls$1>;
-//#endregion
-//#region src/core/Controls/MotionPathControls/MotionPathControls.d.ts
+
 type MotionPathProps = ThreeElements['group'] & {
-  curves?: THREE$1.Curve<THREE$1.Vector3>[];
-  debug?: boolean;
-  debugColor?: THREE$1.ColorRepresentation;
-  object?: React$1.RefObject<THREE$1.Object3D>;
-  focus?: [x: number, y: number, z: number] | React$1.RefObject<THREE$1.Object3D>;
-  loop?: boolean;
-  offset?: number;
-  smooth?: boolean | number;
-  eps?: number;
-  damping?: number;
-  focusDamping?: number;
-  maxSpeed?: number;
+    curves?: THREE.Curve<THREE.Vector3>[];
+    debug?: boolean;
+    debugColor?: THREE.ColorRepresentation;
+    object?: React.RefObject<THREE.Object3D>;
+    focus?: [x: number, y: number, z: number] | React.RefObject<THREE.Object3D>;
+    loop?: boolean;
+    offset?: number;
+    smooth?: boolean | number;
+    eps?: number;
+    damping?: number;
+    focusDamping?: number;
+    maxSpeed?: number;
 };
 type MotionState = {
-  current: number;
-  path: THREE$1.CurvePath<THREE$1.Vector3>;
-  focus: React$1.RefObject<THREE$1.Object3D> | [x: number, y: number, z: number] | undefined;
-  object: React$1.RefObject<THREE$1.Object3D>;
-  offset: number;
-  point: THREE$1.Vector3;
-  tangent: THREE$1.Vector3;
-  next: THREE$1.Vector3;
-};
-type MotionPathRef = THREE$1.Group & {
-  motion: MotionState;
+    current: number;
+    path: THREE.CurvePath<THREE.Vector3>;
+    focus: React.RefObject<THREE.Object3D> | [x: number, y: number, z: number] | undefined;
+    object: React.RefObject<THREE.Object3D>;
+    offset: number;
+    point: THREE.Vector3;
+    tangent: THREE.Vector3;
+    next: THREE.Vector3;
+};
+type MotionPathRef = THREE.Group & {
+    motion: MotionState;
 };
 declare function useMotion(): MotionState;
-declare const MotionPathControls: React$1.ForwardRefExoticComponent<Omit<MotionPathProps, "ref"> & React$1.RefAttributes<MotionPathRef>>;
-//#endregion
-//#region src/core/Controls/OrbitControls/OrbitControls.d.ts
+declare const MotionPathControls: React.ForwardRefExoticComponent<Omit<MotionPathProps, "ref"> & React.RefAttributes<MotionPathRef>>;
+
 type ExtractCallback<T, E extends string> = T extends {
-  addEventListener(event: E, callback: infer C): void;
+    addEventListener(event: E, callback: infer C): void;
 } ? C : never;
 type OrbitControlsChangeEvent = Parameters<ExtractCallback<OrbitControls$1, 'change'>>[0];
 type OrbitControlsProps = Omit<Overwrite<ThreeElement<typeof OrbitControls$1>, {
-  camera?: Camera;
-  domElement?: HTMLElement;
-  enableDamping?: boolean;
-  makeDefault?: boolean;
-  onChange?: (e?: OrbitControlsChangeEvent) => void;
-  onEnd?: (e?: Event) => void;
-  onStart?: (e?: Event) => void;
-  regress?: boolean;
-  target?: ReactThreeFiber.Vector3;
-  keyEvents?: boolean | HTMLElement;
+    camera?: Camera;
+    domElement?: HTMLElement;
+    enableDamping?: boolean;
+    makeDefault?: boolean;
+    onChange?: (e?: OrbitControlsChangeEvent) => void;
+    onEnd?: (e?: Event) => void;
+    onStart?: (e?: Event) => void;
+    regress?: boolean;
+    target?: ReactThreeFiber.Vector3;
+    keyEvents?: boolean | HTMLElement;
 }>, 'ref' | 'args'>;
 declare const OrbitControls: ForwardRefComponent<OrbitControlsProps, OrbitControls$1>;
-//#endregion
-//#region src/core/Controls/PointerLockControls/PointerLockControls.d.ts
+
 type PointerLockControlsProps = Omit<ThreeElement<typeof PointerLockControls$1>, 'ref' | 'args'> & {
-  domElement?: HTMLElement;
-  selector?: string;
-  enabled?: boolean;
-  camera?: THREE$1.Camera;
-  onChange?: (e?: THREE$1.Event) => void;
-  onLock?: (e?: THREE$1.Event) => void;
-  onUnlock?: (e?: THREE$1.Event) => void;
-  makeDefault?: boolean;
+    domElement?: HTMLElement;
+    selector?: string;
+    enabled?: boolean;
+    camera?: THREE.Camera;
+    onChange?: (e?: THREE.Event) => void;
+    onLock?: (e?: THREE.Event) => void;
+    onUnlock?: (e?: THREE.Event) => void;
+    makeDefault?: boolean;
 };
 declare const PointerLockControls: ForwardRefComponent<PointerLockControlsProps, PointerLockControls$1>;
-//#endregion
-//#region src/core/Controls/PresentationControls/PresentationControls.d.ts
+
 type PresentationControlProps = {
-  snap?: Boolean | number;
-  global?: boolean;
-  cursor?: boolean;
-  speed?: number;
-  zoom?: number;
-  rotation?: [number, number, number];
-  polar?: [number, number];
-  azimuth?: [number, number];
-  damping?: number;
-  enabled?: boolean;
-  children?: React$1.ReactNode;
-  domElement?: HTMLElement;
-};
-declare function PresentationControls({
-  enabled,
-  snap,
-  global,
-  domElement,
-  cursor,
-  children,
-  speed,
-  rotation,
-  zoom,
-  polar,
-  azimuth,
-  damping
-}: PresentationControlProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Controls/ScrollControls/ScrollControls.d.ts
+    snap?: Boolean | number;
+    global?: boolean;
+    cursor?: boolean;
+    speed?: number;
+    zoom?: number;
+    rotation?: [number, number, number];
+    polar?: [number, number];
+    azimuth?: [number, number];
+    damping?: number;
+    enabled?: boolean;
+    children?: React.ReactNode;
+    domElement?: HTMLElement;
+};
+declare function PresentationControls({ enabled, snap, global, domElement, cursor, children, speed, rotation, zoom, polar, azimuth, damping, }: PresentationControlProps): React.JSX.Element;
+
 type ScrollControlsProps = {
-  eps?: number;
-  horizontal?: boolean;
-  infinite?: boolean;
-  pages?: number;
-  distance?: number;
-  damping?: number;
-  maxSpeed?: number;
-  prepend?: boolean;
-  enabled?: boolean;
-  style?: React$1.CSSProperties;
-  children: React$1.ReactNode;
+    eps?: number;
+    horizontal?: boolean;
+    infinite?: boolean;
+    pages?: number;
+    distance?: number;
+    damping?: number;
+    maxSpeed?: number;
+    prepend?: boolean;
+    enabled?: boolean;
+    style?: React.CSSProperties;
+    children: React.ReactNode;
 };
 type ScrollControlsState = {
-  el: HTMLDivElement;
-  eps: number;
-  fill: HTMLDivElement;
-  fixed: HTMLDivElement;
-  horizontal: boolean | undefined;
-  damping: number;
-  offset: number;
-  delta: number;
-  pages: number;
-  range(from: number, distance: number, margin?: number): number;
-  curve(from: number, distance: number, margin?: number): number;
-  visible(from: number, distance: number, margin?: number): boolean;
+    el: HTMLDivElement;
+    eps: number;
+    fill: HTMLDivElement;
+    fixed: HTMLDivElement;
+    horizontal: boolean | undefined;
+    damping: number;
+    offset: number;
+    delta: number;
+    pages: number;
+    range(from: number, distance: number, margin?: number): number;
+    curve(from: number, distance: number, margin?: number): number;
+    visible(from: number, distance: number, margin?: number): boolean;
 };
 declare function useScroll(): ScrollControlsState;
-declare function ScrollControls({
-  eps,
-  enabled,
-  infinite,
-  horizontal,
-  pages,
-  distance,
-  damping,
-  maxSpeed,
-  prepend,
-  style,
-  children
-}: ScrollControlsProps): React$1.JSX.Element;
+declare function ScrollControls({ eps, enabled, infinite, horizontal, pages, distance, damping, maxSpeed, prepend, style, children, }: ScrollControlsProps): React.JSX.Element;
 interface ScrollPropsWithFalseHtml {
-  children?: React$1.ReactNode;
-  html?: false;
-  style?: never;
+    children?: React.ReactNode;
+    html?: false;
+    style?: never;
 }
 interface ScrollPropsWithTrueHtml {
-  children?: React$1.ReactNode;
-  html: true;
-  style?: React$1.CSSProperties;
+    children?: React.ReactNode;
+    html: true;
+    style?: React.CSSProperties;
 }
 type ScrollProps = ScrollPropsWithFalseHtml | ScrollPropsWithTrueHtml;
-declare const Scroll: ForwardRefComponent<ScrollProps, THREE$1.Group & HTMLDivElement>;
-//#endregion
-//#region src/core/Controls/TrackballControls/TrackballControls.d.ts
+declare const Scroll: ForwardRefComponent<ScrollProps, THREE.Group & HTMLDivElement>;
+
 type TrackballControlsProps = Omit<Overwrite<ThreeElement<typeof TrackballControls$1>, {
-  target?: ReactThreeFiber.Vector3;
-  camera?: THREE$1.Camera;
-  domElement?: HTMLElement;
-  regress?: boolean;
-  makeDefault?: boolean;
-  onChange?: (e?: THREE$1.Event) => void;
-  onStart?: (e?: THREE$1.Event) => void;
-  onEnd?: (e?: THREE$1.Event) => void;
+    target?: ReactThreeFiber.Vector3;
+    camera?: THREE.Camera;
+    domElement?: HTMLElement;
+    regress?: boolean;
+    makeDefault?: boolean;
+    onChange?: (e?: THREE.Event) => void;
+    onStart?: (e?: THREE.Event) => void;
+    onEnd?: (e?: THREE.Event) => void;
 }>, 'ref' | 'args'>;
 declare const TrackballControls: ForwardRefComponent<TrackballControlsProps, TrackballControls$1>;
-//#endregion
-//#region src/core/Effects/CameraShake/CameraShake.d.ts
+
 interface ShakeController {
-  getIntensity: () => number;
-  setIntensity: (val: number) => void;
+    getIntensity: () => number;
+    setIntensity: (val: number) => void;
 }
 interface CameraShakeProps {
-  intensity?: number;
-  decay?: boolean;
-  decayRate?: number;
-  maxYaw?: number;
-  maxPitch?: number;
-  maxRoll?: number;
-  yawFrequency?: number;
-  pitchFrequency?: number;
-  rollFrequency?: number;
+    intensity?: number;
+    decay?: boolean;
+    decayRate?: number;
+    maxYaw?: number;
+    maxPitch?: number;
+    maxRoll?: number;
+    yawFrequency?: number;
+    pitchFrequency?: number;
+    rollFrequency?: number;
 }
 declare const CameraShake: ForwardRefComponent<CameraShakeProps, ShakeController | undefined>;
-//#endregion
-//#region src/core/Effects/Cloud/Cloud.d.ts
+
 type CloudState = {
-  uuid: string;
-  index: number;
-  segments: number;
-  dist: number;
-  matrix: Matrix4;
-  bounds: Vector3$2;
-  position: Vector3$2;
-  volume: number;
-  length: number;
-  ref: React$1.RefObject<Group>;
-  speed: number;
-  growth: number;
-  opacity: number;
-  fade: number;
-  density: number;
-  rotation: number;
-  rotationFactor: number;
-  color: Color$2;
+    uuid: string;
+    index: number;
+    segments: number;
+    dist: number;
+    matrix: Matrix4;
+    bounds: Vector3$1;
+    position: Vector3$1;
+    volume: number;
+    length: number;
+    ref: React.RefObject<Group>;
+    speed: number;
+    growth: number;
+    opacity: number;
+    fade: number;
+    density: number;
+    rotation: number;
+    rotationFactor: number;
+    color: Color;
 };
 type CloudsProps = Omit<ThreeElements['group'], 'ref'> & {
-  texture?: string;
-  limit?: number;
-  range?: number;
-  material?: typeof Material;
-  materialFactory?: (baseMaterial: typeof Material) => Material;
-  frustumCulled?: boolean;
+    texture?: string;
+    limit?: number;
+    range?: number;
+    material?: typeof Material;
+    materialFactory?: (baseMaterial: typeof Material) => Material;
+    frustumCulled?: boolean;
 };
 type CloudProps = Omit<ThreeElements['group'], 'ref'> & {
-  seed?: number;
-  segments?: number;
-  bounds?: ReactThreeFiber.Vector3;
-  concentrate?: 'random' | 'inside' | 'outside';
-  scale?: ReactThreeFiber.Vector3;
-  volume?: number;
-  smallestVolume?: number;
-  distribute?: (cloud: CloudState, index: number) => {
-    point: Vector3$2;
+    seed?: number;
+    segments?: number;
+    bounds?: ReactThreeFiber.Vector3;
+    concentrate?: 'random' | 'inside' | 'outside';
+    scale?: ReactThreeFiber.Vector3;
     volume?: number;
-  };
-  growth?: number;
-  speed?: number;
-  fade?: number;
-  opacity?: number;
-  color?: ReactThreeFiber.Color;
-};
-declare const Clouds: React$1.ForwardRefExoticComponent<Omit<CloudsProps, "ref"> & React$1.RefAttributes<Group<THREE.Object3DEventMap>>>;
-declare const CloudInstance: React$1.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React$1.RefAttributes<Group<THREE.Object3DEventMap>>>;
-declare const Cloud: React$1.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React$1.RefAttributes<Group<THREE.Object3DEventMap>>>;
-//#endregion
-//#region src/core/Geometry/CatmullRomLine/CatmullRomLine.d.ts
+    smallestVolume?: number;
+    distribute?: (cloud: CloudState, index: number) => {
+        point: Vector3$1;
+        volume?: number;
+    };
+    growth?: number;
+    speed?: number;
+    fade?: number;
+    opacity?: number;
+    color?: ReactThreeFiber.Color;
+};
+declare const Clouds: React.ForwardRefExoticComponent<Omit<CloudsProps, "ref"> & React.RefAttributes<Group<THREE.Object3DEventMap>>>;
+declare const CloudInstance: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group<THREE.Object3DEventMap>>>;
+declare const Cloud: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group<THREE.Object3DEventMap>>>;
+
 type CatmullRomLineProps = Omit<LineProps, 'ref' | 'segments'> & {
-  closed?: boolean;
-  curveType?: 'centripetal' | 'chordal' | 'catmullrom';
-  tension?: number;
-  segments?: number;
-  LineComponent?: React$1.ComponentType<LineProps>;
+    closed?: boolean;
+    curveType?: 'centripetal' | 'chordal' | 'catmullrom';
+    tension?: number;
+    segments?: number;
+    LineComponent?: React.ComponentType<LineProps>;
 };
 declare const CatmullRomLine: ForwardRefComponent<CatmullRomLineProps, Line2>;
-//#endregion
-//#region src/core/Geometry/CubicBezierLine/CubicBezierLine.d.ts
+
 type CubicBezierLineProps = Omit<LineProps, 'points' | 'ref'> & {
-  start: Vector3$2 | [number, number, number];
-  end: Vector3$2 | [number, number, number];
-  midA: Vector3$2 | [number, number, number];
-  midB: Vector3$2 | [number, number, number];
-  segments?: number;
-  LineComponent?: React$1.ComponentType<LineProps>;
+    start: Vector3$1 | [number, number, number];
+    end: Vector3$1 | [number, number, number];
+    midA: Vector3$1 | [number, number, number];
+    midB: Vector3$1 | [number, number, number];
+    segments?: number;
+    LineComponent?: React.ComponentType<LineProps>;
 };
 declare const CubicBezierLine: ForwardRefComponent<CubicBezierLineProps, Line2>;
-//#endregion
-//#region src/core/Geometry/CurveModifier/CurveModifier.d.ts
+
 interface CurveModifierProps {
-  children: React$1.ReactElement<ThreeElements['mesh']>;
-  curve?: THREE$1.Curve<THREE$1.Vector3>;
+    children: React.ReactElement<ThreeElements['mesh']>;
+    curve?: THREE.Curve<THREE.Vector3>;
 }
 type CurveModifierRef = Flow;
 declare const CurveModifier: ForwardRefComponent<CurveModifierProps, CurveModifierRef>;
-//#endregion
-//#region src/core/Geometry/Decal/Decal.d.ts
-type DecalProps = Omit<FIBER.ThreeElements['mesh'], 'ref' | 'children'> & {
-  debug?: boolean;
-  mesh?: React$1.RefObject<THREE$1.Mesh>;
-  position?: FIBER.Vector3;
-  rotation?: FIBER.Euler | number;
-  scale?: FIBER.Vector3;
-  map?: THREE$1.Texture;
-  children?: React$1.ReactNode;
-  polygonOffsetFactor?: number;
-  depthTest?: boolean;
-};
-declare const Decal: ForwardRefComponent<DecalProps, THREE$1.Mesh>;
-//#endregion
-//#region src/core/Geometry/Detailed/Detailed.d.ts
+
+type DecalProps = Omit<_react_three_fiber.ThreeElements['mesh'], 'ref' | 'children'> & {
+    debug?: boolean;
+    mesh?: React.RefObject<THREE.Mesh>;
+    position?: _react_three_fiber.Vector3;
+    rotation?: _react_three_fiber.Euler | number;
+    scale?: _react_three_fiber.Vector3;
+    map?: THREE.Texture;
+    children?: React.ReactNode;
+    polygonOffsetFactor?: number;
+    depthTest?: boolean;
+};
+declare const Decal: ForwardRefComponent<DecalProps, THREE.Mesh>;
+
 type DetailedProps = Omit<ThreeElements['lOD'], 'ref'> & {
-  children: React$1.ReactElement<Object3D$1>[];
-  hysteresis?: number;
-  distances: number[];
+    children: React.ReactElement<Object3D>[];
+    hysteresis?: number;
+    distances: number[];
 };
 declare const Detailed: ForwardRefComponent<DetailedProps, LOD>;
-//#endregion
-//#region src/core/Geometry/Edges/Edges.d.ts
+
 interface EdgesProps {
-  threshold?: number;
-  geometry?: THREE$1.BufferGeometry;
-  lineWidth?: number;
-  color?: THREE$1.ColorRepresentation;
-  scale?: number;
-  LineComponent?: React$1.ComponentType<LineProps>;
+    threshold?: number;
+    geometry?: THREE.BufferGeometry;
+    lineWidth?: number;
+    color?: THREE.ColorRepresentation;
+    scale?: number;
+    LineComponent?: React.ComponentType<LineProps>;
 }
 interface EdgesRef {
-  computeLineDistances: () => void;
+    computeLineDistances: () => void;
 }
 declare const Edges: ForwardRefComponent<EdgesProps, EdgesRef>;
-//#endregion
-//#region src/core/Geometry/Points/Points.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    positionPoint: ThreeElement<typeof PositionPoint>;
-  }
+    interface ThreeElements {
+        positionPoint: ThreeElement<typeof PositionPoint>;
+    }
 }
 type PointsInstancesProps = Omit<ThreeElements['points'], 'ref'> & {
-  range?: number;
-  limit?: number;
-};
-declare class PositionPoint extends THREE$1.Group {
-  size: number;
-  color: THREE$1.Color;
-  instance: React$1.RefObject<THREE$1.Points | undefined>;
-  instanceKey: React$1.RefObject<PositionPoint | undefined>;
-  constructor();
-  get geometry(): THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap> | undefined;
-  raycast(raycaster: THREE$1.Raycaster, intersects: THREE$1.Intersection[]): void;
+    range?: number;
+    limit?: number;
+};
+declare class PositionPoint extends THREE.Group {
+    size: number;
+    color: THREE.Color;
+    instance: React.RefObject<THREE.Points | undefined>;
+    instanceKey: React.RefObject<PositionPoint | undefined>;
+    constructor();
+    get geometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
 }
 declare const Point: ForwardRefComponent<ThreeElements['positionPoint'], PositionPoint>;
 type PointsBuffersProps = ThreeElements['points'] & {
-  positions: Float32Array;
-  colors?: Float32Array;
-  sizes?: Float32Array;
-  stride?: 2 | 3;
-};
-declare const PointsBuffer: ForwardRefComponent<PointsBuffersProps, THREE$1.Points>;
-declare const Points: ForwardRefComponent<PointsBuffersProps | PointsInstancesProps, THREE$1.Points>;
-//#endregion
-//#region src/core/Geometry/QuadraticBezierLine/QuadraticBezierLine.d.ts
+    positions: Float32Array;
+    colors?: Float32Array;
+    sizes?: Float32Array;
+    stride?: 2 | 3;
+};
+declare const PointsBuffer: ForwardRefComponent<PointsBuffersProps, THREE.Points>;
+declare const Points: ForwardRefComponent<PointsBuffersProps | PointsInstancesProps, THREE.Points>;
+
 type QuadraticBezierLineRef = Line2 & {
-  setPoints(start: Vector3$2 | [number, number, number], end: Vector3$2 | [number, number, number], mid: Vector3$2 | [number, number, number]): void;
+    setPoints(start: Vector3$1 | [number, number, number], end: Vector3$1 | [number, number, number], mid: Vector3$1 | [number, number, number]): void;
 };
 type QuadraticBezierLineProps = Omit<LineProps, 'points' | 'ref'> & {
-  start: Vector3$2 | [number, number, number];
-  end: Vector3$2 | [number, number, number];
-  mid?: Vector3$2 | [number, number, number];
-  segments?: number;
-  LineComponent?: React$1.ComponentType<LineProps>;
+    start: Vector3$1 | [number, number, number];
+    end: Vector3$1 | [number, number, number];
+    mid?: Vector3$1 | [number, number, number];
+    segments?: number;
+    LineComponent?: React.ComponentType<LineProps>;
 };
 declare const QuadraticBezierLine: ForwardRefComponent<QuadraticBezierLineProps, QuadraticBezierLineRef>;
-//#endregion
-//#region src/core/Geometry/RoundedBox/RoundedBox.d.ts
+
 type RoundedBoxProps = {
-  args?: NamedArrayTuple<(width?: number, height?: number, depth?: number) => void>;
-  radius?: number;
-  smoothness?: number;
-  bevelSegments?: number;
-  steps?: number;
-  creaseAngle?: number;
+    args?: NamedArrayTuple<(width?: number, height?: number, depth?: number) => void>;
+    radius?: number;
+    smoothness?: number;
+    bevelSegments?: number;
+    steps?: number;
+    creaseAngle?: number;
 } & Omit<ThreeElements['mesh'], 'ref' | 'args'>;
 type RoundedBoxGeometryProps = Omit<RoundedBoxProps, 'children'> & Omit<ThreeElements['extrudeGeometry'], 'args' | 'ref'>;
-declare const RoundedBox: ForwardRefComponent<RoundedBoxProps, Mesh$1>;
+declare const RoundedBox: ForwardRefComponent<RoundedBoxProps, Mesh>;
 declare const RoundedBoxGeometry: ForwardRefComponent<RoundedBoxGeometryProps, ExtrudeGeometry>;
-//#endregion
-//#region src/core/Geometry/ScreenQuad/ScreenQuad.d.ts
+
 type ScreenQuadProps = Omit<ThreeElements['mesh'], 'ref' | 'args'>;
-declare const ScreenQuad: ForwardRefComponent<ScreenQuadProps, THREE$1.Mesh>;
-//#endregion
-//#region src/core/Geometry/Shapes/shapes.d.ts
-type Args<T> = T extends (new (...args: any) => any) ? ConstructorParameters<T> : T;
+declare const ScreenQuad: ForwardRefComponent<ScreenQuadProps, THREE.Mesh>;
+
+type Args<T> = T extends new (...args: any) => any ? ConstructorParameters<T> : T;
 type ShapeProps<T> = Omit<ThreeElements['mesh'], 'ref' | 'args'> & {
-  args?: Args<T>;
-};
-declare const Box: ForwardRefComponent<ShapeProps<typeof THREE$1.BoxGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Circle: ForwardRefComponent<ShapeProps<typeof THREE$1.CircleGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Cone: ForwardRefComponent<ShapeProps<typeof THREE$1.ConeGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Cylinder: ForwardRefComponent<ShapeProps<typeof THREE$1.CylinderGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Sphere: ForwardRefComponent<ShapeProps<typeof THREE$1.SphereGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Plane: ForwardRefComponent<ShapeProps<typeof THREE$1.PlaneGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Tube: ForwardRefComponent<ShapeProps<typeof THREE$1.TubeGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Torus: ForwardRefComponent<ShapeProps<typeof THREE$1.TorusGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const TorusKnot: ForwardRefComponent<ShapeProps<typeof THREE$1.TorusKnotGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Tetrahedron: ForwardRefComponent<ShapeProps<typeof THREE$1.TetrahedronGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Ring: ForwardRefComponent<ShapeProps<typeof THREE$1.RingGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Polyhedron: ForwardRefComponent<ShapeProps<typeof THREE$1.PolyhedronGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Icosahedron: ForwardRefComponent<ShapeProps<typeof THREE$1.IcosahedronGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Octahedron: ForwardRefComponent<ShapeProps<typeof THREE$1.OctahedronGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Dodecahedron: ForwardRefComponent<ShapeProps<typeof THREE$1.DodecahedronGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Extrude: ForwardRefComponent<ShapeProps<typeof THREE$1.ExtrudeGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Lathe: ForwardRefComponent<ShapeProps<typeof THREE$1.LatheGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Capsule: ForwardRefComponent<ShapeProps<typeof THREE$1.CapsuleGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-declare const Shape: ForwardRefComponent<ShapeProps<typeof THREE$1.ShapeGeometry>, THREE$1.Mesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.Object3DEventMap>>;
-//#endregion
-//#region src/core/Loaders/useFont/useFont.d.ts
+    args?: Args<T>;
+};
+declare const Box: ForwardRefComponent<ShapeProps<typeof THREE.BoxGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Circle: ForwardRefComponent<ShapeProps<typeof THREE.CircleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Cone: ForwardRefComponent<ShapeProps<typeof THREE.ConeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Cylinder: ForwardRefComponent<ShapeProps<typeof THREE.CylinderGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Sphere: ForwardRefComponent<ShapeProps<typeof THREE.SphereGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Plane: ForwardRefComponent<ShapeProps<typeof THREE.PlaneGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Tube: ForwardRefComponent<ShapeProps<typeof THREE.TubeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Torus: ForwardRefComponent<ShapeProps<typeof THREE.TorusGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const TorusKnot: ForwardRefComponent<ShapeProps<typeof THREE.TorusKnotGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Tetrahedron: ForwardRefComponent<ShapeProps<typeof THREE.TetrahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Ring: ForwardRefComponent<ShapeProps<typeof THREE.RingGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Polyhedron: ForwardRefComponent<ShapeProps<typeof THREE.PolyhedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Icosahedron: ForwardRefComponent<ShapeProps<typeof THREE.IcosahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Octahedron: ForwardRefComponent<ShapeProps<typeof THREE.OctahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Dodecahedron: ForwardRefComponent<ShapeProps<typeof THREE.DodecahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Extrude: ForwardRefComponent<ShapeProps<typeof THREE.ExtrudeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Lathe: ForwardRefComponent<ShapeProps<typeof THREE.LatheGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Capsule: ForwardRefComponent<ShapeProps<typeof THREE.CapsuleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Shape: ForwardRefComponent<ShapeProps<typeof THREE.ShapeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+
 type Glyph = {
-  _cachedOutline: string[];
-  ha: number;
-  o: string;
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
 };
 type FontData = {
-  boundingBox: {
-    yMax: number;
-    yMin: number;
-  };
-  familyName: string;
-  glyphs: {
-    [k: string]: Glyph;
-  };
-  resolution: number;
-  underlineThickness: number;
-  ascender?: number;
-  descender?: number;
-  underlinePosition?: number;
-  original_font_information?: Record<string, unknown>;
+    boundingBox: {
+        yMax: number;
+        yMin: number;
+    };
+    familyName: string;
+    glyphs: {
+        [k: string]: Glyph;
+    };
+    resolution: number;
+    underlineThickness: number;
+    ascender?: number;
+    descender?: number;
+    underlinePosition?: number;
+    original_font_information?: Record<string, unknown>;
 };
 type FontInput = string | FontData;
-declare function useFont(font: FontInput): three_examples_jsm_loaders_FontLoader0.Font;
+declare function useFont(font: FontInput): three_examples_jsm_loaders_FontLoader_js.Font;
 declare namespace useFont {
-  var preload: (font: FontInput) => undefined;
-  var clear: (font: FontInput) => void;
+    var preload: (font: FontInput) => undefined;
+    var clear: (font: FontInput) => void;
 }
-//#endregion
-//#region src/core/Geometry/Text3D/Text3D.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    renamedTextGeometry: ThreeElement<typeof TextGeometry>;
-  }
+    interface ThreeElements {
+        renamedTextGeometry: ThreeElement<typeof TextGeometry>;
+    }
 }
 type Text3DProps = Omit<ThreeElements['mesh'], 'ref'> & {
-  font: FontData | string;
-  bevelSegments?: number;
-  smooth?: number;
+    font: FontData | string;
+    bevelSegments?: number;
+    smooth?: number;
 } & Omit<TextGeometryParameters, 'font'>;
-declare const Text3D: ForwardRefComponent<React$1.PropsWithChildren<Text3DProps & {
-  letterSpacing?: number;
-  lineHeight?: number;
-}>, THREE$1.Mesh>;
-//#endregion
-//#region src/legacy/Materials/WireframeMaterial/WireframeMaterial.d.ts
-interface WireframeMaterialProps extends THREE$1.ShaderMaterialParameters {
-  fillOpacity?: number;
-  fillMix?: number;
-  strokeOpacity?: number;
-  thickness?: number;
-  colorBackfaces?: boolean;
-  dashInvert?: boolean;
-  dash?: boolean;
-  dashRepeats?: number;
-  dashLength?: number;
-  squeeze?: boolean;
-  squeezeMin?: number;
-  squeezeMax?: number;
-  stroke?: THREE$1.ColorRepresentation;
-  backfaceStroke?: THREE$1.ColorRepresentation;
-  fill?: THREE$1.ColorRepresentation;
+declare const Text3D: ForwardRefComponent<React.PropsWithChildren<Text3DProps & {
+    letterSpacing?: number;
+    lineHeight?: number;
+}>, THREE.Mesh>;
+
+interface WireframeMaterialProps extends THREE.ShaderMaterialParameters {
+    fillOpacity?: number;
+    fillMix?: number;
+    strokeOpacity?: number;
+    thickness?: number;
+    colorBackfaces?: boolean;
+    dashInvert?: boolean;
+    dash?: boolean;
+    dashRepeats?: number;
+    dashLength?: number;
+    squeeze?: boolean;
+    squeezeMin?: number;
+    squeezeMax?: number;
+    stroke?: THREE.ColorRepresentation;
+    backfaceStroke?: THREE.ColorRepresentation;
+    fill?: THREE.ColorRepresentation;
 }
-declare const WireframeMaterial: FIBER.ConstructorRepresentation<THREE$1.ShaderMaterial & {
-  strokeOpacity: number;
-  fillOpacity: number;
-  fillMix: number;
-  thickness: number;
-  colorBackfaces: boolean;
-  dashInvert: boolean;
-  dash: boolean;
-  dashRepeats: number;
-  dashLength: number;
-  squeeze: boolean;
-  squeezeMin: number;
-  squeezeMax: number;
-  stroke: THREE$1.Color;
-  backfaceStroke: THREE$1.Color;
-  fill: THREE$1.Color;
+declare const WireframeMaterial: _react_three_fiber.ConstructorRepresentation<THREE.ShaderMaterial & {
+    strokeOpacity: number;
+    fillOpacity: number;
+    fillMix: number;
+    thickness: number;
+    colorBackfaces: boolean;
+    dashInvert: boolean;
+    dash: boolean;
+    dashRepeats: number;
+    dashLength: number;
+    squeeze: boolean;
+    squeezeMin: number;
+    squeezeMax: number;
+    stroke: THREE.Color;
+    backfaceStroke: THREE.Color;
+    fill: THREE.Color;
 }> & {
-  key: string;
+    key: string;
 };
-//#endregion
-//#region src/core/Geometry/Wireframe/Wireframe.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    meshWireframeMaterial: ThreeElement<typeof WireframeMaterial>;
-  }
+    interface ThreeElements {
+        meshWireframeMaterial: ThreeElement<typeof WireframeMaterial>;
+    }
 }
 interface WireframeProps {
-  geometry?: THREE$1.BufferGeometry | React$1.RefObject<THREE$1.BufferGeometry>;
-  simplify?: boolean;
+    geometry?: THREE.BufferGeometry | React.RefObject<THREE.BufferGeometry>;
+    simplify?: boolean;
 }
-declare function Wireframe({
-  geometry: customGeometry,
-  ...props
-}: WireframeProps & WireframeMaterialProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Gizmos/gizmo/GizmoHelper.d.ts
+declare function Wireframe({ geometry: customGeometry, ...props }: WireframeProps & WireframeMaterialProps): React.JSX.Element;
+
 type GizmoHelperContext = {
-  tweenCamera: (direction: Vector3$2) => void;
+    tweenCamera: (direction: Vector3$1) => void;
 };
 declare const useGizmoContext: () => GizmoHelperContext;
 type GizmoHelperProps = ThreeElements['group'] & {
-  alignment?: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center';
-  margin?: [number, number];
-  renderPriority?: number;
-  autoClear?: boolean;
-  onUpdate?: () => void;
-  onTarget?: () => Vector3$2;
-};
-declare const GizmoHelper: ({
-  alignment,
-  margin,
-  renderPriority,
-  onUpdate,
-  onTarget,
-  children
-}: GizmoHelperProps) => any;
-//#endregion
-//#region src/core/Gizmos/gizmo/GizmoViewcube.d.ts
+    alignment?: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center';
+    margin?: [number, number];
+    renderPriority?: number;
+    autoClear?: boolean;
+    onUpdate?: () => void;
+    onTarget?: () => Vector3$1;
+};
+declare const GizmoHelper: ({ alignment, margin, renderPriority, onUpdate, onTarget, children, }: GizmoHelperProps) => any;
+
 type GenericProps = {
-  font?: string;
-  opacity?: number;
-  color?: string;
-  hoverColor?: string;
-  textColor?: string;
-  strokeColor?: string;
-  onClick?: (e: ThreeEvent<MouseEvent>) => null;
-  faces?: string[];
-};
-declare const GizmoViewcube: (props: GenericProps) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Gizmos/gizmo/GizmoViewport.d.ts
+    font?: string;
+    opacity?: number;
+    color?: string;
+    hoverColor?: string;
+    textColor?: string;
+    strokeColor?: string;
+    onClick?: (e: ThreeEvent<MouseEvent>) => null;
+    faces?: string[];
+};
+declare const GizmoViewcube: (props: GenericProps) => React.JSX.Element;
+
 type GizmoViewportProps = ThreeElements['group'] & {
-  axisColors?: [string, string, string];
-  axisScale?: [number, number, number];
-  labels?: [string, string, string];
-  axisHeadScale?: number;
-  labelColor?: string;
-  hideNegativeAxes?: boolean;
-  hideAxisHeads?: boolean;
-  disabled?: boolean;
-  font?: string;
-  onClick?: (e: ThreeEvent<MouseEvent>) => null;
-};
-declare const GizmoViewport: ({
-  hideNegativeAxes,
-  hideAxisHeads,
-  disabled,
-  font,
-  axisColors,
-  axisHeadScale,
-  axisScale,
-  labels,
-  labelColor,
-  onClick,
-  ...props
-}: GizmoViewportProps) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Gizmos/PivotControls/context.d.ts
+    axisColors?: [string, string, string];
+    axisScale?: [number, number, number];
+    labels?: [string, string, string];
+    axisHeadScale?: number;
+    labelColor?: string;
+    hideNegativeAxes?: boolean;
+    hideAxisHeads?: boolean;
+    disabled?: boolean;
+    font?: string;
+    onClick?: (e: ThreeEvent<MouseEvent>) => null;
+};
+declare const GizmoViewport: ({ hideNegativeAxes, hideAxisHeads, disabled, font, axisColors, axisHeadScale, axisScale, labels, labelColor, onClick, ...props }: GizmoViewportProps) => React.JSX.Element;
+
 type OnDragStartProps = {
-  component: 'Arrow' | 'Slider' | 'Rotator' | 'Sphere';
-  axis: 0 | 1 | 2;
-  origin: THREE$1.Vector3;
-  directions: THREE$1.Vector3[];
+    component: 'Arrow' | 'Slider' | 'Rotator' | 'Sphere';
+    axis: 0 | 1 | 2;
+    origin: THREE.Vector3;
+    directions: THREE.Vector3[];
 };
-//#endregion
-//#region src/core/Gizmos/PivotControls/index.d.ts
+
 type PivotControlsProps = {
-  enabled?: boolean;
-  scale?: number;
-  lineWidth?: number;
-  fixed?: boolean;
-  offset?: [number, number, number];
-  rotation?: [number, number, number];
-  matrix?: THREE$1.Matrix4;
-  anchor?: [number, number, number];
-  autoTransform?: boolean;
-  activeAxes?: [boolean, boolean, boolean];
-  disableAxes?: boolean;
-  disableSliders?: boolean;
-  disableRotations?: boolean;
-  disableScaling?: boolean;
-  translationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
-  rotationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
-  scaleLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
-  axisColors?: [string | number, string | number, string | number];
-  hoveredColor?: string | number;
-  annotations?: boolean;
-  annotationsClass?: string;
-  onDragStart?: (props: OnDragStartProps) => void;
-  onDrag?: (l: THREE$1.Matrix4, deltaL: THREE$1.Matrix4, w: THREE$1.Matrix4, deltaW: THREE$1.Matrix4) => void;
-  onDragEnd?: () => void;
-  depthTest?: boolean;
-  renderOrder?: number;
-  opacity?: number;
-  visible?: boolean;
-  userData?: {
-    [key: string]: any;
-  };
-  children?: React$1.ReactNode;
-  LineComponent?: React$1.ComponentType<LineProps>;
-};
-declare const PivotControls: ForwardRefComponent<PivotControlsProps, THREE$1.Group>;
-//#endregion
-//#region src/core/Gizmos/TransformControls/TransformControls.d.ts
+    enabled?: boolean;
+    scale?: number;
+    lineWidth?: number;
+    fixed?: boolean;
+    offset?: [number, number, number];
+    rotation?: [number, number, number];
+    matrix?: THREE.Matrix4;
+    anchor?: [number, number, number];
+    autoTransform?: boolean;
+    activeAxes?: [boolean, boolean, boolean];
+    disableAxes?: boolean;
+    disableSliders?: boolean;
+    disableRotations?: boolean;
+    disableScaling?: boolean;
+    translationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    rotationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    scaleLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    axisColors?: [string | number, string | number, string | number];
+    hoveredColor?: string | number;
+    annotations?: boolean;
+    annotationsClass?: string;
+    onDragStart?: (props: OnDragStartProps) => void;
+    onDrag?: (l: THREE.Matrix4, deltaL: THREE.Matrix4, w: THREE.Matrix4, deltaW: THREE.Matrix4) => void;
+    onDragEnd?: () => void;
+    depthTest?: boolean;
+    renderOrder?: number;
+    opacity?: number;
+    visible?: boolean;
+    userData?: {
+        [key: string]: any;
+    };
+    children?: React.ReactNode;
+    LineComponent?: React.ComponentType<LineProps>;
+};
+declare const PivotControls: ForwardRefComponent<PivotControlsProps, THREE.Group>;
+
 type TransformControlsProps = Omit<ThreeElement<typeof TransformControls$1>, 'ref' | 'args'> & Omit<ThreeElements['group'], 'ref'> & {
-  object?: THREE$1.Object3D | React$1.RefObject<THREE$1.Object3D>;
-  enabled?: boolean;
-  axis?: string | null;
-  domElement?: HTMLElement;
-  mode?: 'translate' | 'rotate' | 'scale';
-  translationSnap?: number | null;
-  rotationSnap?: number | null;
-  scaleSnap?: number | null;
-  space?: 'world' | 'local';
-  size?: number;
-  showX?: boolean;
-  showY?: boolean;
-  showZ?: boolean;
-  children?: React$1.ReactElement<THREE$1.Object3D>;
-  camera?: THREE$1.Camera;
-  onChange?: (e?: THREE$1.Event) => void;
-  onMouseDown?: (e?: THREE$1.Event) => void;
-  onMouseUp?: (e?: THREE$1.Event) => void;
-  onObjectChange?: (e?: THREE$1.Event) => void;
-  makeDefault?: boolean;
+    object?: THREE.Object3D | React.RefObject<THREE.Object3D>;
+    enabled?: boolean;
+    axis?: string | null;
+    domElement?: HTMLElement;
+    mode?: 'translate' | 'rotate' | 'scale';
+    translationSnap?: number | null;
+    rotationSnap?: number | null;
+    scaleSnap?: number | null;
+    space?: 'world' | 'local';
+    size?: number;
+    showX?: boolean;
+    showY?: boolean;
+    showZ?: boolean;
+    children?: React.ReactElement<THREE.Object3D>;
+    camera?: THREE.Camera;
+    onChange?: (e?: THREE.Event) => void;
+    onMouseDown?: (e?: THREE.Event) => void;
+    onMouseUp?: (e?: THREE.Event) => void;
+    onObjectChange?: (e?: THREE.Event) => void;
+    makeDefault?: boolean;
 };
 declare const TransformControls: ForwardRefComponent<TransformControlsProps, TransformControls$1>;
-//#endregion
-//#region src/core/Gizmos/useHelper/useHelper.d.ts
-type HelperType = Object3D$1 & {
-  update: () => void;
-  dispose: () => void;
+
+type HelperType = Object3D & {
+    update: () => void;
+    dispose: () => void;
 };
 type HelperConstructor = new (...args: any[]) => any;
 type HelperArgs<T> = T extends [infer _, ...infer R] ? R : never;
-declare function useHelper<T extends HelperConstructor>(object3D: React$1.RefObject<Object3D$1> | Falsey, helperConstructor: T, ...args: HelperArgs<ConstructorParameters<T>>): React$1.RefObject<HelperType | null>;
+declare function useHelper<T extends HelperConstructor>(object3D: React.RefObject<Object3D> | Falsey, helperConstructor: T, ...args: HelperArgs<ConstructorParameters<T>>): React.RefObject<HelperType | null>;
 type HelperProps<T extends HelperConstructor> = {
-  type: T;
-  args?: HelperArgs<ConstructorParameters<T>>;
-};
-declare const Helper: <T extends HelperConstructor>({
-  type: helperConstructor,
-  args
-}: HelperProps<T>) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Helpers/PointMaterial/PointMaterial.d.ts
-declare class PointMaterialImpl extends THREE$1.PointsMaterial {
-  constructor(props?: THREE$1.PointsMaterialParameters | null);
+    type: T;
+    args?: HelperArgs<ConstructorParameters<T>>;
+};
+declare const Helper: <T extends HelperConstructor>({ type: helperConstructor, args, }: HelperProps<T>) => React.JSX.Element;
+
+declare class PointMaterialImpl extends THREE.PointsMaterial {
+    constructor(props?: THREE.PointsMaterialParameters | null);
 }
 type PointMaterialProps = Omit<ThreeElements['pointsMaterial'], 'ref'>;
 declare const PointMaterial: ForwardRefComponent<PointMaterialProps, PointMaterialImpl>;
-//#endregion
-//#region src/core/Helpers/PositionalAudio/PositionalAudio.d.ts
+
 type PositionalAudioProps = Omit<ThreeElements['positionalAudio'], 'ref' | 'args'> & {
-  url: string;
-  distance?: number;
-  loop?: boolean;
+    url: string;
+    distance?: number;
+    loop?: boolean;
 };
 declare const PositionalAudio: ForwardRefComponent<PositionalAudioProps, PositionalAudio$1>;
-//#endregion
-//#region src/core/Helpers/Instances/Instances.d.ts
+
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    positionMesh: ThreeElement<typeof PositionMesh>;
-  }
+    interface ThreeElements {
+        positionMesh: ThreeElement<typeof PositionMesh>;
+    }
 }
 type Api$1 = {
-  getParent: () => React$1.RefObject<InstancedMesh$1>;
-  subscribe: <T>(ref: React$1.RefObject<T>) => void;
+    getParent: () => React.RefObject<InstancedMesh>;
+    subscribe: <T>(ref: React.RefObject<T>) => void;
 };
 type InstancesProps = Omit<ThreeElements['instancedMesh'], 'ref' | 'args'> & {
-  context?: React$1.Context<Api$1>;
-  range?: number;
-  limit?: number;
-  frames?: number;
+    context?: React.Context<Api$1>;
+    range?: number;
+    limit?: number;
+    frames?: number;
 };
 type InstanceProps = Omit<ThreeElements['positionMesh'], 'ref'> & {
-  context?: React$1.Context<Api$1>;
+    context?: React.Context<Api$1>;
 };
 type InstancedAttributeProps = Omit<ThreeElements['instancedBufferAttribute'], 'ref' | 'args'> & {
-  name: string;
-  defaultValue: any;
-  normalized?: boolean;
-  usage?: number;
-};
-type InstancedMesh$1 = Omit<THREE$1.InstancedMesh, 'instanceMatrix' | 'instanceColor'> & {
-  instanceMatrix: THREE$1.InstancedBufferAttribute;
-  instanceColor: THREE$1.InstancedBufferAttribute;
-};
-declare class PositionMesh extends THREE$1.Group {
-  color: THREE$1.Color;
-  instance: React$1.RefObject<THREE$1.InstancedMesh | undefined>;
-  instanceKey: React$1.RefObject<PositionMesh | undefined>;
-  constructor();
-  get geometry(): THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap> | undefined;
-  raycast(raycaster: THREE$1.Raycaster, intersects: THREE$1.Intersection[]): void;
+    name: string;
+    defaultValue: any;
+    normalized?: boolean;
+    usage?: number;
+};
+type InstancedMesh = Omit<THREE.InstancedMesh, 'instanceMatrix' | 'instanceColor'> & {
+    instanceMatrix: THREE.InstancedBufferAttribute;
+    instanceColor: THREE.InstancedBufferAttribute;
+};
+declare class PositionMesh extends THREE.Group {
+    color: THREE.Color;
+    instance: React.RefObject<THREE.InstancedMesh | undefined>;
+    instanceKey: React.RefObject<PositionMesh | undefined>;
+    constructor();
+    get geometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
 }
-declare const Instance: React$1.ForwardRefExoticComponent<Omit<FIBER.Mutable<FIBER.Overwrite<Partial<FIBER.Overwrite<PositionMesh, FIBER.MathProps<PositionMesh> & FIBER.ReactProps<PositionMesh> & Partial<FIBER.EventHandlers>>>, Omit<FIBER.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
-  context?: React$1.Context<Api$1>;
-} & React$1.RefAttributes<unknown>>;
-declare const Instances: ForwardRefComponent<InstancesProps, THREE$1.InstancedMesh>;
+declare const Instance: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
+    context?: React.Context<Api$1>;
+} & React.RefAttributes<unknown>>;
+declare const Instances: ForwardRefComponent<InstancesProps, THREE.InstancedMesh>;
 interface MergedProps extends Omit<InstancesProps, 'children'> {
-  meshes: THREE$1.Mesh[] | Record<string, THREE$1.Object3D>;
-  children: (...instances: [React$1.FC<InstanceProps> & Record<string, React$1.FC<InstanceProps>>, ...React$1.FC<InstanceProps>[]]) => React$1.ReactNode;
+    meshes: THREE.Mesh[] | Record<string, THREE.Object3D>;
+    children: (...instances: [React.FC<InstanceProps> & Record<string, React.FC<InstanceProps>>, ...React.FC<InstanceProps>[]]) => React.ReactNode;
 }
-declare const Merged: ForwardRefComponent<MergedProps, THREE$1.Group>;
-declare function createInstances<T = InstanceProps>(): readonly [React$1.ForwardRefExoticComponent<Omit<InstancesProps, "ref"> & React$1.RefAttributes<THREE$1.InstancedMesh<THREE$1.BufferGeometry<THREE$1.NormalBufferAttributes, THREE$1.BufferGeometryEventMap>, THREE$1.Material | THREE$1.Material[], THREE$1.InstancedMeshEventMap>>>, React$1.ForwardRefExoticComponent<React$1.PropsWithoutRef<T & Omit<FIBER.Mutable<FIBER.Overwrite<Partial<FIBER.Overwrite<PositionMesh, FIBER.MathProps<PositionMesh> & FIBER.ReactProps<PositionMesh> & Partial<FIBER.EventHandlers>>>, Omit<FIBER.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
-  context?: React$1.Context<Api$1>;
-}> & React$1.RefAttributes<PositionMesh & T>>];
-declare const InstancedAttribute: React$1.ForwardRefExoticComponent<Omit<InstancedAttributeProps, "ref"> & React$1.RefAttributes<THREE$1.InstancedBufferAttribute>>;
-//#endregion
-//#region src/core/Loaders/useSpriteLoader/useSpriteLoader.d.ts
+declare const Merged: ForwardRefComponent<MergedProps, THREE.Group>;
+declare function createInstances<T = InstanceProps>(): readonly [React.ForwardRefExoticComponent<Omit<InstancesProps, "ref"> & React.RefAttributes<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap>>>, React.ForwardRefExoticComponent<React.PropsWithoutRef<T & Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
+    context?: React.Context<Api$1>;
+}> & React.RefAttributes<PositionMesh & T>>];
+declare const InstancedAttribute: React.ForwardRefExoticComponent<Omit<InstancedAttributeProps, "ref"> & React.RefAttributes<THREE.InstancedBufferAttribute>>;
+
 type Size = {
-  w: number;
-  h: number;
-};
-type FrameData = {
-  frame: {
-    x: number;
-    y: number;
     w: number;
     h: number;
-  };
-  scaleRatio?: number;
-  rotated: boolean;
-  trimmed: boolean;
-  spriteSourceSize: {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-  };
-  sourceSize: Size;
+};
+type FrameData = {
+    frame: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    scaleRatio?: number;
+    rotated: boolean;
+    trimmed: boolean;
+    spriteSourceSize: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    sourceSize: Size;
 };
 type MetaData = {
-  version: string;
-  size: {
-    w: number;
-    h: number;
-  };
-  rows: number;
-  columns: number;
-  frameWidth: number;
-  frameHeight: number;
-  scale: string;
+    version: string;
+    size: {
+        w: number;
+        h: number;
+    };
+    rows: number;
+    columns: number;
+    frameWidth: number;
+    frameHeight: number;
+    scale: string;
 };
 type Frames = Record<string, FrameData[]> | FrameData[];
 type SpriteData = {
-  frames: Frames;
-  meta: MetaData;
+    frames: Frames;
+    meta: MetaData;
 };
 declare const getFirstFrame: (frames: SpriteData["frames"], frameName?: string) => FrameData;
 declare const checkIfFrameIsEmpty: (frameData: Uint8ClampedArray) => boolean;
-declare function useSpriteLoader<Url extends string>(input: Url | null, json?: string | null, animationNames?: string[] | null, numberOfFrames?: number | null, onLoad?: (texture: Texture$2, textureData?: SpriteData | null) => void, canvasRenderingContext2DSettings?: CanvasRenderingContext2DSettings): {
-  spriteObj: {
-    spriteTexture: THREE$1.Texture;
-    spriteData: SpriteData | null;
-    aspect: Vector3;
-  } | null;
-  loadJsonAndTexture: (textureUrl: string, jsonUrl?: string) => void;
+declare function useSpriteLoader<Url extends string>(input: Url | null, json?: string | null, animationNames?: string[] | null, numberOfFrames?: number | null, onLoad?: (texture: Texture$1, textureData?: SpriteData | null) => void, canvasRenderingContext2DSettings?: CanvasRenderingContext2DSettings): {
+    spriteObj: {
+        spriteTexture: THREE.Texture;
+        spriteData: SpriteData | null;
+        aspect: Vector3;
+    } | null;
+    loadJsonAndTexture: (textureUrl: string, jsonUrl?: string) => void;
 };
 declare namespace useSpriteLoader {
-  var preload: (url: string) => void;
-  var clear: (input: string) => void;
+    var preload: (url: string) => void;
+    var clear: (input: string) => void;
 }
-//#endregion
-//#region src/core/Helpers/SpriteAnimator/SpriteAnimator.d.ts
+
 type AnimationEventData = {
-  currentFrameName: string;
-  currentFrame: number;
+    currentFrameName: string;
+    currentFrame: number;
 };
 type CommonProps<T, U, V> = Pick<T & U & V, keyof T & keyof U & keyof V>;
-type CommonMeshProps = CommonProps<React$1.ComponentProps<'mesh'>, React$1.ComponentProps<typeof Instance>, React$1.ComponentProps<typeof Instances>>;
+type CommonMeshProps = CommonProps<React.ComponentProps<'mesh'>, React.ComponentProps<typeof Instance>, React.ComponentProps<typeof Instances>>;
 type SpriteAnimatorProps = {
-  startFrame?: number;
-  endFrame?: number;
-  fps?: number;
-  frameName?: string;
-  textureDataURL?: string;
-  textureImageURL?: string;
-  loop?: boolean;
-  numberOfFrames?: number;
-  autoPlay?: boolean;
-  animationNames?: Array<string>;
-  onStart?: (data: AnimationEventData) => void;
-  onEnd?: (data: AnimationEventData) => void;
-  onLoopEnd?: (data: AnimationEventData) => void;
-  onFrame?: (data: AnimationEventData) => void;
-  play?: boolean;
-  pause?: boolean;
-  flipX?: boolean;
-  alphaTest?: number;
-  asSprite?: boolean;
-  offset?: number;
-  playBackwards?: boolean;
-  resetOnEnd?: boolean;
-  instanceItems?: Vector3[];
-  maxItems?: number;
-  spriteDataset?: {
-    spriteTexture: THREE$1.Texture;
-    spriteData: SpriteData | null;
-    aspect: Vector3;
-  } | null;
-  canvasRenderingContext2DSettings?: CanvasRenderingContext2DSettings;
-  roundFramePosition?: boolean;
-  meshProps?: CommonMeshProps;
+    startFrame?: number;
+    endFrame?: number;
+    fps?: number;
+    frameName?: string;
+    textureDataURL?: string;
+    textureImageURL?: string;
+    loop?: boolean;
+    numberOfFrames?: number;
+    autoPlay?: boolean;
+    animationNames?: Array<string>;
+    onStart?: (data: AnimationEventData) => void;
+    onEnd?: (data: AnimationEventData) => void;
+    onLoopEnd?: (data: AnimationEventData) => void;
+    onFrame?: (data: AnimationEventData) => void;
+    play?: boolean;
+    pause?: boolean;
+    flipX?: boolean;
+    alphaTest?: number;
+    asSprite?: boolean;
+    offset?: number;
+    playBackwards?: boolean;
+    resetOnEnd?: boolean;
+    instanceItems?: Vector3[];
+    maxItems?: number;
+    spriteDataset?: {
+        spriteTexture: THREE.Texture;
+        spriteData: SpriteData | null;
+        aspect: Vector3;
+    } | null;
+    canvasRenderingContext2DSettings?: CanvasRenderingContext2DSettings;
+    roundFramePosition?: boolean;
+    meshProps?: CommonMeshProps;
 } & Omit<ThreeElements['group'], 'ref'>;
 type SpriteAnimatorState = {
-  current?: number;
-  offset?: number;
-  imageUrl?: string;
-  hasEnded: boolean;
-  ref: React$1.Ref<THREE$1.Group>;
+    current?: number;
+    offset?: number;
+    imageUrl?: string;
+    hasEnded: boolean;
+    ref: React.Ref<THREE.Group>;
 };
 declare function useSpriteAnimator(): SpriteAnimatorState | null;
-declare const SpriteAnimator: React$1.ForwardRefExoticComponent<Omit<SpriteAnimatorProps, "ref"> & React$1.RefAttributes<THREE$1.Group<THREE$1.Object3DEventMap>>>;
-//#endregion
-//#region src/core/Helpers/useAnimations/useAnimations.d.ts
+declare const SpriteAnimator: React.ForwardRefExoticComponent<Omit<SpriteAnimatorProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+
 type Api<T extends AnimationClip> = {
-  ref: React$1.RefObject<Object3D$1 | undefined | null>;
-  clips: AnimationClip[];
-  mixer: AnimationMixer;
-  names: T['name'][];
-  actions: { [key in T['name']]: AnimationAction | null };
-};
-declare function useAnimations<T extends AnimationClip>(clips: T[], root?: React$1.RefObject<Object3D$1 | undefined | null> | Object3D$1): Api<T>;
-//#endregion
-//#region src/core/Helpers/useContextBridge/useContextBridge.d.ts
-declare function useContextBridge(...contexts: Array<React$1.Context<any>>): ({
-  children
-}: {
-  children: React$1.ReactNode;
-}) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Helpers/Clone/Clone.d.ts
+    ref: React.RefObject<Object3D | undefined | null>;
+    clips: AnimationClip[];
+    mixer: AnimationMixer;
+    names: T['name'][];
+    actions: {
+        [key in T['name']]: AnimationAction | null;
+    };
+};
+declare function useAnimations<T extends AnimationClip>(clips: T[], root?: React.RefObject<Object3D | undefined | null> | Object3D): Api<T>;
+
+declare function useContextBridge(...contexts: Array<React.Context<any>>): ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+
 type CloneProps = Omit<ThreeElements['group'], 'ref' | 'children'> & {
-  object: THREE$1.Object3D | THREE$1.Object3D[];
-  children?: React$1.ReactNode;
-  deep?: boolean | 'materialsOnly' | 'geometriesOnly';
-  keys?: string[];
-  inject?: ThreeElements['mesh'] | React$1.ReactNode | ((object: THREE$1.Object3D) => React$1.ReactNode);
-  castShadow?: boolean;
-  receiveShadow?: boolean;
-  isChild?: boolean;
-};
-declare const Clone: ForwardRefComponent<CloneProps, THREE$1.Group>;
-//#endregion
-//#region src/core/Helpers/ComputedAttribute/ComputedAttribute.d.ts
+    object: THREE.Object3D | THREE.Object3D[];
+    children?: React.ReactNode;
+    deep?: boolean | 'materialsOnly' | 'geometriesOnly';
+    keys?: string[];
+    inject?: ThreeElements['mesh'] | React.ReactNode | ((object: THREE.Object3D) => React.ReactNode);
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    isChild?: boolean;
+};
+declare const Clone: ForwardRefComponent<CloneProps, THREE.Group>;
+
 type ComputedAttributeProps = Omit<ThreeElements['bufferAttribute'], 'args'> & {
-  compute: (geometry: BufferGeometry) => BufferAttribute;
-  name: string;
-};
-declare const ComputedAttribute: ({
-  compute,
-  name,
-  ...props
-}: ComputedAttributeProps) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Helpers/Example/Example.d.ts
+    compute: (geometry: BufferGeometry) => BufferAttribute;
+    name: string;
+};
+declare const ComputedAttribute: ({ compute, name, ...props }: ComputedAttributeProps) => React.JSX.Element;
+
 type ExampleProps = {
-  font: string;
-  color?: Color;
-  debug?: boolean;
-  bevelSize?: number;
-} & React$1.ComponentProps<'group'>;
+    font: string;
+    color?: Color$1;
+    debug?: boolean;
+    bevelSize?: number;
+} & React.ComponentProps<'group'>;
 type ExampleApi = {
-  incr: (x?: number) => void;
-  decr: (x?: number) => void;
+    incr: (x?: number) => void;
+    decr: (x?: number) => void;
 };
-declare const Example: React$1.ForwardRefExoticComponent<Omit<ExampleProps, "ref"> & React$1.RefAttributes<ExampleApi>>;
-//#endregion
-//#region src/core/Helpers/Sampler/Sampler.d.ts
+declare const Example: React.ForwardRefExoticComponent<Omit<ExampleProps, "ref"> & React.RefAttributes<ExampleApi>>;
+
 type SamplePayload = {
-  position: Vector3$2;
-  normal: Vector3$2;
-  color: Color$2;
+    position: Vector3$1;
+    normal: Vector3$1;
+    color: Color;
 };
 type TransformFn = (payload: TransformPayload, i: number) => void;
 type TransformPayload = SamplePayload & {
-  dummy: Object3D$1;
-  sampledMesh: Mesh$1;
+    dummy: Object3D;
+    sampledMesh: Mesh;
 };
 type SamplerProps = Omit<ThreeElements['group'], 'ref'> & {
-  mesh?: React$1.RefObject<Mesh$1>;
-  instances?: React$1.RefObject<InstancedMesh>;
-  weight?: string;
-  transform?: TransformFn;
-  count?: number;
+    mesh?: React.RefObject<Mesh>;
+    instances?: React.RefObject<InstancedMesh$1>;
+    weight?: string;
+    transform?: TransformFn;
+    count?: number;
 };
 interface useSurfaceSamplerProps {
-  transform?: TransformFn;
-  weight?: string;
-  count?: number;
+    transform?: TransformFn;
+    weight?: string;
+    count?: number;
 }
-declare function useSurfaceSampler(mesh: React$1.RefObject<Mesh$1>, count?: number, transform?: TransformFn, weight?: string, instanceMesh?: React$1.RefObject<InstancedMesh> | null): InstancedBufferAttribute;
-declare function Sampler({
-  children,
-  weight,
-  transform,
-  instances,
-  mesh,
-  count,
-  ...props
-}: SamplerProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Helpers/Svg/Svg.d.ts
+declare function useSurfaceSampler(mesh: React.RefObject<Mesh>, count?: number, transform?: TransformFn, weight?: string, instanceMesh?: React.RefObject<InstancedMesh$1> | null): InstancedBufferAttribute;
+declare function Sampler({ children, weight, transform, instances, mesh, count, ...props }: SamplerProps): React.JSX.Element;
+
 interface SvgProps extends Omit<ThreeElements['object3D'], 'ref'> {
-  src: string;
-  skipFill?: boolean;
-  skipStrokes?: boolean;
-  fillMaterial?: ThreeElements['meshBasicMaterial'];
-  strokeMaterial?: ThreeElements['meshBasicMaterial'];
-  fillMeshProps?: ThreeElements['mesh'];
-  strokeMeshProps?: ThreeElements['mesh'];
+    src: string;
+    skipFill?: boolean;
+    skipStrokes?: boolean;
+    fillMaterial?: ThreeElements['meshBasicMaterial'];
+    strokeMaterial?: ThreeElements['meshBasicMaterial'];
+    fillMeshProps?: ThreeElements['mesh'];
+    strokeMeshProps?: ThreeElements['mesh'];
 }
-declare const Svg: ForwardRefComponent<SvgProps, Object3D$1>;
-//#endregion
-//#region src/core/Helpers/useDepthBuffer/useDepthBuffer.d.ts
-declare function useDepthBuffer({
-  size,
-  frames
-}?: {
-  size?: number;
-  frames?: number;
+declare const Svg: ForwardRefComponent<SvgProps, Object3D>;
+
+declare function useDepthBuffer({ size, frames }?: {
+    size?: number;
+    frames?: number;
 }): DepthTexture | null;
-//#endregion
-//#region src/core/Textures/CubeTexture/CubeTexture.d.ts
+
 interface CubeTextureOptions {
-  path: string;
+    path: string;
 }
 interface CubeTextureProps extends CubeTextureOptions {
-  children?: (texture: CubeTexture$1) => React$1.ReactNode;
-  files: string[];
+    children?: (texture: CubeTexture$1) => React.ReactNode;
+    files: string[];
 }
-declare function useCubeTexture(files: string[], {
-  path
-}: CubeTextureOptions): CubeTexture$1;
+declare function useCubeTexture(files: string[], { path }: CubeTextureOptions): CubeTexture$1;
 declare namespace useCubeTexture {
-  var preload: (files: string[], {
-    path
-  }: CubeTextureOptions) => void;
+    var preload: (files: string[], { path }: CubeTextureOptions) => void;
 }
-declare function CubeTexture({
-  children,
-  files,
-  ...options
-}: CubeTextureProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Loaders/Loader/Loader.d.ts
+declare function CubeTexture({ children, files, ...options }: CubeTextureProps): React.JSX.Element;
+
 interface LoaderOptions {
-  containerStyles: CSSProperties;
-  innerStyles: CSSProperties;
-  barStyles: CSSProperties;
-  dataStyles: CSSProperties;
-  dataInterpolation: (p: number) => string;
-  initialState: (active: boolean) => boolean;
+    containerStyles: CSSProperties;
+    innerStyles: CSSProperties;
+    barStyles: CSSProperties;
+    dataStyles: CSSProperties;
+    dataInterpolation: (p: number) => string;
+    initialState: (active: boolean) => boolean;
 }
-declare function Loader({
-  containerStyles,
-  innerStyles,
-  barStyles,
-  dataStyles,
-  dataInterpolation,
-  initialState
-}: Partial<LoaderOptions>): React$1.JSX.Element | null;
-//#endregion
-//#region src/core/Loaders/Preload/Preload.d.ts
+declare function Loader({ containerStyles, innerStyles, barStyles, dataStyles, dataInterpolation, initialState, }: Partial<LoaderOptions>): React.JSX.Element | null;
+
 type PreloadProps = {
-  all?: boolean;
-  scene?: Object3D$1;
-  camera?: Camera;
-};
-declare function Preload({
-  all,
-  scene,
-  camera
-}: PreloadProps): null;
-//#endregion
-//#region src/core/Textures/VideoTexture/VideoTexture.d.ts
-declare function getHls(...args: ConstructorParameters<typeof Hls>): Promise<Hls | null>;
-declare function useVideoTexture(srcOrSrcObject: HTMLVideoElement['src' | 'srcObject'], {
-  unsuspend,
-  start,
-  hls: hlsConfig,
-  crossOrigin,
-  muted,
-  loop,
-  playsInline,
-  onVideoFrame,
-  ...videoProps
-}?: {
-  unsuspend?: keyof HTMLVideoElementEventMap;
-  start?: boolean;
-  hls?: Parameters<typeof getHls>[0];
-  onVideoFrame?: VideoFrameRequestCallback;
-} & Partial<Omit<HTMLVideoElement, 'children' | 'src' | 'srcObject'>>): THREE$1.VideoTexture<HTMLVideoElement>;
+    all?: boolean;
+    scene?: Object3D;
+    camera?: Camera;
+};
+declare function Preload({ all, scene, camera }: PreloadProps): null;
+
+declare function getHls(...args: ConstructorParameters<typeof hls_js__default>): Promise<hls_js__default | null>;
+declare function useVideoTexture(srcOrSrcObject: HTMLVideoElement['src' | 'srcObject'], { unsuspend, start, hls: hlsConfig, crossOrigin, muted, loop, playsInline, onVideoFrame, ...videoProps }?: {
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<typeof getHls>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, 'children' | 'src' | 'srcObject'>>): THREE.VideoTexture<HTMLVideoElement>;
 type UseVideoTextureParams = Parameters<typeof useVideoTexture>;
-type VideoTexture = ReturnType<typeof useVideoTexture>;
 type VideoTextureProps = {
-  children?: (texture: VideoTexture) => React$1.ReactNode;
-  src: UseVideoTextureParams[0];
+    children?: (texture: VideoTexture) => React.ReactNode;
+    src: UseVideoTextureParams[0];
 } & UseVideoTextureParams[1];
-declare const VideoTexture: React$1.ForwardRefExoticComponent<{
-  children?: (texture: VideoTexture) => React$1.ReactNode;
-  src: UseVideoTextureParams[0];
+type VideoTexture = ReturnType<typeof useVideoTexture>;
+declare const VideoTexture: React.ForwardRefExoticComponent<{
+    children?: (texture: VideoTexture) => React.ReactNode;
+    src: UseVideoTextureParams[0];
 } & {
-  unsuspend?: keyof HTMLVideoElementEventMap;
-  start?: boolean;
-  hls?: Parameters<typeof getHls>[0];
-  onVideoFrame?: VideoFrameRequestCallback;
-} & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">> & React$1.RefAttributes<THREE$1.VideoTexture<HTMLVideoElement>>>;
-//#endregion
-//#region src/core/Textures/ScreenVideoTexture/ScreenVideoTexture.d.ts
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<typeof getHls>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">> & React.RefAttributes<THREE.VideoTexture<HTMLVideoElement>>>;
+
 type ScreenVideoTextureProps = Omit<VideoTextureProps, 'src'> & {
-  options?: DisplayMediaStreamOptions;
+    options?: DisplayMediaStreamOptions;
 };
-declare const ScreenVideoTexture: React$1.ForwardRefExoticComponent<Omit<{
-  children?: (texture: THREE$1.VideoTexture<HTMLVideoElement>) => React$1.ReactNode;
-  src: string | MediaProvider | null;
+declare const ScreenVideoTexture: React.ForwardRefExoticComponent<Omit<{
+    children?: (texture: THREE.VideoTexture<HTMLVideoElement>) => React.ReactNode;
+    src: string | MediaProvider | null;
 } & {
-  unsuspend?: keyof HTMLVideoElementEventMap;
-  start?: boolean;
-  hls?: Parameters<(userConfig?: Partial<hls_js1.HlsConfig> | undefined) => Promise<hls_js1.default | null>>[0];
-  onVideoFrame?: VideoFrameRequestCallback;
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<(userConfig?: Partial<hls_js.HlsConfig> | undefined) => Promise<hls_js.default | null>>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
 } & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">>, "src"> & {
-  options?: DisplayMediaStreamOptions;
-} & React$1.RefAttributes<THREE$1.VideoTexture<HTMLVideoElement>>>;
-//#endregion
-//#region src/core/Textures/TrailTexture/TrailTexture.d.ts
+    options?: DisplayMediaStreamOptions;
+} & React.RefAttributes<THREE.VideoTexture<HTMLVideoElement>>>;
+
 type TrailConfig = {
-  size?: number;
-  maxAge?: number;
-  radius?: number;
-  intensity?: number;
-  interpolate?: number;
-  smoothing?: number;
-  minForce?: number;
-  blend?: CanvasRenderingContext2D['globalCompositeOperation'];
-  ease?: (t: number) => number;
-};
-declare function useTrailTexture(config?: Partial<TrailConfig>): [Texture$2, (ThreeEvent: any) => void];
+    size?: number;
+    maxAge?: number;
+    radius?: number;
+    intensity?: number;
+    interpolate?: number;
+    smoothing?: number;
+    minForce?: number;
+    blend?: CanvasRenderingContext2D['globalCompositeOperation'];
+    ease?: (t: number) => number;
+};
+declare function useTrailTexture(config?: Partial<TrailConfig>): [Texture$1, (ThreeEvent: any) => void];
 type TrailTextureProps = {
-  children?: (texture: ReturnType<typeof useTrailTexture>) => React$1.ReactNode;
+    children?: (texture: ReturnType<typeof useTrailTexture>) => React.ReactNode;
 } & TrailConfig;
-declare const TrailTexture: ({
-  children,
-  ...config
-}: TrailTextureProps) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Loaders/useFBX/useFBX.d.ts
+declare const TrailTexture: ({ children, ...config }: TrailTextureProps) => React.JSX.Element;
+
 declare function useFBX(path: string): Group;
 declare namespace useFBX {
-  var preload: (path: string) => void;
-  var clear: (input: string | string[]) => void;
+    var preload: (path: string) => void;
+    var clear: (input: string | string[]) => void;
 }
-declare function Fbx({
-  path,
-  ...props
-}: {
-  path: Parameters<typeof useFBX>[0];
-} & Omit<React$1.ComponentProps<typeof Clone>, 'object'>): React$1.JSX.Element;
-//#endregion
-//#region src/core/Loaders/useGLTF/useGLTF.d.ts
+declare function Fbx({ path, ...props }: {
+    path: Parameters<typeof useFBX>[0];
+} & Omit<React.ComponentProps<typeof Clone>, 'object'>): React.JSX.Element;
+
 type Path = string | string[];
 type UseDraco = boolean | string;
 type UseMeshopt = boolean;
 type ExtendLoader = (loader: GLTFLoader) => void;
 declare const useGLTF: {
-  <T extends Path>(path: T, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader): T extends any[] ? (GLTF & ObjectMap)[] : GLTF & ObjectMap;
-  preload(path: Path, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader): void;
-  clear(path: Path): void;
-  setDecoderPath(path: string): void;
+    <T extends Path>(path: T, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader): T extends any[] ? (GLTF & ObjectMap)[] : GLTF & ObjectMap;
+    preload(path: Path, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader): void;
+    clear(path: Path): void;
+    setDecoderPath(path: string): void;
 };
 type GltfProps = Omit<CloneProps, 'object'> & {
-  src: string;
-  useDraco?: UseDraco;
-  useMeshOpt?: UseMeshopt;
-  extendLoader?: ExtendLoader;
-};
-declare const Gltf: React$1.ForwardRefExoticComponent<Omit<GltfProps, "ref"> & React$1.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
-//#endregion
-//#region src/core/Loaders/useKTX2/useKTX2.d.ts
-declare function useKTX2<Url extends string[] | string | Record<string, string>>(input: Url, basisPath?: string): Url extends any[] ? Texture$2[] : Url extends object ? { [key in keyof Url]: Texture$2 } : Texture$2;
+    src: string;
+    useDraco?: UseDraco;
+    useMeshOpt?: UseMeshopt;
+    extendLoader?: ExtendLoader;
+};
+declare const Gltf: React.ForwardRefExoticComponent<Omit<GltfProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+
+declare function useKTX2<Url extends string[] | string | Record<string, string>>(input: Url, basisPath?: string): Url extends any[] ? Texture$1[] : Url extends object ? {
+    [key in keyof Url]: Texture$1;
+} : Texture$1;
 declare namespace useKTX2 {
-  var preload: (url: string extends any[] ? string[] : string, basisPath?: string) => void;
-  var clear: (input: string | string[]) => void;
+    var preload: (url: string extends any[] ? string[] : string, basisPath?: string) => void;
+    var clear: (input: string | string[]) => void;
 }
-declare const Ktx2: ({
-  children,
-  input,
-  basisPath
-}: {
-  children?: (texture: ReturnType<typeof useKTX2>) => React$1.ReactNode;
-  input: Parameters<typeof useKTX2>[0];
-  basisPath?: Parameters<typeof useKTX2>[1];
-}) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Loaders/useProgress/useProgress.d.ts
+declare const Ktx2: ({ children, input, basisPath, }: {
+    children?: (texture: ReturnType<typeof useKTX2>) => React.ReactNode;
+    input: Parameters<typeof useKTX2>[0];
+    basisPath?: Parameters<typeof useKTX2>[1];
+}) => React.JSX.Element;
+
 type Data = {
-  errors: string[];
-  active: boolean;
-  progress: number;
-  item: string;
-  loaded: number;
-  total: number;
-};
-declare const useProgress: zustand0.UseBoundStore<zustand0.StoreApi<Data>>;
-declare function Progress({
-  children
-}: {
-  children?: (result: Data) => React$1.ReactNode;
-}): React$1.JSX.Element;
-//#endregion
-//#region src/core/Loaders/useTexture/useTexture.d.ts
-type MappedTextureType<T extends string | string[] | Record<string, string>> = T extends string[] ? Texture$2[] : T extends Record<string, string> ? { [K in keyof T]: Texture$2 } : Texture$2;
+    errors: string[];
+    active: boolean;
+    progress: number;
+    item: string;
+    loaded: number;
+    total: number;
+};
+declare const useProgress: zustand.UseBoundStore<zustand.StoreApi<Data>>;
+
+declare function Progress({ children }: {
+    children?: (result: Data) => React.ReactNode;
+}): React.JSX.Element;
+
+type MappedTextureType<T extends string | string[] | Record<string, string>> = T extends string[] ? Texture$1[] : T extends Record<string, string> ? {
+    [K in keyof T]: Texture$1;
+} : Texture$1;
 declare const IsObject: (url: unknown) => url is Record<string, string>;
 declare function useTexture<Url extends string[] | string | Record<string, string>>(input: Url, onLoad?: (texture: MappedTextureType<Url>) => void): MappedTextureType<Url>;
 declare namespace useTexture {
-  var preload: (url: string | string[]) => void;
-  var clear: (input: string | string[]) => void;
+    var preload: (url: string | string[]) => void;
+    var clear: (input: string | string[]) => void;
 }
-declare const Texture: ({
-  children,
-  input,
-  onLoad
-}: {
-  children?: (texture: ReturnType<typeof useTexture>) => React$1.ReactNode;
-  input: Parameters<typeof useTexture>[0];
-  onLoad?: Parameters<typeof useTexture>[1];
-}) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Textures/WebcamVideoTexture/WebcamVideoTexture.d.ts
+declare const Texture: ({ children, input, onLoad, }: {
+    children?: (texture: ReturnType<typeof useTexture>) => React.ReactNode;
+    input: Parameters<typeof useTexture>[0];
+    onLoad?: Parameters<typeof useTexture>[1];
+}) => React.JSX.Element;
+
 type WebcamVideoTextureProps = Omit<VideoTextureProps, 'src'> & {
-  constraints?: MediaStreamConstraints;
+    constraints?: MediaStreamConstraints;
 };
-declare const WebcamVideoTexture: React$1.ForwardRefExoticComponent<Omit<{
-  children?: (texture: THREE$1.VideoTexture<HTMLVideoElement>) => React$1.ReactNode;
-  src: string | MediaProvider | null;
+declare const WebcamVideoTexture: React.ForwardRefExoticComponent<Omit<{
+    children?: (texture: THREE.VideoTexture<HTMLVideoElement>) => React.ReactNode;
+    src: string | MediaProvider | null;
 } & {
-  unsuspend?: keyof HTMLVideoElementEventMap;
-  start?: boolean;
-  hls?: Parameters<(userConfig?: Partial<hls_js1.HlsConfig> | undefined) => Promise<hls_js1.default | null>>[0];
-  onVideoFrame?: VideoFrameRequestCallback;
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<(userConfig?: Partial<hls_js.HlsConfig> | undefined) => Promise<hls_js.default | null>>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
 } & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">>, "src"> & {
-  constraints?: MediaStreamConstraints;
-} & React$1.RefAttributes<THREE$1.VideoTexture<HTMLVideoElement>>>;
-//#endregion
-//#region src/core/Performance/AdaptiveDpr/AdaptiveDpr.d.ts
-declare function AdaptiveDpr({
-  pixelated
-}: {
-  pixelated?: boolean;
+    constraints?: MediaStreamConstraints;
+} & React.RefAttributes<THREE.VideoTexture<HTMLVideoElement>>>;
+
+declare function AdaptiveDpr({ pixelated }: {
+    pixelated?: boolean;
 }): null;
-//#endregion
-//#region src/core/Performance/AdaptiveEvents/AdaptiveEvents.d.ts
+
 declare function AdaptiveEvents(): null;
-//#endregion
-//#region src/core/Performance/DetectGPU/DetectGPU.d.ts
-declare const useDetectGPU: (props?: GetGPUTier) => detect_gpu0.TierResult;
+
+declare const useDetectGPU: (props?: GetGPUTier) => detect_gpu.TierResult;
 type DetectGPUProps = {
-  children?: (result: ReturnType<typeof useDetectGPU>) => React$1.ReactNode;
+    children?: (result: ReturnType<typeof useDetectGPU>) => React.ReactNode;
 } & Parameters<typeof useDetectGPU>[0];
-declare function DetectGPU({
-  children,
-  ...options
-}: DetectGPUProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Performance/meshBounds/meshBounds.d.ts
+declare function DetectGPU({ children, ...options }: DetectGPUProps): React.JSX.Element;
+
 declare function meshBounds(raycaster: Raycaster, intersects: Intersection[]): void;
-//#endregion
-//#region src/core/Performance/PerformanceMonitor/PerformanceMonitor.d.ts
+
 type PerformanceMonitorHookApi = {
-  onIncline: (api: PerformanceMonitorApi) => void;
-  onDecline: (api: PerformanceMonitorApi) => void;
-  onChange: (api: PerformanceMonitorApi) => void;
-  onFallback: (api: PerformanceMonitorApi) => void;
+    onIncline: (api: PerformanceMonitorApi) => void;
+    onDecline: (api: PerformanceMonitorApi) => void;
+    onChange: (api: PerformanceMonitorApi) => void;
+    onFallback: (api: PerformanceMonitorApi) => void;
 };
 type PerformanceMonitorApi = {
-  fps: number;
-  factor: number;
-  refreshrate: number;
-  frames: number[];
-  averages: number[];
-  index: number;
-  flipped: number;
-  fallback: boolean;
-  subscriptions: Map<Symbol, Partial<PerformanceMonitorHookApi>>;
-  subscribe: (ref: React$1.RefObject<Partial<PerformanceMonitorHookApi>>) => () => void;
+    fps: number;
+    factor: number;
+    refreshrate: number;
+    frames: number[];
+    averages: number[];
+    index: number;
+    flipped: number;
+    fallback: boolean;
+    subscriptions: Map<Symbol, Partial<PerformanceMonitorHookApi>>;
+    subscribe: (ref: React.RefObject<Partial<PerformanceMonitorHookApi>>) => () => void;
 };
 type PerformanceMonitorProps = {
-  ms?: number;
-  iterations?: number;
-  threshold?: number;
-  bounds?: (refreshrate: number) => [lower: number, upper: number];
-  flipflops?: number;
-  factor?: number;
-  step?: number;
-  onIncline?: (api: PerformanceMonitorApi) => void;
-  onDecline?: (api: PerformanceMonitorApi) => void;
-  onChange?: (api: PerformanceMonitorApi) => void;
-  onFallback?: (api: PerformanceMonitorApi) => void;
-  children?: React$1.ReactNode;
-};
-declare function PerformanceMonitor({
-  iterations,
-  ms,
-  threshold,
-  step,
-  factor: _factor,
-  flipflops,
-  bounds,
-  onIncline,
-  onDecline,
-  onChange,
-  onFallback,
-  children
-}: PerformanceMonitorProps): React$1.JSX.Element;
-declare function usePerformanceMonitor({
-  onIncline,
-  onDecline,
-  onChange,
-  onFallback
-}: Partial<PerformanceMonitorHookApi>): void;
-//#endregion
-//#region src/core/Performance/Stats/Stats.d.ts
+    ms?: number;
+    iterations?: number;
+    threshold?: number;
+    bounds?: (refreshrate: number) => [lower: number, upper: number];
+    flipflops?: number;
+    factor?: number;
+    step?: number;
+    onIncline?: (api: PerformanceMonitorApi) => void;
+    onDecline?: (api: PerformanceMonitorApi) => void;
+    onChange?: (api: PerformanceMonitorApi) => void;
+    onFallback?: (api: PerformanceMonitorApi) => void;
+    children?: React.ReactNode;
+};
+declare function PerformanceMonitor({ iterations, ms, threshold, step, factor: _factor, flipflops, bounds, onIncline, onDecline, onChange, onFallback, children, }: PerformanceMonitorProps): React.JSX.Element;
+declare function usePerformanceMonitor({ onIncline, onDecline, onChange, onFallback, }: Partial<PerformanceMonitorHookApi>): void;
+
 type StatsProps = {
-  showPanel?: number;
-  className?: string;
-  parent?: React$1.RefObject<HTMLElement>;
-};
-declare function Stats({
-  showPanel,
-  className,
-  parent
-}: StatsProps): null;
-//#endregion
-//#region src/core/Performance/StatsGl/StatsGl.d.ts
+    showPanel?: number;
+    className?: string;
+    parent?: React.RefObject<HTMLElement>;
+};
+declare function Stats({ showPanel, className, parent }: StatsProps): null;
+
 type StatsOptions = ConstructorParameters<typeof Stats$1>[0];
 type StatsGlProps = Partial<StatsOptions> & {
-  id?: string;
-  clearStatsGlStyle?: boolean;
-  showPanel?: number;
-  className?: string;
-  parent?: React$1.RefObject<HTMLElement>;
-  ref?: React$1.RefObject<HTMLElement>;
+    id?: string;
+    clearStatsGlStyle?: boolean;
+    showPanel?: number;
+    className?: string;
+    parent?: React.RefObject<HTMLElement>;
+    ref?: React.RefObject<HTMLElement>;
 };
 declare const StatsGl: ForwardRefComponent<StatsGlProps, HTMLDivElement>;
-//#endregion
-//#region src/core/Portal/Fbo/Fbo.d.ts
+
 type FBOSettings = {
-  depth?: boolean;
+    depth?: boolean;
 } & RenderTargetOptions;
-declare function useFBO(width?: number | FBOSettings, height?: number, settings?: FBOSettings): THREE$1.WebGLRenderTarget<THREE$1.Texture<unknown>>;
+declare function useFBO(width?: number | FBOSettings, height?: number, settings?: FBOSettings): THREE.WebGLRenderTarget<THREE.Texture<unknown>>;
 type UseFBOParams = Parameters<typeof useFBO>;
-type Fbo = ReturnType<typeof useFBO>;
 type FboProps = {
-  children?: (target: Fbo) => React$1.ReactNode;
-  width?: UseFBOParams[0];
-  height?: UseFBOParams[1];
+    children?: (target: Fbo) => React.ReactNode;
+    width?: UseFBOParams[0];
+    height?: UseFBOParams[1];
 } & FBOSettings;
-declare const Fbo: React$1.ForwardRefExoticComponent<{
-  children?: (target: Fbo) => React$1.ReactNode;
-  width?: UseFBOParams[0];
-  height?: UseFBOParams[1];
+type Fbo = ReturnType<typeof useFBO>;
+declare const Fbo: React.ForwardRefExoticComponent<{
+    children?: (target: Fbo) => React.ReactNode;
+    width?: UseFBOParams[0];
+    height?: UseFBOParams[1];
 } & {
-  depth?: boolean;
-} & THREE$1.RenderTargetOptions & React$1.RefAttributes<THREE$1.WebGLRenderTarget<THREE$1.Texture<unknown>>>>;
-//#endregion
-//#region src/core/Portal/Fisheye/Fisheye.d.ts
+    depth?: boolean;
+} & THREE.RenderTargetOptions & React.RefAttributes<THREE.WebGLRenderTarget<THREE.Texture<unknown>>>>;
+
 type FisheyeProps = ThreeElements['mesh'] & {
-  zoom?: number;
-  segments?: number;
-  resolution?: number;
-  children: React$1.ReactNode;
-  renderPriority?: number;
-};
-declare function Fisheye({
-  renderPriority,
-  zoom,
-  segments,
-  children,
-  resolution,
-  ...props
-}: FisheyeProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Portal/Hud/Hud.d.ts
+    zoom?: number;
+    segments?: number;
+    resolution?: number;
+    children: React.ReactNode;
+    renderPriority?: number;
+};
+declare function Fisheye({ renderPriority, zoom, segments, children, resolution, ...props }: FisheyeProps): React.JSX.Element;
+
 type HudProps = {
-  children: React$1.ReactNode;
-  renderPriority?: number;
-};
-declare function Hud({
-  children,
-  renderPriority
-}: HudProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Portal/Mask/Mask.d.ts
+    children: React.ReactNode;
+    renderPriority?: number;
+};
+declare function Hud({ children, renderPriority }: HudProps): React.JSX.Element;
+
 type MaskProps = Omit<ThreeElements['mesh'], 'ref' | 'id'> & {
-  id: number;
-  colorWrite?: boolean;
-  depthWrite?: boolean;
+    id: number;
+    colorWrite?: boolean;
+    depthWrite?: boolean;
 };
-declare const Mask: ForwardRefComponent<MaskProps, THREE$1.Mesh>;
+declare const Mask: ForwardRefComponent<MaskProps, THREE.Mesh>;
 declare function useMask(id: number, inverse?: boolean): {
-  stencilWrite: boolean;
-  stencilRef: number;
-  stencilFunc: 517 | 514;
-  stencilFail: 7680;
-  stencilZFail: 7680;
-  stencilZPass: 7680;
-};
-//#endregion
-//#region src/core/Portal/RenderCubeTexture/RenderCubeTexture.d.ts
+    stencilWrite: boolean;
+    stencilRef: number;
+    stencilFunc: 514 | 517;
+    stencilFail: 7680;
+    stencilZFail: 7680;
+    stencilZPass: 7680;
+};
+
 type RenderCubeTextureProps = Omit<ThreeElements['texture'], 'ref' | 'args' | 'rotation'> & {
-  stencilBuffer?: boolean;
-  depthBuffer?: boolean;
-  generateMipmaps?: boolean;
-  renderPriority?: number;
-  eventPriority?: number;
-  frames?: number;
-  compute?: ComputeFunction;
-  flip?: boolean;
-  resolution?: number;
-  children: React$1.ReactNode;
-  near?: number;
-  far?: number;
-  position?: ReactThreeFiber.Vector3;
-  rotation?: ReactThreeFiber.Euler;
-  scale?: ReactThreeFiber.Vector3;
-  quaternion?: ReactThreeFiber.Quaternion;
-  matrix?: ReactThreeFiber.Matrix4;
-  matrixAutoUpdate?: boolean;
+    stencilBuffer?: boolean;
+    depthBuffer?: boolean;
+    generateMipmaps?: boolean;
+    renderPriority?: number;
+    eventPriority?: number;
+    frames?: number;
+    compute?: ComputeFunction;
+    flip?: boolean;
+    resolution?: number;
+    children: React.ReactNode;
+    near?: number;
+    far?: number;
+    position?: ReactThreeFiber.Vector3;
+    rotation?: ReactThreeFiber.Euler;
+    scale?: ReactThreeFiber.Vector3;
+    quaternion?: ReactThreeFiber.Quaternion;
+    matrix?: ReactThreeFiber.Matrix4;
+    matrixAutoUpdate?: boolean;
 };
 type RenderCubeTextureApi = {
-  scene: THREE$1.Scene;
-  fbo: THREE$1.WebGLCubeRenderTarget;
-  camera: THREE$1.CubeCamera;
+    scene: THREE.Scene;
+    fbo: THREE.WebGLCubeRenderTarget;
+    camera: THREE.CubeCamera;
 };
 declare const RenderCubeTexture: ForwardRefComponent<RenderCubeTextureProps, RenderCubeTextureApi>;
-//#endregion
-//#region src/core/Portal/useCustomRaycast/useCustomRaycast.d.ts
-declare function useCustomRaycast(camera: Camera | React$1.RefObject<Camera>, props?: Partial<Raycaster>): (_: Raycaster, intersects: Intersection[]) => void;
-//#endregion
-//#region src/core/Portal/View/View.d.ts
+
+declare function useCustomRaycast(camera: Camera | React.RefObject<Camera>, props?: Partial<Raycaster>): (_: Raycaster, intersects: Intersection[]) => void;
+
 type CanvasSize = {
-  top: number;
-  left: number;
-  height: number;
-  width: number;
+    top: number;
+    left: number;
+    height: number;
+    width: number;
 };
 type ContainerProps = {
-  visible: boolean;
-  scene: THREE$1.Scene;
-  index: number;
-  children?: React$1.ReactNode;
-  frames: number;
-  rect: React$1.RefObject<DOMRect>;
-  track?: React$1.RefObject<HTMLElement>;
-  canvasSize: CanvasSize;
+    visible: boolean;
+    scene: THREE.Scene;
+    index: number;
+    children?: React.ReactNode;
+    frames: number;
+    rect: React.RefObject<DOMRect>;
+    track?: React.RefObject<HTMLElement>;
+    canvasSize: CanvasSize;
 };
 type ViewProps = {
-  as?: string;
-  id?: string;
-  className?: string;
-  style?: React$1.CSSProperties;
-  visible?: boolean;
-  index?: number;
-  frames?: number;
-  children?: React$1.ReactNode;
-  track?: React$1.RefObject<HTMLElement>;
+    as?: string;
+    id?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    visible?: boolean;
+    index?: number;
+    frames?: number;
+    children?: React.ReactNode;
+    track?: React.RefObject<HTMLElement>;
 };
 type ViewportProps = {
-  Port: () => React$1.JSX.Element;
-} & React$1.ForwardRefExoticComponent<ViewProps & React$1.RefAttributes<HTMLElement | THREE$1.Group>>;
+    Port: () => React.JSX.Element;
+} & React.ForwardRefExoticComponent<ViewProps & React.RefAttributes<HTMLElement | THREE.Group>>;
 declare const View: ViewportProps;
-//#endregion
-//#region src/core/Staging/Backdrop/Backdrop.d.ts
+
 type BackdropProps = ThreeElements['group'] & {
-  floor?: number;
-  segments?: number;
-  receiveShadow?: boolean;
-  children?: React$1.ReactNode;
-};
-declare function Backdrop({
-  children,
-  floor,
-  segments,
-  receiveShadow,
-  ...props
-}: {
-  [x: string]: any;
-  children: any;
-  floor?: number | undefined;
-  segments?: number | undefined;
-  receiveShadow: any;
-}): React$1.JSX.Element;
-//#endregion
-//#region src/core/Staging/BBAnchor/BBAnchor.d.ts
+    floor?: number;
+    segments?: number;
+    receiveShadow?: boolean;
+    children?: React.ReactNode;
+};
+declare function Backdrop({ children, floor, segments, receiveShadow, ...props }: {
+    [x: string]: any;
+    children: any;
+    floor?: number | undefined;
+    segments?: number | undefined;
+    receiveShadow: any;
+}): React.JSX.Element;
+
 type BBAnchorProps = ThreeElements['group'] & {
-  anchor: THREE$1.Vector3 | [number, number, number];
-};
-declare const BBAnchor: ({
-  anchor,
-  ...props
-}: BBAnchorProps) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Staging/Billboard/Billboard.d.ts
+    anchor: THREE.Vector3 | [number, number, number];
+};
+declare const BBAnchor: ({ anchor, ...props }: BBAnchorProps) => React.JSX.Element;
+
 type BillboardProps = Omit<ThreeElements['group'], 'ref'> & {
-  follow?: boolean;
-  lockX?: boolean;
-  lockY?: boolean;
-  lockZ?: boolean;
+    follow?: boolean;
+    lockX?: boolean;
+    lockY?: boolean;
+    lockZ?: boolean;
 };
 declare const Billboard: ForwardRefComponent<BillboardProps, Group>;
-//#endregion
-//#region src/core/Staging/Bounds/Bounds.d.ts
+
 type SizeProps = {
-  box: THREE$1.Box3;
-  size: THREE$1.Vector3;
-  center: THREE$1.Vector3;
-  distance: number;
+    box: THREE.Box3;
+    size: THREE.Vector3;
+    center: THREE.Vector3;
+    distance: number;
 };
 type BoundsApi = {
-  getSize: () => SizeProps;
-  refresh(object?: THREE$1.Object3D | THREE$1.Box3): BoundsApi;
-  reset(): BoundsApi;
-  moveTo(position: THREE$1.Vector3 | [number, number, number]): BoundsApi;
-  lookAt({
-    target,
-    up
-  }: {
-    target?: THREE$1.Vector3 | [number, number, number];
-    up?: THREE$1.Vector3 | [number, number, number];
-  }): BoundsApi;
-  to({
-    position,
-    target
-  }: {
-    position: [number, number, number];
-    target: [number, number, number];
-  }): BoundsApi;
-  fit(): BoundsApi;
-  clip(): BoundsApi;
+    getSize: () => SizeProps;
+    refresh(object?: THREE.Object3D | THREE.Box3): BoundsApi;
+    reset(): BoundsApi;
+    moveTo(position: THREE.Vector3 | [number, number, number]): BoundsApi;
+    lookAt({ target, up, }: {
+        target?: THREE.Vector3 | [number, number, number];
+        up?: THREE.Vector3 | [number, number, number];
+    }): BoundsApi;
+    to({ position, target }: {
+        position: [number, number, number];
+        target: [number, number, number];
+    }): BoundsApi;
+    fit(): BoundsApi;
+    clip(): BoundsApi;
 };
 type BoundsProps = Omit<ThreeElements['group'], 'ref'> & {
-  maxDuration?: number;
-  margin?: number;
-  observe?: boolean;
-  fit?: boolean;
-  clip?: boolean;
-  interpolateFunc?: (t: number) => number;
-  onFit?: (data: SizeProps) => void;
-};
-declare function Bounds({
-  children,
-  maxDuration,
-  margin,
-  observe,
-  fit,
-  clip,
-  interpolateFunc,
-  onFit
-}: BoundsProps): React$1.JSX.Element;
+    maxDuration?: number;
+    margin?: number;
+    observe?: boolean;
+    fit?: boolean;
+    clip?: boolean;
+    interpolateFunc?: (t: number) => number;
+    onFit?: (data: SizeProps) => void;
+};
+declare function Bounds({ children, maxDuration, margin, observe, fit, clip, interpolateFunc, onFit, }: BoundsProps): React.JSX.Element;
 declare function useBounds(): BoundsApi;
-//#endregion
-//#region src/core/Staging/Center/Center.d.ts
+
 type OnCenterCallbackProps = {
-  parent: Object3D$1;
-  container: Object3D$1;
-  width: number;
-  height: number;
-  depth: number;
-  boundingBox: Box3;
-  boundingSphere: Sphere$1;
-  center: Vector3$2;
-  verticalAlignment: number;
-  horizontalAlignment: number;
-  depthAlignment: number;
+    parent: Object3D;
+    container: Object3D;
+    width: number;
+    height: number;
+    depth: number;
+    boundingBox: Box3;
+    boundingSphere: Sphere$1;
+    center: Vector3$1;
+    verticalAlignment: number;
+    horizontalAlignment: number;
+    depthAlignment: number;
 };
 type CenterProps = Omit<ThreeElements['group'], 'ref'> & {
-  top?: boolean;
-  right?: boolean;
-  bottom?: boolean;
-  left?: boolean;
-  front?: boolean;
-  back?: boolean;
-  disable?: boolean;
-  disableX?: boolean;
-  disableY?: boolean;
-  disableZ?: boolean;
-  object?: Object3D$1 | null;
-  precise?: boolean;
-  onCentered?: (props: OnCenterCallbackProps) => void;
-  cacheKey?: any;
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+    front?: boolean;
+    back?: boolean;
+    disable?: boolean;
+    disableX?: boolean;
+    disableY?: boolean;
+    disableZ?: boolean;
+    object?: Object3D | null;
+    precise?: boolean;
+    onCentered?: (props: OnCenterCallbackProps) => void;
+    cacheKey?: any;
 };
 declare const Center: ForwardRefComponent<CenterProps, Group>;
-//#endregion
-//#region src/core/Staging/environment-assets.d.ts
+
 declare const presetsObj: {
-  apartment: string;
-  city: string;
-  dawn: string;
-  forest: string;
-  lobby: string;
-  night: string;
-  park: string;
-  studio: string;
-  sunset: string;
-  warehouse: string;
+    apartment: string;
+    city: string;
+    dawn: string;
+    forest: string;
+    lobby: string;
+    night: string;
+    park: string;
+    studio: string;
+    sunset: string;
+    warehouse: string;
 };
 type PresetsType = keyof typeof presetsObj;
-//#endregion
-//#region src/core/Staging/useEnvironment/useEnvironment.d.ts
+
 type EnvironmentLoaderProps = {
-  files?: string | string[];
-  path?: string;
-  preset?: PresetsType;
-  extensions?: (loader: Loader$2) => void;
-  colorSpace?: ColorSpace;
-};
-declare function useEnvironment({
-  files,
-  path,
-  preset,
-  colorSpace,
-  extensions
-}?: Partial<EnvironmentLoaderProps>): CubeTexture$1<unknown> | Texture$2<unknown>;
+    files?: string | string[];
+    path?: string;
+    preset?: PresetsType;
+    extensions?: (loader: Loader$1) => void;
+    colorSpace?: ColorSpace;
+};
+declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): CubeTexture$1<unknown> | Texture$1<unknown>;
 declare namespace useEnvironment {
-  var preload: (preloadOptions?: EnvironmentLoaderPreloadOptions) => void;
-  var clear: (clearOptions?: EnvironmentLoaderClearOptions) => void;
+    var preload: (preloadOptions?: EnvironmentLoaderPreloadOptions) => void;
+    var clear: (clearOptions?: EnvironmentLoaderClearOptions) => void;
 }
 type EnvironmentLoaderPreloadOptions = Omit<EnvironmentLoaderProps, 'encoding'>;
 type EnvironmentLoaderClearOptions = Pick<EnvironmentLoaderProps, 'files' | 'preset'>;
-//#endregion
-//#region src/core/Staging/Environment/Environment.d.ts
+
 type EnvironmentProps = {
-  children?: React$1.ReactNode;
-  frames?: number;
-  near?: number;
-  far?: number;
-  resolution?: number;
-  background?: boolean | 'only';
-  blur?: number;
-  backgroundBlurriness?: number;
-  backgroundIntensity?: number;
-  backgroundRotation?: Euler;
-  environmentIntensity?: number;
-  environmentRotation?: Euler;
-  map?: Texture$2;
-  preset?: PresetsType;
-  scene?: Scene$1 | React$1.RefObject<Scene$1>;
-  ground?: boolean | {
-    radius?: number;
-    height?: number;
-    scale?: number;
-  };
+    children?: React.ReactNode;
+    frames?: number;
+    near?: number;
+    far?: number;
+    resolution?: number;
+    background?: boolean | 'only';
+    blur?: number;
+    backgroundBlurriness?: number;
+    backgroundIntensity?: number;
+    backgroundRotation?: Euler;
+    environmentIntensity?: number;
+    environmentRotation?: Euler;
+    map?: Texture$1;
+    preset?: PresetsType;
+    scene?: Scene | React.RefObject<Scene>;
+    ground?: boolean | {
+        radius?: number;
+        height?: number;
+        scale?: number;
+    };
 } & EnvironmentLoaderProps;
-declare function EnvironmentMap({
-  scene,
-  background,
-  map,
-  ...config
-}: EnvironmentProps): null;
-declare function EnvironmentCube({
-  background,
-  scene,
-  blur,
-  backgroundBlurriness,
-  backgroundIntensity,
-  backgroundRotation,
-  environmentIntensity,
-  environmentRotation,
-  ...rest
-}: EnvironmentProps): null;
-declare function EnvironmentPortal({
-  children,
-  near,
-  far,
-  resolution,
-  frames,
-  map,
-  background,
-  blur,
-  backgroundBlurriness,
-  backgroundIntensity,
-  backgroundRotation,
-  environmentIntensity,
-  environmentRotation,
-  scene,
-  files,
-  path,
-  preset,
-  extensions
-}: EnvironmentProps): React$1.JSX.Element;
+declare function EnvironmentMap({ scene, background, map, ...config }: EnvironmentProps): null;
+declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, ...rest }: EnvironmentProps): null;
+declare function EnvironmentPortal({ children, near, far, resolution, frames, map, background, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, scene, files, path, preset, extensions, }: EnvironmentProps): React.JSX.Element;
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    groundProjectedEnvImpl: ThreeElement<typeof GroundedSkybox>;
-  }
+    interface ThreeElements {
+        groundProjectedEnvImpl: ThreeElement<typeof GroundedSkybox>;
+    }
 }
-declare function Environment(props: EnvironmentProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Staging/Float/Float.d.ts
+declare function Environment(props: EnvironmentProps): React.JSX.Element;
+
 type FloatProps = Omit<ThreeElements['group'], 'ref'> & {
-  enabled?: boolean;
-  speed?: number;
-  rotationIntensity?: number;
-  floatIntensity?: number;
-  children?: React$1.ReactNode;
-  floatingRange?: [number?, number?];
-  autoInvalidate?: boolean;
-};
-declare const Float: ForwardRefComponent<FloatProps, THREE$1.Group>;
-//#endregion
-//#region src/core/Staging/Lightformer/Lightformer.d.ts
+    enabled?: boolean;
+    speed?: number;
+    rotationIntensity?: number;
+    floatIntensity?: number;
+    children?: React.ReactNode;
+    floatingRange?: [number?, number?];
+    autoInvalidate?: boolean;
+};
+declare const Float: ForwardRefComponent<FloatProps, THREE.Group>;
+
 type LightProps = Omit<ThreeElements['mesh'], 'ref'> & {
-  args?: any[];
-  map?: THREE$1.Texture;
-  toneMapped?: boolean;
-  color?: ReactThreeFiber.Color;
-  form?: 'circle' | 'ring' | 'rect' | 'plane' | 'box' | any;
-  scale?: number | [number, number, number] | [number, number];
-  intensity?: number;
-  target?: boolean | [number, number, number] | THREE$1.Vector3;
-  light?: Partial<ThreeElements['pointLight']>;
-};
-declare const Lightformer: ForwardRefComponent<LightProps, THREE$1.Mesh>;
-//#endregion
-//#region src/core/Staging/Resize/Resize.d.ts
+    args?: any[];
+    map?: THREE.Texture;
+    toneMapped?: boolean;
+    color?: ReactThreeFiber.Color;
+    form?: 'circle' | 'ring' | 'rect' | 'plane' | 'box' | any;
+    scale?: number | [number, number, number] | [number, number];
+    intensity?: number;
+    target?: boolean | [number, number, number] | THREE.Vector3;
+    light?: Partial<ThreeElements['pointLight']>;
+};
+declare const Lightformer: ForwardRefComponent<LightProps, THREE.Mesh>;
+
 type ResizeProps = Omit<ThreeElements['group'], 'ref'> & {
-  width?: boolean;
-  height?: boolean;
-  depth?: boolean;
-  box3?: THREE$1.Box3;
-  precise?: boolean;
-};
-declare const Resize: React$1.ForwardRefExoticComponent<Omit<ResizeProps, "ref"> & React$1.RefAttributes<THREE$1.Group<THREE$1.Object3DEventMap>>>;
-//#endregion
-//#region src/core/Staging/ScreenSizer/ScreenSizer.d.ts
+    width?: boolean;
+    height?: boolean;
+    depth?: boolean;
+    box3?: THREE.Box3;
+    precise?: boolean;
+};
+declare const Resize: React.ForwardRefExoticComponent<Omit<ResizeProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+
 type ScreenSizerProps = Omit<ThreeElements['object3D'], 'ref'> & {
-  scale?: number;
+    scale?: number;
 };
-declare const ScreenSizer: ForwardRefComponent<ScreenSizerProps, Object3D$1>;
-//#endregion
-//#region src/core/Staging/Shadow/Shadow.d.ts
+declare const ScreenSizer: ForwardRefComponent<ScreenSizerProps, Object3D>;
+
 type ShadowProps = Omit<ThreeElements['mesh'], 'ref'> & {
-  colorStop?: number;
-  fog?: boolean;
-  color?: Color$2 | number | string;
-  opacity?: number;
-  depthWrite?: boolean;
+    colorStop?: number;
+    fog?: boolean;
+    color?: Color | number | string;
+    opacity?: number;
+    depthWrite?: boolean;
 };
-type ShadowType = Mesh$1<PlaneGeometry$1, MeshBasicMaterial$1>;
+type ShadowType = Mesh<PlaneGeometry, MeshBasicMaterial>;
 declare const Shadow: ForwardRefComponent<ShadowProps, ShadowType>;
-//#endregion
-//#region src/core/Staging/Sky/Sky.d.ts
+
 type SkyProps = {
-  distance?: number;
-  sunPosition?: ReactThreeFiber.Vector3;
-  inclination?: number;
-  azimuth?: number;
-  mieCoefficient?: number;
-  mieDirectionalG?: number;
-  rayleigh?: number;
-  turbidity?: number;
-};
-declare function calcPosFromAngles(inclination: number, azimuth: number, vector?: Vector3$2): Vector3$2;
+    distance?: number;
+    sunPosition?: ReactThreeFiber.Vector3;
+    inclination?: number;
+    azimuth?: number;
+    mieCoefficient?: number;
+    mieDirectionalG?: number;
+    rayleigh?: number;
+    turbidity?: number;
+};
+declare function calcPosFromAngles(inclination: number, azimuth: number, vector?: Vector3$1): Vector3$1;
 declare const Sky: ForwardRefComponent<SkyProps, Sky$1>;
-//#endregion
-//#region src/core/Staging/Stage/Stage.d.ts
+
 type StageShadows = Partial<AccumulativeShadowsProps> & Partial<RandomizedLightProps> & Partial<ContactShadowsProps> & {
-  type: 'contact' | 'accumulative';
-  offset?: number;
-  bias?: number;
-  normalBias?: number;
-  size?: number;
+    type: 'contact' | 'accumulative';
+    offset?: number;
+    bias?: number;
+    normalBias?: number;
+    size?: number;
 };
 type StageProps = Omit<ThreeElements['group'], 'ref'> & {
-  preset?: 'rembrandt' | 'portrait' | 'upfront' | 'soft' | {
-    main: [x: number, y: number, z: number];
-    fill: [x: number, y: number, z: number];
-  };
-  shadows?: boolean | 'contact' | 'accumulative' | StageShadows;
-  adjustCamera?: boolean | number;
-  environment?: PresetsType | Partial<EnvironmentProps> | null;
-  intensity?: number;
-  center?: Partial<CenterProps>;
-};
-declare function Stage({
-  children,
-  center,
-  adjustCamera,
-  intensity,
-  shadows,
-  environment,
-  preset,
-  ...props
-}: StageProps): React$1.JSX.Element;
-//#endregion
-//#region src/core/Staging/MatcapTexture/MatcapTexture.d.ts
-declare function useMatcapTexture(id?: number | string, format?: number, onLoad?: (texture: Texture$2 | Texture$2[]) => void): [Texture$2, string, number];
-declare const MatcapTexture: ({
-  children,
-  id,
-  format,
-  onLoad
-}: {
-  children?: (texture: ReturnType<typeof useMatcapTexture>) => React$1.ReactNode;
-  id?: Parameters<typeof useMatcapTexture>[0];
-  format?: Parameters<typeof useMatcapTexture>[1];
-  onLoad?: Parameters<typeof useMatcapTexture>[2];
-}) => React$1.JSX.Element;
-//#endregion
-//#region src/core/Textures/NormalTexture/NormalTexture.d.ts
+    preset?: 'rembrandt' | 'portrait' | 'upfront' | 'soft' | {
+        main: [x: number, y: number, z: number];
+        fill: [x: number, y: number, z: number];
+    };
+    shadows?: boolean | 'contact' | 'accumulative' | StageShadows;
+    adjustCamera?: boolean | number;
+    environment?: PresetsType | Partial<EnvironmentProps> | null;
+    intensity?: number;
+    center?: Partial<CenterProps>;
+};
+declare function Stage({ children, center, adjustCamera, intensity, shadows, environment, preset, ...props }: StageProps): React.JSX.Element;
+
+declare function useMatcapTexture(id?: number | string, format?: number, onLoad?: (texture: Texture$1 | Texture$1[]) => void): [Texture$1, string, number];
+declare const MatcapTexture: ({ children, id, format, onLoad, }: {
+    children?: (texture: ReturnType<typeof useMatcapTexture>) => React.ReactNode;
+    id?: Parameters<typeof useMatcapTexture>[0];
+    format?: Parameters<typeof useMatcapTexture>[1];
+    onLoad?: Parameters<typeof useMatcapTexture>[2];
+}) => React.JSX.Element;
+
 type Settings = {
-  repeat?: number[];
-  anisotropy?: number;
-  offset?: number[];
-};
-declare function useNormalTexture(id?: number, settings?: Settings, onLoad?: (texture: Texture$2 | Texture$2[]) => void): [Texture$2, string, number];
-declare const NormalTexture: ({
-  children,
-  id,
-  onLoad,
-  ...settings
-}: {
-  children?: (texture: ReturnType<typeof useNormalTexture>) => React$1.ReactNode;
-  id?: Parameters<typeof useNormalTexture>[0];
-  onLoad?: Parameters<typeof useNormalTexture>[2];
-} & Settings) => React$1.JSX.Element;
-//#endregion
-//#region src/core/UI/CycleRaycast/CycleRaycast.d.ts
+    repeat?: number[];
+    anisotropy?: number;
+    offset?: number[];
+};
+declare function useNormalTexture(id?: number, settings?: Settings, onLoad?: (texture: Texture$1 | Texture$1[]) => void): [Texture$1, string, number];
+declare const NormalTexture: ({ children, id, onLoad, ...settings }: {
+    children?: (texture: ReturnType<typeof useNormalTexture>) => React.ReactNode;
+    id?: Parameters<typeof useNormalTexture>[0];
+    onLoad?: Parameters<typeof useNormalTexture>[2];
+} & Settings) => React.JSX.Element;
+
 type CycleRaycastProps = {
-  onChanged?: (hits: THREE$1.Intersection[], cycle: number) => null;
-  preventDefault?: boolean;
-  scroll?: boolean;
-  keyCode?: number;
-  portal?: React$1.RefObject<HTMLElement>;
-};
-declare function CycleRaycast({
-  onChanged,
-  portal,
-  preventDefault,
-  scroll,
-  keyCode
-}: CycleRaycastProps): null;
-//#endregion
-//#region src/core/UI/Html/Html.d.ts
-declare function defaultCalculatePosition(el: Object3D$1, camera: Camera, size: {
-  width: number;
-  height: number;
+    onChanged?: (hits: THREE.Intersection[], cycle: number) => null;
+    preventDefault?: boolean;
+    scroll?: boolean;
+    keyCode?: number;
+    portal?: React.RefObject<HTMLElement>;
+};
+declare function CycleRaycast({ onChanged, portal, preventDefault, scroll, keyCode, }: CycleRaycastProps): null;
+
+declare function defaultCalculatePosition(el: Object3D, camera: Camera, size: {
+    width: number;
+    height: number;
 }): number[];
 type CalculatePosition = typeof defaultCalculatePosition;
 type PointerEventsProperties = 'auto' | 'none' | 'visiblePainted' | 'visibleFill' | 'visibleStroke' | 'visible' | 'painted' | 'fill' | 'stroke' | 'all' | 'inherit';
-interface HtmlProps extends Omit<Assign<React$1.HTMLAttributes<HTMLDivElement>, ThreeElements['group']>, 'ref'> {
-  prepend?: boolean;
-  center?: boolean;
-  fullscreen?: boolean;
-  eps?: number;
-  portal?: React$1.RefObject<HTMLElement>;
-  distanceFactor?: number;
-  sprite?: boolean;
-  transform?: boolean;
-  zIndexRange?: Array<number>;
-  calculatePosition?: CalculatePosition;
-  as?: string;
-  wrapperClass?: string;
-  pointerEvents?: PointerEventsProperties;
-  occlude?: React$1.RefObject<Object3D$1>[] | boolean | 'raycast' | 'blending';
-  onOcclude?: (hidden: boolean) => void;
-  material?: React$1.ReactNode;
-  geometry?: React$1.ReactNode;
-  castShadow?: boolean;
-  receiveShadow?: boolean;
+interface HtmlProps extends Omit<Assign<React.HTMLAttributes<HTMLDivElement>, ThreeElements['group']>, 'ref'> {
+    prepend?: boolean;
+    center?: boolean;
+    fullscreen?: boolean;
+    eps?: number;
+    portal?: React.RefObject<HTMLElement>;
+    distanceFactor?: number;
+    sprite?: boolean;
+    transform?: boolean;
+    zIndexRange?: Array<number>;
+    calculatePosition?: CalculatePosition;
+    as?: string;
+    wrapperClass?: string;
+    pointerEvents?: PointerEventsProperties;
+    occlude?: React.RefObject<Object3D>[] | boolean | 'raycast' | 'blending';
+    onOcclude?: (hidden: boolean) => void;
+    material?: React.ReactNode;
+    geometry?: React.ReactNode;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
 }
 declare const Html: ForwardRefComponent<HtmlProps, HTMLDivElement>;
-//#endregion
-//#region src/core/UI/useAspect/useAspect.d.ts
+
 declare function useAspect(width: number, height: number, factor?: number): [number, number, number];
-//#endregion
-//#region src/core/UI/useCursor/useCursor.d.ts
+
 declare function useCursor(hovered: boolean, onPointerOver?: string, onPointerOut?: string, container?: HTMLElement): void;
-//#endregion
-//#region src/core/UI/useIntersect/useIntersect.d.ts
-declare function useIntersect<T extends Object3D$1>(onChange: (visible: boolean) => void): React$1.RefObject<T>;
-//#endregion
-//#region src/core/UI/ScreenSpace/ScreenSpace.d.ts
+
+declare function useIntersect<T extends Object3D>(onChange: (visible: boolean) => void): React.RefObject<T>;
+
 type ScreenSpaceProps = Omit<ThreeElements['group'], 'ref'> & {
-  depth?: number;
+    depth?: number;
 };
 declare const ScreenSpace: ForwardRefComponent<ScreenSpaceProps, Group>;
-//#endregion
-//#region src/core/UI/Select/Select.d.ts
+
 type SelectProps = Omit<ThreeElements['group'], 'ref'> & {
-  multiple?: boolean;
-  box?: boolean;
-  border?: string;
-  backgroundColor?: string;
-  onChange?: (selected: THREE$1.Object3D[]) => void;
-  onChangePointerUp?: (selected: THREE$1.Object3D[]) => void;
-  filter?: (selected: THREE$1.Object3D[]) => THREE$1.Object3D[];
-};
-declare function Select({
-  box,
-  multiple,
-  children,
-  onChange,
-  onChangePointerUp,
-  border,
-  backgroundColor,
-  filter: customFilter,
-  ...props
-}: SelectProps): React$1.JSX.Element;
-declare function useSelect(): THREE$1.Object3D[];
-//#endregion
-//#region src/external/Performance/Bvh/Bvh.d.ts
+    multiple?: boolean;
+    box?: boolean;
+    border?: string;
+    backgroundColor?: string;
+    onChange?: (selected: THREE.Object3D[]) => void;
+    onChangePointerUp?: (selected: THREE.Object3D[]) => void;
+    filter?: (selected: THREE.Object3D[]) => THREE.Object3D[];
+};
+declare function Select({ box, multiple, children, onChange, onChangePointerUp, border, backgroundColor, filter: customFilter, ...props }: SelectProps): React.JSX.Element;
+declare function useSelect(): THREE.Object3D[];
+
 interface BVHOptions {
-  strategy?: SplitStrategy;
-  verbose?: boolean;
-  setBoundingBox?: boolean;
-  maxDepth?: number;
-  maxLeafTris?: number;
-  indirect?: boolean;
+    strategy?: SplitStrategy;
+    verbose?: boolean;
+    setBoundingBox?: boolean;
+    maxDepth?: number;
+    maxLeafTris?: number;
+    indirect?: boolean;
 }
 type BvhProps = BVHOptions & ThreeElements['group'] & {
-  enabled?: boolean;
-  firstHitOnly?: boolean;
+    enabled?: boolean;
+    firstHitOnly?: boolean;
 };
-declare function useBVH(mesh: React$1.RefObject<Mesh$1 | undefined>, options?: BVHOptions): void;
+declare function useBVH(mesh: React.RefObject<Mesh | undefined>, options?: BVHOptions): void;
 declare const Bvh: ForwardRefComponent<BvhProps, Group>;
-//#endregion
-//#region src/external/Controls/CameraControls/CameraControls.d.ts
+
 type CameraControlsProps = Omit<Overwrite<ThreeElement<typeof CameraControlsImpl>, {
-  impl?: typeof CameraControlsImpl;
-  camera?: PerspectiveCamera$1 | OrthographicCamera$2;
-  domElement?: HTMLElement;
-  makeDefault?: boolean;
-  onControlStart?: (e?: {
-    type: 'controlstart';
-  }) => void;
-  onControl?: (e?: {
-    type: 'control';
-  }) => void;
-  onControlEnd?: (e?: {
-    type: 'controlend';
-  }) => void;
-  onTransitionStart?: (e?: {
-    type: 'transitionstart';
-  }) => void;
-  onUpdate?: (e?: {
-    type: 'update';
-  }) => void;
-  onWake?: (e?: {
-    type: 'wake';
-  }) => void;
-  onRest?: (e?: {
-    type: 'rest';
-  }) => void;
-  onSleep?: (e?: {
-    type: 'sleep';
-  }) => void;
-  onStart?: (e?: {
-    type: 'controlstart';
-  }) => void;
-  onEnd?: (e?: {
-    type: 'controlend';
-  }) => void;
-  onChange?: (e?: {
-    type: string;
-  }) => void;
-  events?: boolean;
-  regress?: boolean;
+    impl?: typeof CameraControlsImpl;
+    camera?: PerspectiveCamera$1 | OrthographicCamera$1;
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+    onControlStart?: (e?: {
+        type: 'controlstart';
+    }) => void;
+    onControl?: (e?: {
+        type: 'control';
+    }) => void;
+    onControlEnd?: (e?: {
+        type: 'controlend';
+    }) => void;
+    onTransitionStart?: (e?: {
+        type: 'transitionstart';
+    }) => void;
+    onUpdate?: (e?: {
+        type: 'update';
+    }) => void;
+    onWake?: (e?: {
+        type: 'wake';
+    }) => void;
+    onRest?: (e?: {
+        type: 'rest';
+    }) => void;
+    onSleep?: (e?: {
+        type: 'sleep';
+    }) => void;
+    onStart?: (e?: {
+        type: 'controlstart';
+    }) => void;
+    onEnd?: (e?: {
+        type: 'controlend';
+    }) => void;
+    onChange?: (e?: {
+        type: string;
+    }) => void;
+    events?: boolean;
+    regress?: boolean;
 }>, 'ref' | 'args' | keyof EventDispatcher>;
 declare const CameraControls: ForwardRefComponent<CameraControlsProps, CameraControlsImpl>;
 type CameraControls = CameraControlsImpl;
-//#endregion
-//#region src/external/Geometry/Facemesh/Facemesh.d.ts
+
 type MediaPipeFaceMesh = typeof FacemeshDatas.SAMPLE_FACE;
 type MediaPipePoints = typeof FacemeshDatas.SAMPLE_FACE.keypoints | (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.faceLandmarks)[0];
 type FacemeshProps = {
-  points?: MediaPipePoints;
-  face?: MediaPipeFaceMesh;
-  width?: number;
-  height?: number;
-  depth?: number;
-  verticalTri?: [number, number, number];
-  origin?: number | THREE$1.Vector3;
-  facialTransformationMatrix?: (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.facialTransformationMatrixes)[0];
-  offset?: boolean;
-  offsetScalar?: number;
-  faceBlendshapes?: (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.faceBlendshapes)[0];
-  eyes?: boolean;
-  eyesAsOrigin?: boolean;
-  debug?: boolean;
-  LineComponent?: React$1.ComponentType<LineProps>;
+    points?: MediaPipePoints;
+    face?: MediaPipeFaceMesh;
+    width?: number;
+    height?: number;
+    depth?: number;
+    verticalTri?: [number, number, number];
+    origin?: number | THREE.Vector3;
+    facialTransformationMatrix?: (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.facialTransformationMatrixes)[0];
+    offset?: boolean;
+    offsetScalar?: number;
+    faceBlendshapes?: (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.faceBlendshapes)[0];
+    eyes?: boolean;
+    eyesAsOrigin?: boolean;
+    debug?: boolean;
+    LineComponent?: React.ComponentType<LineProps>;
 } & Omit<ThreeElements['group'], 'ref'>;
 type FacemeshApi = {
-  meshRef: React$1.RefObject<THREE$1.Mesh>;
-  outerRef: React$1.RefObject<THREE$1.Group>;
-  eyeRightRef: React$1.RefObject<FacemeshEyeApi>;
-  eyeLeftRef: React$1.RefObject<FacemeshEyeApi>;
+    meshRef: React.RefObject<THREE.Mesh>;
+    outerRef: React.RefObject<THREE.Group>;
+    eyeRightRef: React.RefObject<FacemeshEyeApi>;
+    eyeLeftRef: React.RefObject<FacemeshEyeApi>;
 };
-declare const Facemesh: React$1.ForwardRefExoticComponent<Omit<FacemeshProps, "ref"> & React$1.RefAttributes<FacemeshApi>>;
+declare const Facemesh: React.ForwardRefExoticComponent<Omit<FacemeshProps, "ref"> & React.RefAttributes<FacemeshApi>>;
 type FacemeshEyeProps = {
-  side: 'left' | 'right';
-  debug?: boolean;
-  LineComponent?: React$1.ComponentType<LineProps>;
+    side: 'left' | 'right';
+    debug?: boolean;
+    LineComponent?: React.ComponentType<LineProps>;
 };
 type FacemeshEyeApi = {
-  eyeMeshRef: React$1.RefObject<THREE$1.Group>;
-  irisDirRef: React$1.RefObject<THREE$1.Group>;
-  _computeSphere: (faceGeometry: THREE$1.BufferGeometry) => THREE$1.Sphere;
-  _update: (faceGeometry: THREE$1.BufferGeometry, faceBlendshapes: FacemeshProps['faceBlendshapes'], sphere?: THREE$1.Sphere) => void;
+    eyeMeshRef: React.RefObject<THREE.Group>;
+    irisDirRef: React.RefObject<THREE.Group>;
+    _computeSphere: (faceGeometry: THREE.BufferGeometry) => THREE.Sphere;
+    _update: (faceGeometry: THREE.BufferGeometry, faceBlendshapes: FacemeshProps['faceBlendshapes'], sphere?: THREE.Sphere) => void;
 };
 declare const FacemeshEyeDefaults: {
-  contourLandmarks: {
-    right: number[];
-    left: number[];
-  };
-  blendshapes: {
-    right: number[];
-    left: number[];
-  };
-  color: {
-    right: string;
-    left: string;
-  };
-  fov: {
-    horizontal: number;
-    vertical: number;
-  };
-};
-declare const FacemeshEye: React$1.ForwardRefExoticComponent<FacemeshEyeProps & React$1.RefAttributes<FacemeshEyeApi>>;
+    contourLandmarks: {
+        right: number[];
+        left: number[];
+    };
+    blendshapes: {
+        right: number[];
+        left: number[];
+    };
+    color: {
+        right: string;
+        left: string;
+    };
+    fov: {
+        horizontal: number;
+        vertical: number;
+    };
+};
+declare const FacemeshEye: React.ForwardRefExoticComponent<FacemeshEyeProps & React.RefAttributes<FacemeshEyeApi>>;
 declare const FacemeshDatas: {
-  TRIANGULATION: number[];
-  SAMPLE_FACE: {
-    keypoints: ({
-      x: number;
-      y: number;
-      z: number;
-      name: string;
-    } | {
-      x: number;
-      y: number;
-      z: number;
-      name?: undefined;
-    })[];
-    box: {
-      xMin: number;
-      yMin: number;
-      xMax: number;
-      yMax: number;
-      width: number;
-      height: number;
+    TRIANGULATION: number[];
+    SAMPLE_FACE: {
+        keypoints: ({
+            x: number;
+            y: number;
+            z: number;
+            name: string;
+        } | {
+            x: number;
+            y: number;
+            z: number;
+            name?: undefined;
+        })[];
+        box: {
+            xMin: number;
+            yMin: number;
+            xMax: number;
+            yMax: number;
+            width: number;
+            height: number;
+        };
+    };
+    SAMPLE_FACELANDMARKER_RESULT: {
+        faceLandmarks: {
+            x: number;
+            y: number;
+            z: number;
+        }[][];
+        faceBlendshapes: {
+            categories: {
+                index: number;
+                score: number;
+                categoryName: string;
+                displayName: string;
+            }[];
+            headIndex: number;
+            headName: string;
+        }[];
+        facialTransformationMatrixes: {
+            rows: number;
+            columns: number;
+            data: number[];
+        }[];
     };
-  };
-  SAMPLE_FACELANDMARKER_RESULT: {
-    faceLandmarks: {
-      x: number;
-      y: number;
-      z: number;
-    }[][];
-    faceBlendshapes: {
-      categories: {
-        index: number;
-        score: number;
-        categoryName: string;
-        displayName: string;
-      }[];
-      headIndex: number;
-      headName: string;
-    }[];
-    facialTransformationMatrixes: {
-      rows: number;
-      columns: number;
-      data: number[];
-    }[];
-  };
-};
-//#endregion
-//#region src/external/Controls/FaceControls/FaceControls.d.ts
+};
+
 type FaceControlsProps = {
-  camera?: THREE$1.Camera;
-  videoTexture?: VideoTextureProps;
-  manualDetect?: boolean;
-  faceLandmarkerResult?: FaceLandmarkerResult;
-  manualUpdate?: boolean;
-  makeDefault?: boolean;
-  smoothTime?: number;
-  offset?: boolean;
-  offsetScalar?: number;
-  eyes?: boolean;
-  eyesAsOrigin?: boolean;
-  depth?: number;
-  debug?: boolean;
-  facemesh?: FacemeshProps;
-};
-type FaceControlsApi = THREE$1.EventDispatcher & {
-  computeTarget: () => THREE$1.Object3D;
-  update: (delta: number, target?: THREE$1.Object3D) => void;
-  facemeshApiRef: RefObject<FacemeshApi>;
-};
-declare const FaceControls: React$1.ForwardRefExoticComponent<FaceControlsProps & React$1.RefAttributes<FaceControlsApi>>;
+    camera?: THREE.Camera;
+    videoTexture?: VideoTextureProps;
+    manualDetect?: boolean;
+    faceLandmarkerResult?: FaceLandmarkerResult;
+    manualUpdate?: boolean;
+    makeDefault?: boolean;
+    smoothTime?: number;
+    offset?: boolean;
+    offsetScalar?: number;
+    eyes?: boolean;
+    eyesAsOrigin?: boolean;
+    depth?: number;
+    debug?: boolean;
+    facemesh?: FacemeshProps;
+};
+type FaceControlsApi = THREE.EventDispatcher & {
+    computeTarget: () => THREE.Object3D;
+    update: (delta: number, target?: THREE.Object3D) => void;
+    facemeshApiRef: RefObject<FacemeshApi>;
+};
+declare const FaceControls: React.ForwardRefExoticComponent<FaceControlsProps & React.RefAttributes<FaceControlsApi>>;
 declare const useFaceControls: () => FaceControlsApi;
-//#endregion
-//#region src/external/Geometry/Splat/Splat.d.ts
+
 type SplatMaterialType = {
-  alphaTest?: number;
-  alphaHash?: boolean;
-  centerAndScaleTexture?: THREE$1.DataTexture;
-  covAndColorTexture?: THREE$1.DataTexture;
-  viewport?: THREE$1.Vector2;
-  focal?: number;
-};
-type TargetMesh = THREE$1.Mesh<THREE$1.InstancedBufferGeometry, THREE$1.ShaderMaterial & SplatMaterialType> & {
-  ready: boolean;
-  sorted: boolean;
-  pm: THREE$1.Matrix4;
-  vm1: THREE$1.Matrix4;
-  vm2: THREE$1.Matrix4;
-  viewport: THREE$1.Vector4;
+    alphaTest?: number;
+    alphaHash?: boolean;
+    centerAndScaleTexture?: THREE.DataTexture;
+    covAndColorTexture?: THREE.DataTexture;
+    viewport?: THREE.Vector2;
+    focal?: number;
+};
+type TargetMesh = THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial & SplatMaterialType> & {
+    ready: boolean;
+    sorted: boolean;
+    pm: THREE.Matrix4;
+    vm1: THREE.Matrix4;
+    vm2: THREE.Matrix4;
+    viewport: THREE.Vector4;
 };
 type SharedState = {
-  url: string;
-  gl: THREE$1.WebGLRenderer;
-  worker: Worker;
-  manager: THREE$1.LoadingManager;
-  stream: ReadableStreamDefaultReader<Uint8Array>;
-  loading: boolean;
-  loaded: boolean;
-  loadedVertexCount: number;
-  rowLength: number;
-  maxVertexes: number;
-  chunkSize: number;
-  totalDownloadBytes: number;
-  numVertices: number;
-  bufferTextureWidth: number;
-  bufferTextureHeight: number;
-  centerAndScaleData: Float32Array;
-  covAndColorData: Uint32Array;
-  covAndColorTexture: THREE$1.DataTexture;
-  centerAndScaleTexture: THREE$1.DataTexture;
-  connect(target: TargetMesh): () => void;
-  update(target: TargetMesh, camera: THREE$1.Camera, hashed: boolean): void;
-  onProgress?: (event: ProgressEvent) => void;
+    url: string;
+    gl: THREE.WebGLRenderer;
+    worker: Worker;
+    manager: THREE.LoadingManager;
+    stream: ReadableStreamDefaultReader<Uint8Array>;
+    loading: boolean;
+    loaded: boolean;
+    loadedVertexCount: number;
+    rowLength: number;
+    maxVertexes: number;
+    chunkSize: number;
+    totalDownloadBytes: number;
+    numVertices: number;
+    bufferTextureWidth: number;
+    bufferTextureHeight: number;
+    centerAndScaleData: Float32Array;
+    covAndColorData: Uint32Array;
+    covAndColorTexture: THREE.DataTexture;
+    centerAndScaleTexture: THREE.DataTexture;
+    connect(target: TargetMesh): () => void;
+    update(target: TargetMesh, camera: THREE.Camera, hashed: boolean): void;
+    onProgress?: (event: ProgressEvent) => void;
 };
 declare module '@react-three/fiber' {
-  interface ThreeElements {
-    splatMaterial: SplatMaterialType & ThreeElements['shaderMaterial'];
-  }
+    interface ThreeElements {
+        splatMaterial: SplatMaterialType & ThreeElements['shaderMaterial'];
+    }
 }
 type SplatProps = {
-  src: string;
-  toneMapped?: boolean;
-  alphaTest?: number;
-  alphaHash?: boolean;
-  chunkSize?: number;
+    src: string;
+    toneMapped?: boolean;
+    alphaTest?: number;
+    alphaHash?: boolean;
+    chunkSize?: number;
 } & Omit<ThreeElements['mesh'], 'ref'>;
-declare function Splat({
-  src,
-  toneMapped,
-  alphaTest,
-  alphaHash,
-  chunkSize,
-  ...props
-}: SplatProps): React$1.JSX.Element;
-//#endregion
-//#region src/external/Helpers/FaceLandmarker/FaceLandmarker.d.ts
+declare function Splat({ src, toneMapped, alphaTest, alphaHash, chunkSize, ...props }: SplatProps): React.JSX.Element;
+
 type FaceLandmarkerProps = {
-  basePath?: string;
-  options?: FaceLandmarkerOptions;
-  children?: ReactNode;
+    basePath?: string;
+    options?: FaceLandmarkerOptions;
+    children?: ReactNode;
 };
 declare const FaceLandmarkerDefaults: {
-  basePath: string;
-  options: FaceLandmarkerOptions;
+    basePath: string;
+    options: FaceLandmarkerOptions;
 };
-declare const FaceLandmarker: React$1.ForwardRefExoticComponent<FaceLandmarkerProps & React$1.RefAttributes<FaceLandmarker$1>>;
+declare const FaceLandmarker: React.ForwardRefExoticComponent<FaceLandmarkerProps & React.RefAttributes<FaceLandmarker$1>>;
 declare function useFaceLandmarker(): FaceLandmarker$1 | undefined;
-//#endregion
-//#region src/experimental/Geometry/MarchingCubes/MarchingCubes.d.ts
+
 type MarchingCubesProps = {
-  resolution?: number;
-  maxPolyCount?: number;
-  enableUvs?: boolean;
-  enableColors?: boolean;
+    resolution?: number;
+    maxPolyCount?: number;
+    enableUvs?: boolean;
+    enableColors?: boolean;
 } & Omit<ThreeElements['group'], 'ref'>;
 declare const MarchingCubes: ForwardRefComponent<MarchingCubesProps, MarchingCubes$1>;
 type MarchingCubeProps = {
-  strength?: number;
-  subtract?: number;
-  color?: Color$2;
+    strength?: number;
+    subtract?: number;
+    color?: Color;
 } & ThreeElements['group'];
-declare const MarchingCube: ForwardRefComponent<MarchingCubeProps, THREE$1.Group>;
+declare const MarchingCube: ForwardRefComponent<MarchingCubeProps, THREE.Group>;
 type MarchingPlaneProps = {
-  planeType?: 'x' | 'y' | 'z';
-  strength?: number;
-  subtract?: number;
+    planeType?: 'x' | 'y' | 'z';
+    strength?: number;
+    subtract?: number;
 } & ThreeElements['group'];
-declare const MarchingPlane: ForwardRefComponent<MarchingPlaneProps, THREE$1.Group>;
-//#endregion
-export { AdaptiveDpr, AdaptiveEvents, ArcballControls, ArcballControlsProps, Args, BBAnchor, BBAnchorProps, BVHOptions, Backdrop, BackdropProps, Billboard, BillboardProps, Bounds, BoundsApi, BoundsProps, Box, Bvh, BvhProps, CalculatePosition, CameraControls, CameraControlsImpl, CameraControlsProps, CameraShake, CameraShakeProps, Capsule, CatmullRomLine, CatmullRomLineProps, Center, CenterProps, Circle, Clone, CloneProps, Cloud, CloudInstance, CloudProps, Clouds, CloudsProps, ComputedAttribute, ComputedAttributeProps, Cone, ContainerProps, CubeCamera, CubeCameraOptions, CubeCameraProps, CubeTexture, CubeTextureProps, CubicBezierLine, CubicBezierLineProps, CurveModifier, CurveModifierProps, CurveModifierRef, CycleRaycast, CycleRaycastProps, Cylinder, Decal, DecalProps, Detailed, DetailedProps, DetectGPU, DetectGPUProps, DeviceOrientationControls, DeviceOrientationControlsProps, Dodecahedron, DragControls, DragControlsProps, Edges, EdgesProps, Environment, EnvironmentCube, EnvironmentLoaderProps, EnvironmentMap, EnvironmentPortal, EnvironmentProps, Example, ExampleApi, ExampleProps, Extrude, FaceControls, FaceControlsApi, FaceControlsProps, FaceLandmarker, FaceLandmarkerDefaults, FaceLandmarkerProps, Facemesh, FacemeshApi, FacemeshDatas, FacemeshEye, FacemeshEyeApi, FacemeshEyeDefaults, FacemeshEyeProps, FacemeshProps, Fbo, FboProps, Fbx, FirstPersonControls, FirstPersonControlsProps, Fisheye, FisheyeProps, Float, FloatProps, FlyControls, FlyControlsProps, FontData, FrameData, GizmoHelper, GizmoHelperProps, GizmoViewcube, GizmoViewport, Gltf, GltfProps, Glyph, Helper, HelperProps, Html, HtmlProps, Hud, HudProps, Icosahedron, Instance, InstanceProps, InstancedAttribute, InstancedAttributeProps, Instances, InstancesProps, IsObject, KeyboardControls, KeyboardControlsEntry, KeyboardControlsProps, Ktx2, Lathe, LightProps, Lightformer, Loader, LoaderOptions, MapControls, MapControlsProps, MarchingCube, MarchingCubeProps, MarchingCubes, MarchingCubesProps, MarchingPlane, MarchingPlaneProps, Mask, MaskProps, MatcapTexture, MediaPipeFaceMesh, MediaPipePoints, Merged, MergedProps, MetaData, MotionPathControls, MotionPathProps, MotionPathRef, NormalTexture, Octahedron, OnCenterCallbackProps, OrbitControls, OrbitControlsChangeEvent, OrbitControlsProps, OrthographicCamera, OrthographicCameraProps, Outlines, OutlinesProps, PerformanceMonitor, PerformanceMonitorApi, PerformanceMonitorProps, PerspectiveCamera, PerspectiveCameraProps, PivotControls, PivotControlsProps, Plane, Point, PointMaterial, PointMaterialImpl, PointMaterialProps, PointerLockControls, PointerLockControlsProps, Points, PointsBuffer, PointsBuffersProps, PointsInstancesProps, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, PositionalAudioProps, Preload, PreloadProps, PresentationControlProps, PresentationControls, PresetsType, Progress, QuadraticBezierLine, QuadraticBezierLineProps, QuadraticBezierLineRef, RenderCubeTexture, RenderCubeTextureApi, RenderCubeTextureProps, RenderTexture, type RenderTextureProps, Resize, ResizeProps, Ring, RoundedBox, RoundedBoxGeometry, RoundedBoxGeometryProps, RoundedBoxProps, Sampler, SamplerProps, ScreenQuad, ScreenQuadProps, ScreenSizer, ScreenSizerProps, ScreenSpace, ScreenSpaceProps, ScreenVideoTexture, ScreenVideoTextureProps, Scroll, ScrollControls, ScrollControlsProps, ScrollControlsState, ScrollProps, Select, SelectProps, Shadow, ShadowProps, ShadowType, ShakeController, Shape, ShapeProps, SharedState, Size, SizeProps, Sky, SkyProps, Sphere, Splat, SplatMaterialType, SplatProps, SpriteAnimator, SpriteAnimatorProps, SpriteData, Stage, StageProps, Stats, StatsGl, StatsGlProps, StatsProps, Svg, SvgProps, TargetMesh, Tetrahedron, Text3D, Text3DProps, Texture, Torus, TorusKnot, TrackballControls, TrackballControlsProps, Trail, type TrailProps, TrailTexture, TrailTextureProps, TransformControls, TransformControlsProps, TransformFn, Tube, VideoTexture, VideoTextureProps, View, ViewProps, ViewportProps, WebcamVideoTexture, WebcamVideoTextureProps, Wireframe, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, meshBounds, presetsObj, useAnimations, useAspect, useBVH, useBounds, useContextBridge, useCubeCamera, useCubeTexture, useCursor, useCustomRaycast, useDepthBuffer, useDetectGPU, useEnvironment, useFBO, useFBX, useFaceControls, useFaceLandmarker, useFont, useGLTF, useGizmoContext, useHelper, useIntersect, useKTX2, useKeyboardControls, useMask, useMatcapTexture, useMotion, useNormalTexture, usePerformanceMonitor, useProgress, useScroll, useSelect, useSpriteAnimator, useSpriteLoader, useSurfaceSampler, useSurfaceSamplerProps, useTexture, useTrail, useTrailTexture, useVideoTexture };
+declare const MarchingPlane: ForwardRefComponent<MarchingPlaneProps, THREE.Group>;
+
+export { AdaptiveDpr, AdaptiveEvents, ArcballControls, BBAnchor, Backdrop, Billboard, Bounds, Box, Bvh, CameraControls, CameraShake, Capsule, CatmullRomLine, Center, Circle, Clone, Cloud, CloudInstance, Clouds, ComputedAttribute, Cone, CubeCamera, CubeTexture, CubicBezierLine, CurveModifier, CycleRaycast, Cylinder, Decal, Detailed, DetectGPU, DeviceOrientationControls, Dodecahedron, DragControls, Edges, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, Example, Extrude, FaceControls, FaceLandmarker, FaceLandmarkerDefaults, Facemesh, FacemeshDatas, FacemeshEye, FacemeshEyeDefaults, Fbo, Fbx, FirstPersonControls, Fisheye, Float, FlyControls, GizmoHelper, GizmoViewcube, GizmoViewport, Gltf, Helper, Html, Hud, Icosahedron, Instance, InstancedAttribute, Instances, IsObject, KeyboardControls, Ktx2, Lathe, Lightformer, Loader, MapControls, MarchingCube, MarchingCubes, MarchingPlane, Mask, MatcapTexture, Merged, MotionPathControls, NormalTexture, Octahedron, OrbitControls, OrthographicCamera, Outlines, PerformanceMonitor, PerspectiveCamera, PivotControls, Plane, Point, PointMaterial, PointMaterialImpl, PointerLockControls, Points, PointsBuffer, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, Preload, PresentationControls, Progress, QuadraticBezierLine, RenderCubeTexture, RenderTexture, Resize, Ring, RoundedBox, RoundedBoxGeometry, Sampler, ScreenQuad, ScreenSizer, ScreenSpace, ScreenVideoTexture, Scroll, ScrollControls, Select, Shadow, Shape, Sky, Sphere, Splat, SpriteAnimator, Stage, Stats, StatsGl, Svg, Tetrahedron, Text3D, Texture, Torus, TorusKnot, TrackballControls, Trail, TrailTexture, TransformControls, Tube, VideoTexture, View, WebcamVideoTexture, Wireframe, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, meshBounds, presetsObj, useAnimations, useAspect, useBVH, useBounds, useContextBridge, useCubeCamera, useCubeTexture, useCursor, useCustomRaycast, useDepthBuffer, useDetectGPU, useEnvironment, useFBO, useFBX, useFaceControls, useFaceLandmarker, useFont, useGLTF, useGizmoContext, useHelper, useIntersect, useKTX2, useKeyboardControls, useMask, useMatcapTexture, useMotion, useNormalTexture, usePerformanceMonitor, useProgress, useScroll, useSelect, useSpriteAnimator, useSpriteLoader, useSurfaceSampler, useTexture, useTrail, useTrailTexture, useVideoTexture };
+export type { ArcballControlsProps, Args, BBAnchorProps, BVHOptions, BackdropProps, BillboardProps, BoundsApi, BoundsProps, BvhProps, CalculatePosition, CameraControlsProps, CameraShakeProps, CatmullRomLineProps, CenterProps, CloneProps, CloudProps, CloudsProps, ComputedAttributeProps, ContainerProps, CubeCameraOptions, CubeCameraProps, CubeTextureProps, CubicBezierLineProps, CurveModifierProps, CurveModifierRef, CycleRaycastProps, DecalProps, DetailedProps, DetectGPUProps, DeviceOrientationControlsProps, DragControlsProps, EdgesProps, EnvironmentLoaderProps, EnvironmentProps, ExampleApi, ExampleProps, FaceControlsApi, FaceControlsProps, FaceLandmarkerProps, FacemeshApi, FacemeshEyeApi, FacemeshEyeProps, FacemeshProps, FboProps, FirstPersonControlsProps, FisheyeProps, FloatProps, FlyControlsProps, FontData, FrameData, GizmoHelperProps, GltfProps, Glyph, HelperProps, HtmlProps, HudProps, InstanceProps, InstancedAttributeProps, InstancesProps, KeyboardControlsEntry, KeyboardControlsProps, LightProps, LoaderOptions, MapControlsProps, MarchingCubeProps, MarchingCubesProps, MarchingPlaneProps, MaskProps, MediaPipeFaceMesh, MediaPipePoints, MergedProps, MetaData, MotionPathProps, MotionPathRef, OnCenterCallbackProps, OrbitControlsChangeEvent, OrbitControlsProps, OrthographicCameraProps, OutlinesProps, PerformanceMonitorApi, PerformanceMonitorProps, PerspectiveCameraProps, PivotControlsProps, PointMaterialProps, PointerLockControlsProps, PointsBuffersProps, PointsInstancesProps, PositionalAudioProps, PreloadProps, PresentationControlProps, PresetsType, QuadraticBezierLineProps, QuadraticBezierLineRef, RenderCubeTextureApi, RenderCubeTextureProps, RenderTextureProps, ResizeProps, RoundedBoxGeometryProps, RoundedBoxProps, SamplerProps, ScreenQuadProps, ScreenSizerProps, ScreenSpaceProps, ScreenVideoTextureProps, ScrollControlsProps, ScrollControlsState, ScrollProps, SelectProps, ShadowProps, ShadowType, ShakeController, ShapeProps, SharedState, Size, SizeProps, SkyProps, SplatMaterialType, SplatProps, SpriteAnimatorProps, SpriteData, StageProps, StatsGlProps, StatsProps, SvgProps, TargetMesh, Text3DProps, TrackballControlsProps, TrailProps, TrailTextureProps, TransformControlsProps, TransformFn, VideoTextureProps, ViewProps, ViewportProps, WebcamVideoTextureProps, useSurfaceSamplerProps };