@react-three/drei 10.7.6 → 10.8.0-alpha.1

package/index.d.mts

@@ -0,0 +1,2567 @@
+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_js0 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
+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 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
+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;
+};
+type SoftShadowMaterialProps = {
+  map: THREE$1.Texture;
+  color?: ReactThreeFiber.Color;
+  alphaTest?: number;
+  blend?: number;
+};
+declare module '@react-three/fiber' {
+  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
+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;
+    };
+  }
+}
+//#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];
+};
+declare module '@react-three/fiber' {
+  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);
+}
+//#endregion
+//#region src/legacy/Materials/MeshReflectorMaterial/MeshReflectorMaterial.d.ts
+declare module '@react-three/fiber' {
+  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;
+    };
+  }
+}
+//#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;
+    };
+  }
+}
+//#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;
+    };
+  }
+}
+//#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
+declare module '@react-three/fiber' {
+  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
+type LineProps = Omit<{
+  points: ReadonlyArray<Vector2 | Vector3>;
+  vertexColors?: ReadonlyArray<Color$1 | [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;
+}, 'ref'>;
+//#endregion
+//#region src/legacy/Geometry/Segments/Segments.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    segmentObject: ThreeElement<typeof SegmentObject>;
+  }
+}
+declare class SegmentObject {
+  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;
+};
+type TrailProps = {
+  color?: ColorRepresentation;
+  attenuation?: (t: number) => number;
+  target?: React$1.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
+type CubeCameraOptions = {
+  resolution?: number;
+  near?: number;
+  far?: number;
+  envMap?: Texture$2;
+  fog?: Fog | FogExp2;
+};
+type CubeCameraProps = Omit<ThreeElements['group'], 'children'> & {
+  children?: (tex: Texture$2) => React$1.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
+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
+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;
+};
+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;
+}>, '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;
+};
+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
+type FirstPersonControlsProps = Omit<ThreeElement<typeof FirstPersonControls$1>, 'ref' | 'args'> & {
+  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;
+};
+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 };
+type KeyboardControlsEntry<T extends string = string> = {
+  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;
+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>(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;
+}>, '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;
+};
+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;
+};
+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
+type ExtractCallback<T, E extends string> = T extends {
+  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;
+}>, '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;
+};
+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
+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;
+};
+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;
+};
+declare function useScroll(): ScrollControlsState;
+declare function ScrollControls({
+  eps,
+  enabled,
+  infinite,
+  horizontal,
+  pages,
+  distance,
+  damping,
+  maxSpeed,
+  prepend,
+  style,
+  children
+}: ScrollControlsProps): React$1.JSX.Element;
+interface ScrollPropsWithFalseHtml {
+  children?: React$1.ReactNode;
+  html?: false;
+  style?: never;
+}
+interface ScrollPropsWithTrueHtml {
+  children?: React$1.ReactNode;
+  html: true;
+  style?: React$1.CSSProperties;
+}
+type ScrollProps = ScrollPropsWithFalseHtml | ScrollPropsWithTrueHtml;
+declare const Scroll: ForwardRefComponent<ScrollProps, THREE$1.Group & HTMLDivElement>;
+//#endregion
+//#region src/core/Controls/TrackballControls/TrackballControls.d.ts
+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;
+}>, '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;
+}
+interface CameraShakeProps {
+  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;
+};
+type CloudsProps = Omit<ThreeElements['group'], 'ref'> & {
+  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;
+    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
+type CatmullRomLineProps = Omit<LineProps, 'ref' | 'segments'> & {
+  closed?: boolean;
+  curveType?: 'centripetal' | 'chordal' | 'catmullrom';
+  tension?: number;
+  segments?: number;
+  LineComponent?: React$1.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>;
+};
+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>;
+}
+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 DetailedProps = Omit<ThreeElements['lOD'], 'ref'> & {
+  children: React$1.ReactElement<Object3D$1>[];
+  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>;
+}
+interface EdgesRef {
+  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>;
+  }
+}
+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;
+}
+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
+type QuadraticBezierLineRef = Line2 & {
+  setPoints(start: Vector3$2 | [number, number, number], end: Vector3$2 | [number, number, number], mid: Vector3$2 | [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>;
+};
+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;
+} & Omit<ThreeElements['mesh'], 'ref' | 'args'>;
+type RoundedBoxGeometryProps = Omit<RoundedBoxProps, 'children'> & Omit<ThreeElements['extrudeGeometry'], 'args' | 'ref'>;
+declare const RoundedBox: ForwardRefComponent<RoundedBoxProps, Mesh$1>;
+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;
+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
+type Glyph = {
+  _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>;
+};
+type FontInput = string | FontData;
+declare function useFont(font: FontInput): three_examples_jsm_loaders_FontLoader0.Font;
+declare namespace useFont {
+  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>;
+  }
+}
+type Text3DProps = Omit<ThreeElements['mesh'], 'ref'> & {
+  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 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;
+}> & {
+  key: string;
+};
+//#endregion
+//#region src/core/Geometry/Wireframe/Wireframe.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshWireframeMaterial: ThreeElement<typeof WireframeMaterial>;
+  }
+}
+interface WireframeProps {
+  geometry?: THREE$1.BufferGeometry | React$1.RefObject<THREE$1.BufferGeometry>;
+  simplify?: boolean;
+}
+declare function Wireframe({
+  geometry: customGeometry,
+  ...props
+}: WireframeProps & WireframeMaterialProps): React$1.JSX.Element;
+//#endregion
+//#region src/core/Gizmos/gizmo/GizmoHelper.d.ts
+type GizmoHelperContext = {
+  tweenCamera: (direction: Vector3$2) => 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
+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
+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
+type OnDragStartProps = {
+  component: 'Arrow' | 'Slider' | 'Rotator' | 'Sphere';
+  axis: 0 | 1 | 2;
+  origin: THREE$1.Vector3;
+  directions: THREE$1.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
+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;
+};
+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 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>;
+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 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;
+};
+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>;
+  }
+}
+type Api$1 = {
+  getParent: () => React$1.RefObject<InstancedMesh$1>;
+  subscribe: <T>(ref: React$1.RefObject<T>) => void;
+};
+type InstancesProps = Omit<ThreeElements['instancedMesh'], 'ref' | 'args'> & {
+  context?: React$1.Context<Api$1>;
+  range?: number;
+  limit?: number;
+  frames?: number;
+};
+type InstanceProps = Omit<ThreeElements['positionMesh'], 'ref'> & {
+  context?: React$1.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;
+}
+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>;
+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;
+}
+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
+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 MetaData = {
+  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;
+};
+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 namespace useSpriteLoader {
+  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;
+};
+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 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;
+} & Omit<ThreeElements['group'], 'ref'>;
+type SpriteAnimatorState = {
+  current?: number;
+  offset?: number;
+  imageUrl?: string;
+  hasEnded: boolean;
+  ref: React$1.Ref<THREE$1.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
+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
+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
+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
+type ExampleProps = {
+  font: string;
+  color?: Color;
+  debug?: boolean;
+  bevelSize?: number;
+} & React$1.ComponentProps<'group'>;
+type ExampleApi = {
+  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
+type SamplePayload = {
+  position: Vector3$2;
+  normal: Vector3$2;
+  color: Color$2;
+};
+type TransformFn = (payload: TransformPayload, i: number) => void;
+type TransformPayload = SamplePayload & {
+  dummy: Object3D$1;
+  sampledMesh: Mesh$1;
+};
+type SamplerProps = Omit<ThreeElements['group'], 'ref'> & {
+  mesh?: React$1.RefObject<Mesh$1>;
+  instances?: React$1.RefObject<InstancedMesh>;
+  weight?: string;
+  transform?: TransformFn;
+  count?: number;
+};
+interface useSurfaceSamplerProps {
+  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
+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'];
+}
+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;
+}): DepthTexture | null;
+//#endregion
+//#region src/core/Textures/CubeTexture/CubeTexture.d.ts
+interface CubeTextureOptions {
+  path: string;
+}
+interface CubeTextureProps extends CubeTextureOptions {
+  children?: (texture: CubeTexture$1) => React$1.ReactNode;
+  files: string[];
+}
+declare function useCubeTexture(files: string[], {
+  path
+}: CubeTextureOptions): CubeTexture$1;
+declare namespace useCubeTexture {
+  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
+interface LoaderOptions {
+  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
+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>;
+type UseVideoTextureParams = Parameters<typeof useVideoTexture>;
+type VideoTexture = ReturnType<typeof useVideoTexture>;
+type VideoTextureProps = {
+  children?: (texture: VideoTexture) => React$1.ReactNode;
+  src: UseVideoTextureParams[0];
+} & UseVideoTextureParams[1];
+declare const VideoTexture: React$1.ForwardRefExoticComponent<{
+  children?: (texture: VideoTexture) => React$1.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
+type ScreenVideoTextureProps = Omit<VideoTextureProps, 'src'> & {
+  options?: DisplayMediaStreamOptions;
+};
+declare const ScreenVideoTexture: React$1.ForwardRefExoticComponent<Omit<{
+  children?: (texture: THREE$1.VideoTexture<HTMLVideoElement>) => React$1.ReactNode;
+  src: string | MediaProvider | null;
+} & {
+  unsuspend?: keyof HTMLVideoElementEventMap;
+  start?: boolean;
+  hls?: Parameters<(userConfig?: Partial<hls_js0.HlsConfig> | undefined) => Promise<hls_js0.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
+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];
+type TrailTextureProps = {
+  children?: (texture: ReturnType<typeof useTrailTexture>) => React$1.ReactNode;
+} & TrailConfig;
+declare const TrailTexture: ({
+  children,
+  ...config
+}: TrailTextureProps) => React$1.JSX.Element;
+//#endregion
+//#region src/core/Loaders/useFBX/useFBX.d.ts
+declare function useFBX(path: string): Group;
+declare namespace useFBX {
+  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
+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;
+};
+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;
+declare namespace useKTX2 {
+  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
+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;
+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;
+}
+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
+type WebcamVideoTextureProps = Omit<VideoTextureProps, 'src'> & {
+  constraints?: MediaStreamConstraints;
+};
+declare const WebcamVideoTexture: React$1.ForwardRefExoticComponent<Omit<{
+  children?: (texture: THREE$1.VideoTexture<HTMLVideoElement>) => React$1.ReactNode;
+  src: string | MediaProvider | null;
+} & {
+  unsuspend?: keyof HTMLVideoElementEventMap;
+  start?: boolean;
+  hls?: Parameters<(userConfig?: Partial<hls_js0.HlsConfig> | undefined) => Promise<hls_js0.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;
+}): 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;
+type DetectGPUProps = {
+  children?: (result: ReturnType<typeof useDetectGPU>) => React$1.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 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;
+};
+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;
+};
+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
+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
+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>;
+};
+declare const StatsGl: ForwardRefComponent<StatsGlProps, HTMLDivElement>;
+//#endregion
+//#region src/core/Portal/Fbo/Fbo.d.ts
+type FBOSettings = {
+  depth?: boolean;
+} & RenderTargetOptions;
+declare function useFBO(width?: number | FBOSettings, height?: number, settings?: FBOSettings): THREE$1.WebGLRenderTarget<THREE$1.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];
+} & FBOSettings;
+declare const Fbo: React$1.ForwardRefExoticComponent<{
+  children?: (target: Fbo) => React$1.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
+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
+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
+type MaskProps = Omit<ThreeElements['mesh'], 'ref' | 'id'> & {
+  id: number;
+  colorWrite?: boolean;
+  depthWrite?: boolean;
+};
+declare const Mask: ForwardRefComponent<MaskProps, THREE$1.Mesh>;
+declare function useMask(id: number, inverse?: boolean): {
+  stencilWrite: boolean;
+  stencilRef: number;
+  stencilFunc: 514 | 517;
+  stencilFail: 7680;
+  stencilZFail: 7680;
+  stencilZPass: 7680;
+};
+//#endregion
+//#region src/core/Portal/RenderCubeTexture/RenderCubeTexture.d.ts
+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;
+};
+type RenderCubeTextureApi = {
+  scene: THREE$1.Scene;
+  fbo: THREE$1.WebGLCubeRenderTarget;
+  camera: THREE$1.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
+type CanvasSize = {
+  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;
+};
+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>;
+};
+type ViewportProps = {
+  Port: () => React$1.JSX.Element;
+} & React$1.ForwardRefExoticComponent<ViewProps & React$1.RefAttributes<HTMLElement | THREE$1.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
+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
+type BillboardProps = Omit<ThreeElements['group'], 'ref'> & {
+  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;
+};
+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;
+};
+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;
+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;
+};
+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;
+};
+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;
+};
+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>): Texture$2<unknown> | CubeTexture$1<unknown>;
+declare namespace useEnvironment {
+  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;
+  };
+} & 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 module '@react-three/fiber' {
+  interface ThreeElements {
+    groundProjectedEnvImpl: ThreeElement<typeof GroundedSkybox>;
+  }
+}
+declare function Environment(props: EnvironmentProps): React$1.JSX.Element;
+//#endregion
+//#region src/core/Staging/Float/Float.d.ts
+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
+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
+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
+type ScreenSizerProps = Omit<ThreeElements['object3D'], 'ref'> & {
+  scale?: number;
+};
+declare const ScreenSizer: ForwardRefComponent<ScreenSizerProps, Object3D$1>;
+//#endregion
+//#region src/core/Staging/Shadow/Shadow.d.ts
+type ShadowProps = Omit<ThreeElements['mesh'], 'ref'> & {
+  colorStop?: number;
+  fog?: boolean;
+  color?: Color$2 | number | string;
+  opacity?: number;
+  depthWrite?: boolean;
+};
+type ShadowType = Mesh$1<PlaneGeometry$1, MeshBasicMaterial$1>;
+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;
+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 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
+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
+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;
+}): 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;
+}
+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
+type ScreenSpaceProps = Omit<ThreeElements['group'], 'ref'> & {
+  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
+interface BVHOptions {
+  strategy?: SplitStrategy;
+  verbose?: boolean;
+  setBoundingBox?: boolean;
+  maxDepth?: number;
+  maxLeafTris?: number;
+  indirect?: boolean;
+}
+type BvhProps = BVHOptions & ThreeElements['group'] & {
+  enabled?: boolean;
+  firstHitOnly?: boolean;
+};
+declare function useBVH(mesh: React$1.RefObject<Mesh$1 | 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;
+}>, '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>;
+} & 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>;
+};
+declare const Facemesh: React$1.ForwardRefExoticComponent<Omit<FacemeshProps, "ref"> & React$1.RefAttributes<FacemeshApi>>;
+type FacemeshEyeProps = {
+  side: 'left' | 'right';
+  debug?: boolean;
+  LineComponent?: React$1.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;
+};
+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>>;
+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;
+    };
+  };
+  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>>;
+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;
+};
+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;
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    splatMaterial: SplatMaterialType & ThreeElements['shaderMaterial'];
+  }
+}
+type SplatProps = {
+  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
+type FaceLandmarkerProps = {
+  basePath?: string;
+  options?: FaceLandmarkerOptions;
+  children?: ReactNode;
+};
+declare const FaceLandmarkerDefaults: {
+  basePath: string;
+  options: FaceLandmarkerOptions;
+};
+declare const FaceLandmarker: React$1.ForwardRefExoticComponent<FaceLandmarkerProps & React$1.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;
+} & Omit<ThreeElements['group'], 'ref'>;
+declare const MarchingCubes: ForwardRefComponent<MarchingCubesProps, MarchingCubes$1>;
+type MarchingCubeProps = {
+  strength?: number;
+  subtract?: number;
+  color?: Color$2;
+} & ThreeElements['group'];
+declare const MarchingCube: ForwardRefComponent<MarchingCubeProps, THREE$1.Group>;
+type MarchingPlaneProps = {
+  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 };