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

package/native/native/index.d.mts

@@ -0,0 +1,3168 @@
+import * as React$1 from "react";
+import { CSSProperties, ForwardRefExoticComponent, PropsWithoutRef, RefAttributes } 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 * as THREE from "three/webgpu";
+import { Color as Color$1, ColorRepresentation, MeshBasicNodeMaterial, MeshNormalNodeMaterial, MeshPhysicalNodeMaterial, Object3D, SpriteNodeMaterial } from "three/webgpu";
+import { Fn, reflector, uniform } from "three/tsl";
+import { Line2 } from "three/examples/jsm/lines/webgpu/Line2.js";
+import { LineSegments2 } from "three/examples/jsm/lines/webgpu/LineSegments2.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 * as THREE$1 from "three";
+import { Color as Color$2, ColorRepresentation as ColorRepresentation$1, WebGLCubeRenderTarget as CubeRenderTarget } from "three";
+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 * as THREE$2 from "#three";
+import { AnimationAction, AnimationClip, AnimationMixer, Box3, BufferAttribute, BufferGeometry, Camera, Color as Color$3, ColorSpace, CubeCamera as CubeCamera$1, CubeTexture as CubeTexture$1, DepthTexture, Event, 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, SpotLight as SpotLight$1, Texture as Texture$2, Vector3 as Vector3$3, WebGLRenderTarget as WebGLRenderTarget$1, WebGLRenderer as WebGLRenderer$1 } from "#three";
+import "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 { Line2 as Line2$1 } from "three/examples/jsm/lines/Line2.js";
+import "three/examples/jsm/lines/LineSegments2.js";
+import { LineMaterial, LineMaterialParameters } from "three/examples/jsm/lines/LineMaterial.js";
+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";
+
+//#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$1 = 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$2.ColorRepresentation;
+  depthWrite?: boolean;
+};
+//#endregion
+//#region src/legacy/Materials/AccumulativeShadows/AccumulativeShadows.d.ts
+type AccumulativeShadowsProps$1 = 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$1 = {
+  map: THREE$2.Texture;
+  color?: ReactThreeFiber.Color;
+  alphaTest?: number;
+  blend?: number;
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps$1;
+  }
+}
+type RandomizedLightProps$1 = 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$2.Matrix4;
+      };
+      color?: ReactThreeFiber.Color;
+      causticsTexture?: THREE$2.Texture;
+      causticsTextureB?: THREE$2.Texture;
+      lightProjMatrix?: THREE$2.Matrix4;
+      lightViewMatrix?: THREE$2.Matrix4;
+    };
+  }
+}
+//#endregion
+//#region src/legacy/Materials/MeshTransmissionMaterial/MeshTransmissionMaterial.d.ts
+type MeshTransmissionMaterialType$1 = 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$2.Texture;
+  time?: number;
+  args?: [samples: number, transmissionSampler: boolean];
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshTransmissionMaterial: MeshTransmissionMaterialType$1;
+  }
+}
+//#endregion
+//#region src/legacy/Materials/MeshReflectorMaterial/MeshReflectorMaterialClass.d.ts
+declare class MeshReflectorMaterial$2 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$2>;
+  }
+}
+//#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$2.Texture;
+      map?: THREE$2.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/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$2.Texture>;
+//#endregion
+//#region src/legacy/Geometry/Line/Line.d.ts
+type LineProps$1 = Omit<{
+  points: ReadonlyArray<Vector2 | Vector3>;
+  vertexColors?: ReadonlyArray<Color$2 | [number, number, number] | [number, number, number, number]>;
+  lineWidth?: number;
+  segments?: boolean;
+} & Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<ThreeElement<typeof Line2$1>, 'ref' | 'args'> & Omit<ThreeElement<typeof LineMaterial>, 'ref' | 'color' | 'vertexColors' | 'args'> & {
+  color?: ColorRepresentation$1;
+}, 'ref'>;
+//#endregion
+//#region src/legacy/Geometry/Segments/Segments.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    segmentObject: ThreeElement<typeof SegmentObject$1>;
+  }
+}
+declare class SegmentObject$1 {
+  color: THREE$1.Color;
+  start: THREE$1.Vector3;
+  end: THREE$1.Vector3;
+  constructor();
+}
+//#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$2.Texture) => React$1.ReactNode);
+  frames?: number;
+  resolution?: number;
+  envMap?: THREE$2.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$2.Texture) => React$1.ReactNode);
+  frames?: number;
+  resolution?: number;
+  envMap?: THREE$2.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$2.Camera;
+  onChange?: (e?: THREE$2.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$2.Matrix4;
+  axisLock?: 'x' | 'y' | 'z';
+  dragLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+  onHover?: (hovering: boolean) => void;
+  onDragStart?: (origin: THREE$2.Vector3) => void;
+  onDrag?: (localMatrix: THREE$2.Matrix4, deltaLocalMatrix: THREE$2.Matrix4, worldMatrix: THREE$2.Matrix4, deltaWorldMatrix: THREE$2.Matrix4) => void;
+  onDragEnd?: () => void;
+  children: React$1.ReactNode;
+  dragConfig?: DragConfig;
+};
+declare const DragControls: ForwardRefComponent<DragControlsProps, THREE$2.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$2.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$2.Camera;
+  makeDefault?: boolean;
+  onChange?: (e?: THREE$2.Event) => void;
+  onStart?: (e?: THREE$2.Event) => void;
+  onEnd?: (e?: THREE$2.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$2.Curve<THREE$2.Vector3>[];
+  debug?: boolean;
+  debugColor?: THREE$2.ColorRepresentation;
+  object?: React$1.RefObject<THREE$2.Object3D>;
+  focus?: [x: number, y: number, z: number] | React$1.RefObject<THREE$2.Object3D>;
+  loop?: boolean;
+  offset?: number;
+  smooth?: boolean | number;
+  eps?: number;
+  damping?: number;
+  focusDamping?: number;
+  maxSpeed?: number;
+};
+type MotionState = {
+  current: number;
+  path: THREE$2.CurvePath<THREE$2.Vector3>;
+  focus: React$1.RefObject<THREE$2.Object3D> | [x: number, y: number, z: number] | undefined;
+  object: React$1.RefObject<THREE$2.Object3D>;
+  offset: number;
+  point: THREE$2.Vector3;
+  tangent: THREE$2.Vector3;
+  next: THREE$2.Vector3;
+};
+type MotionPathRef = THREE$2.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$2.Camera;
+  onChange?: (e?: THREE$2.Event) => void;
+  onLock?: (e?: THREE$2.Event) => void;
+  onUnlock?: (e?: THREE$2.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$2.Group & HTMLDivElement>;
+//#endregion
+//#region src/core/Controls/TrackballControls/TrackballControls.d.ts
+type TrackballControlsProps = Omit<Overwrite<ThreeElement<typeof TrackballControls$1>, {
+  target?: ReactThreeFiber.Vector3;
+  camera?: THREE$2.Camera;
+  domElement?: HTMLElement;
+  regress?: boolean;
+  makeDefault?: boolean;
+  onChange?: (e?: THREE$2.Event) => void;
+  onStart?: (e?: THREE$2.Event) => void;
+  onEnd?: (e?: THREE$2.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$3;
+  position: Vector3$3;
+  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$3;
+};
+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$3;
+    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$1.Object3DEventMap>>>;
+declare const CloudInstance: React$1.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React$1.RefAttributes<Group<THREE$1.Object3DEventMap>>>;
+declare const Cloud: React$1.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React$1.RefAttributes<Group<THREE$1.Object3DEventMap>>>;
+//#endregion
+//#region src/core/Geometry/CatmullRomLine/CatmullRomLine.d.ts
+type CatmullRomLineProps = Omit<LineProps$1, 'ref' | 'segments'> & {
+  closed?: boolean;
+  curveType?: 'centripetal' | 'chordal' | 'catmullrom';
+  tension?: number;
+  segments?: number;
+  LineComponent?: React$1.ComponentType<LineProps$1>;
+};
+declare const CatmullRomLine: ForwardRefComponent<CatmullRomLineProps, Line2$1>;
+//#endregion
+//#region src/core/Geometry/CubicBezierLine/CubicBezierLine.d.ts
+type CubicBezierLineProps = Omit<LineProps$1, 'points' | 'ref'> & {
+  start: Vector3$3 | [number, number, number];
+  end: Vector3$3 | [number, number, number];
+  midA: Vector3$3 | [number, number, number];
+  midB: Vector3$3 | [number, number, number];
+  segments?: number;
+  LineComponent?: React$1.ComponentType<LineProps$1>;
+};
+declare const CubicBezierLine: ForwardRefComponent<CubicBezierLineProps, Line2$1>;
+//#endregion
+//#region src/core/Geometry/CurveModifier/CurveModifier.d.ts
+interface CurveModifierProps {
+  children: React$1.ReactElement<ThreeElements['mesh']>;
+  curve?: THREE$2.Curve<THREE$2.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$2.Mesh>;
+  position?: FIBER.Vector3;
+  rotation?: FIBER.Euler | number;
+  scale?: FIBER.Vector3;
+  map?: THREE$2.Texture;
+  children?: React$1.ReactNode;
+  polygonOffsetFactor?: number;
+  depthTest?: boolean;
+};
+declare const Decal: ForwardRefComponent<DecalProps, THREE$2.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$2.BufferGeometry;
+  lineWidth?: number;
+  color?: THREE$2.ColorRepresentation;
+  scale?: number;
+  LineComponent?: React$1.ComponentType<LineProps$1>;
+}
+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$2.Group {
+  size: number;
+  color: THREE$2.Color;
+  instance: React$1.RefObject<THREE$2.Points | undefined>;
+  instanceKey: React$1.RefObject<PositionPoint | undefined>;
+  constructor();
+  get geometry(): THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap> | undefined;
+  raycast(raycaster: THREE$2.Raycaster, intersects: THREE$2.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$2.Points>;
+declare const Points: ForwardRefComponent<PointsBuffersProps | PointsInstancesProps, THREE$2.Points>;
+//#endregion
+//#region src/core/Geometry/QuadraticBezierLine/QuadraticBezierLine.d.ts
+type QuadraticBezierLineRef = Line2$1 & {
+  setPoints(start: Vector3$3 | [number, number, number], end: Vector3$3 | [number, number, number], mid: Vector3$3 | [number, number, number]): void;
+};
+type QuadraticBezierLineProps = Omit<LineProps$1, 'points' | 'ref'> & {
+  start: Vector3$3 | [number, number, number];
+  end: Vector3$3 | [number, number, number];
+  mid?: Vector3$3 | [number, number, number];
+  segments?: number;
+  LineComponent?: React$1.ComponentType<LineProps$1>;
+};
+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$2.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$2.BoxGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Circle: ForwardRefComponent<ShapeProps<typeof THREE$2.CircleGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Cone: ForwardRefComponent<ShapeProps<typeof THREE$2.ConeGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Cylinder: ForwardRefComponent<ShapeProps<typeof THREE$2.CylinderGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Sphere: ForwardRefComponent<ShapeProps<typeof THREE$2.SphereGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Plane: ForwardRefComponent<ShapeProps<typeof THREE$2.PlaneGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Tube: ForwardRefComponent<ShapeProps<typeof THREE$2.TubeGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Torus: ForwardRefComponent<ShapeProps<typeof THREE$2.TorusGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const TorusKnot: ForwardRefComponent<ShapeProps<typeof THREE$2.TorusKnotGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Tetrahedron: ForwardRefComponent<ShapeProps<typeof THREE$2.TetrahedronGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Ring: ForwardRefComponent<ShapeProps<typeof THREE$2.RingGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Polyhedron: ForwardRefComponent<ShapeProps<typeof THREE$2.PolyhedronGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Icosahedron: ForwardRefComponent<ShapeProps<typeof THREE$2.IcosahedronGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Octahedron: ForwardRefComponent<ShapeProps<typeof THREE$2.OctahedronGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Dodecahedron: ForwardRefComponent<ShapeProps<typeof THREE$2.DodecahedronGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Extrude: ForwardRefComponent<ShapeProps<typeof THREE$2.ExtrudeGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Lathe: ForwardRefComponent<ShapeProps<typeof THREE$2.LatheGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Capsule: ForwardRefComponent<ShapeProps<typeof THREE$2.CapsuleGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.Object3DEventMap>>;
+declare const Shape: ForwardRefComponent<ShapeProps<typeof THREE$2.ShapeGeometry>, THREE$2.Mesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.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$2.Mesh>;
+//#endregion
+//#region src/legacy/Materials/WireframeMaterial/WireframeMaterial.d.ts
+interface WireframeMaterialProps$1 extends THREE$2.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$2.ColorRepresentation;
+  backfaceStroke?: THREE$2.ColorRepresentation;
+  fill?: THREE$2.ColorRepresentation;
+}
+declare const WireframeMaterial$1: FIBER.ConstructorRepresentation<THREE$2.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$2.Color;
+  backfaceStroke: THREE$2.Color;
+  fill: THREE$2.Color;
+}> & {
+  key: string;
+};
+//#endregion
+//#region src/core/Geometry/Wireframe/Wireframe.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshWireframeMaterial: ThreeElement<typeof WireframeMaterial$1>;
+  }
+}
+interface WireframeProps {
+  geometry?: THREE$2.BufferGeometry | React$1.RefObject<THREE$2.BufferGeometry>;
+  simplify?: boolean;
+}
+declare function Wireframe({
+  geometry: customGeometry,
+  ...props
+}: WireframeProps & WireframeMaterialProps$1): React$1.JSX.Element;
+//#endregion
+//#region src/core/Gizmos/gizmo/GizmoHelper.d.ts
+type GizmoHelperContext = {
+  tweenCamera: (direction: Vector3$3) => 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$3;
+};
+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$2.Vector3;
+  directions: THREE$2.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$2.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$2.Matrix4, deltaL: THREE$2.Matrix4, w: THREE$2.Matrix4, deltaW: THREE$2.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$1>;
+};
+declare const PivotControls: ForwardRefComponent<PivotControlsProps, THREE$2.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$2.Object3D | React$1.RefObject<THREE$2.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$2.Object3D>;
+  camera?: THREE$2.Camera;
+  onChange?: (e?: THREE$2.Event) => void;
+  onMouseDown?: (e?: THREE$2.Event) => void;
+  onMouseUp?: (e?: THREE$2.Event) => void;
+  onObjectChange?: (e?: THREE$2.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$2.PointsMaterial {
+  constructor(props?: THREE$2.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$2.InstancedMesh, 'instanceMatrix' | 'instanceColor'> & {
+  instanceMatrix: THREE$2.InstancedBufferAttribute;
+  instanceColor: THREE$2.InstancedBufferAttribute;
+};
+declare class PositionMesh extends THREE$2.Group {
+  color: THREE$2.Color;
+  instance: React$1.RefObject<THREE$2.InstancedMesh | undefined>;
+  instanceKey: React$1.RefObject<PositionMesh | undefined>;
+  constructor();
+  get geometry(): THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap> | undefined;
+  raycast(raycaster: THREE$2.Raycaster, intersects: THREE$2.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$2.InstancedMesh>;
+interface MergedProps extends Omit<InstancesProps, 'children'> {
+  meshes: THREE$2.Mesh[] | Record<string, THREE$2.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$2.Group>;
+declare function createInstances<T = InstanceProps>(): readonly [React$1.ForwardRefExoticComponent<Omit<InstancesProps, "ref"> & React$1.RefAttributes<THREE$2.InstancedMesh<THREE$2.BufferGeometry<THREE$2.NormalBufferAttributes, THREE$2.BufferGeometryEventMap>, THREE$2.Material | THREE$2.Material[], THREE$2.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$2.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$2.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$2.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$2.Group>;
+};
+declare function useSpriteAnimator(): SpriteAnimatorState | null;
+declare const SpriteAnimator: React$1.ForwardRefExoticComponent<Omit<SpriteAnimatorProps, "ref"> & React$1.RefAttributes<THREE$2.Group<THREE$2.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$2.Object3D | THREE$2.Object3D[];
+  children?: React$1.ReactNode;
+  deep?: boolean | 'materialsOnly' | 'geometriesOnly';
+  keys?: string[];
+  inject?: ThreeElements['mesh'] | React$1.ReactNode | ((object: THREE$2.Object3D) => React$1.ReactNode);
+  castShadow?: boolean;
+  receiveShadow?: boolean;
+  isChild?: boolean;
+};
+declare const Clone: ForwardRefComponent<CloneProps, THREE$2.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$3;
+  normal: Vector3$3;
+  color: Color$3;
+};
+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$2.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$2.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$2.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$2.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$1.Group<THREE$1.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$2.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$2.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$2.WebGLRenderTarget<THREE$2.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$2.RenderTargetOptions & React$1.RefAttributes<THREE$2.WebGLRenderTarget<THREE$2.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$2.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$2.Scene;
+  fbo: THREE$2.WebGLCubeRenderTarget;
+  camera: THREE$2.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$2.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$2.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$2.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$2.Box3;
+  size: THREE$2.Vector3;
+  center: THREE$2.Vector3;
+  distance: number;
+};
+type BoundsApi = {
+  getSize: () => SizeProps;
+  refresh(object?: THREE$2.Object3D | THREE$2.Box3): BoundsApi;
+  reset(): BoundsApi;
+  moveTo(position: THREE$2.Vector3 | [number, number, number]): BoundsApi;
+  lookAt({
+    target,
+    up
+  }: {
+    target?: THREE$2.Vector3 | [number, number, number];
+    up?: THREE$2.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$3;
+  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$2.Group>;
+//#endregion
+//#region src/core/Staging/Lightformer/Lightformer.d.ts
+type LightProps = Omit<ThreeElements['mesh'], 'ref'> & {
+  args?: any[];
+  map?: THREE$2.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$2.Vector3;
+  light?: Partial<ThreeElements['pointLight']>;
+};
+declare const Lightformer: ForwardRefComponent<LightProps, THREE$2.Mesh>;
+//#endregion
+//#region src/core/Staging/Resize/Resize.d.ts
+type ResizeProps = Omit<ThreeElements['group'], 'ref'> & {
+  width?: boolean;
+  height?: boolean;
+  depth?: boolean;
+  box3?: THREE$2.Box3;
+  precise?: boolean;
+};
+declare const Resize: React$1.ForwardRefExoticComponent<Omit<ResizeProps, "ref"> & React$1.RefAttributes<THREE$2.Group<THREE$2.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$3 | 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$3): Vector3$3;
+declare const Sky: ForwardRefComponent<SkyProps, Sky$1>;
+//#endregion
+//#region src/core/Staging/Stage/Stage.d.ts
+type StageShadows = Partial<AccumulativeShadowsProps$1> & Partial<RandomizedLightProps$1> & Partial<ContactShadowsProps$1> & {
+  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$1 = {
+  repeat?: number[];
+  anisotropy?: number;
+  offset?: number[];
+};
+declare function useNormalTexture(id?: number, settings?: Settings$1, 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$1) => React$1.JSX.Element;
+//#endregion
+//#region src/core/UI/CycleRaycast/CycleRaycast.d.ts
+type CycleRaycastProps = {
+  onChanged?: (hits: THREE$2.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;
+}
+//#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$2.Object3D[]) => void;
+  onChangePointerUp?: (selected: THREE$2.Object3D[]) => void;
+  filter?: (selected: THREE$2.Object3D[]) => THREE$2.Object3D[];
+};
+declare function Select({
+  box,
+  multiple,
+  children,
+  onChange,
+  onChangePointerUp,
+  border,
+  backgroundColor,
+  filter: customFilter,
+  ...props
+}: SelectProps): React$1.JSX.Element;
+declare function useSelect(): THREE$2.Object3D[];
+//#endregion
+//#region src/webgpu/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;
+  linewidth?: number;
+  segments?: boolean;
+  dashed?: boolean;
+  color?: ColorRepresentation;
+} & Omit<ThreeElement<typeof Line2>, 'ref' | 'args'>, 'ref'>;
+declare const Line: ForwardRefComponent<LineProps, Line2 | LineSegments2>;
+//#endregion
+//#region src/webgpu/Geometry/Segments/Segments.d.ts
+type SegmentsProps = {
+  limit?: number;
+  lineWidth?: number;
+  linewidth?: number;
+  dashed?: boolean;
+  children: React$1.ReactNode;
+};
+type SegmentProps = Omit<ThreeElements['segmentObject'], 'ref' | 'start' | 'end' | 'color'> & {
+  start: ReactThreeFiber.Vector3;
+  end: ReactThreeFiber.Vector3;
+  color?: ReactThreeFiber.Color;
+};
+declare const Segments: ForwardRefComponent<SegmentsProps, LineSegments2>;
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    segmentObject: ThreeElement<typeof SegmentObject>;
+  }
+}
+declare class SegmentObject {
+  color: THREE.Color;
+  start: THREE.Vector3;
+  end: THREE.Vector3;
+  constructor();
+}
+declare const Segment: ForwardRefComponent<SegmentProps, SegmentObject>;
+//#endregion
+//#region src/webgpu/Staging/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;
+};
+interface AccumulativeContext {
+  lights: Map<any, any>;
+  temporal: boolean;
+  frames: number;
+  blend: number;
+  count: number;
+  getMesh: () => THREE$2.Mesh<THREE$2.PlaneGeometry, SoftShadowMaterialProps & THREE$2.ShaderMaterial>;
+  reset: () => void;
+  update: (frames?: number) => void;
+}
+interface AccumulativeLightContext {
+  update: () => void;
+}
+type SoftShadowMaterialProps = {
+  map: THREE$2.Texture;
+  color?: ReactThreeFiber.Color;
+  alphaTest?: number;
+  blend?: number;
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps;
+  }
+}
+declare const accumulativeContext: React$1.Context<AccumulativeContext>;
+declare const AccumulativeShadows: ForwardRefComponent<AccumulativeShadowsProps, AccumulativeContext>;
+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;
+};
+declare const RandomizedLight: ForwardRefComponent<RandomizedLightProps, AccumulativeLightContext>;
+//#endregion
+//#region src/webgpu/Staging/BakeShadows/BakeShadows.d.ts
+declare function BakeShadows(): null;
+//#endregion
+//#region src/legacy/Materials/ConvolutionMaterial/ConvolutionMaterial.d.ts
+declare class ConvolutionMaterial$1 extends THREE$2.ShaderMaterial {
+  readonly kernel: Float32Array;
+  constructor(texelSize?: THREE$2.Vector2);
+  setTexelSize(x: number, y: number): void;
+  setResolution(resolution: THREE$2.Vector2): void;
+}
+//#endregion
+//#region src/webgpu/Materials/BlurPass/BlurPass.d.ts
+interface BlurPassProps {
+  gl: WebGLRenderer$1;
+  resolution: number;
+  width?: number;
+  height?: number;
+  minDepthThreshold?: number;
+  maxDepthThreshold?: number;
+  depthScale?: number;
+  depthToBlurRatioBias?: number;
+}
+declare class BlurPass {
+  readonly renderTargetA: WebGLRenderTarget$1;
+  readonly renderTargetB: WebGLRenderTarget$1;
+  readonly convolutionMaterial: ConvolutionMaterial$1;
+  readonly scene: Scene$1;
+  readonly camera: Camera;
+  readonly screen: Mesh$1;
+  renderToScreen: boolean;
+  constructor({
+    gl,
+    resolution,
+    width,
+    height,
+    minDepthThreshold,
+    maxDepthThreshold,
+    depthScale,
+    depthToBlurRatioBias
+  }: BlurPassProps);
+  render(renderer: any, inputBuffer: any, outputBuffer: any): void;
+}
+//#endregion
+//#region src/webgpu/Effects/Caustics/Caustics.d.ts
+type CausticsProps = Omit<ThreeElements['group'], 'ref'> & {
+  frames?: number;
+  debug?: boolean;
+  causticsOnly?: boolean;
+  backside?: boolean;
+  ior?: number;
+  backsideIOR?: number;
+  worldRadius?: number;
+  intensity?: number;
+  color?: ReactThreeFiber.Color;
+  resolution?: number;
+  lightSource?: [x: number, y: number, z: number] | React$1.RefObject<THREE.Object3D>;
+};
+declare class CausticsProjectionMaterial extends MeshBasicNodeMaterial {
+  private _causticsTexture;
+  private _causticsTextureB;
+  private _color;
+  private _lightProjMatrix;
+  private _lightViewMatrix;
+  constructor();
+  private _buildShader;
+  get causticsTexture(): THREE.Texture;
+  set causticsTexture(v: THREE.Texture);
+  get causticsTextureB(): THREE.Texture;
+  set causticsTextureB(v: THREE.Texture);
+  get color(): THREE.Color;
+  set color(v: THREE.Color);
+  get lightProjMatrix(): THREE.Matrix4;
+  set lightProjMatrix(v: THREE.Matrix4);
+  get lightViewMatrix(): THREE.Matrix4;
+  set lightViewMatrix(v: THREE.Matrix4);
+}
+declare class CausticsMaterial extends MeshBasicNodeMaterial {
+  private _cameraMatrixWorld;
+  private _cameraProjectionMatrixInv;
+  private _normalTexture;
+  private _depthTexture;
+  private _lightDir;
+  private _lightPlaneNormal;
+  private _lightPlaneConstant;
+  private _near;
+  private _far;
+  private _worldRadius;
+  private _ior;
+  private _resolution;
+  private _size;
+  private _intensity;
+  constructor();
+  private _buildShader;
+  get cameraMatrixWorld(): THREE.Matrix4;
+  set cameraMatrixWorld(v: THREE.Matrix4);
+  get cameraProjectionMatrixInv(): THREE.Matrix4;
+  set cameraProjectionMatrixInv(v: THREE.Matrix4);
+  get normalTexture(): THREE.Texture | null;
+  set normalTexture(v: THREE.Texture | null);
+  get depthTexture(): THREE.Texture | null;
+  set depthTexture(v: THREE.Texture | null);
+  get lightDir(): THREE.Vector3;
+  set lightDir(v: THREE.Vector3);
+  get lightPlaneNormal(): THREE.Vector3;
+  set lightPlaneNormal(v: THREE.Vector3);
+  get lightPlaneConstant(): number;
+  set lightPlaneConstant(v: number);
+  get near(): number;
+  set near(v: number);
+  get far(): number;
+  set far(v: number);
+  get worldRadius(): number;
+  set worldRadius(v: number);
+  get ior(): number;
+  set ior(v: number);
+  get resolution(): number;
+  set resolution(v: number);
+  get size(): number;
+  set size(v: number);
+  get intensity(): number;
+  set intensity(v: number);
+}
+declare class CausticsNormalMaterial extends MeshNormalNodeMaterial {
+  constructor(side?: THREE.Side);
+}
+//#endregion
+//#region src/webgpu/Staging/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.ColorRepresentation;
+  depthWrite?: boolean;
+};
+declare const ContactShadows: ForwardRefComponent<ContactShadowsProps, THREE.Group>;
+//#endregion
+//#region src/webgpu/Materials/ConvolutionMaterial/ConvolutionMaterial.d.ts
+declare class ConvolutionMaterial extends MeshBasicNodeMaterial {
+  private _inputBuffer;
+  private _depthBuffer;
+  private _resolution;
+  private _texelSize;
+  private _halfTexelSize;
+  private _kernel;
+  private _scale;
+  private _cameraNear;
+  private _cameraFar;
+  private _minDepthThreshold;
+  private _maxDepthThreshold;
+  private _depthScale;
+  private _depthToBlurRatioBias;
+  private _useDepth;
+  readonly kernel: Float32Array;
+  constructor(texelSize?: THREE.Vector2);
+  private _buildShader;
+  setTexelSize(x: number, y: number): void;
+  setResolution(resolution: THREE.Vector2): void;
+  get inputBuffer(): THREE.Texture | null;
+  set inputBuffer(v: THREE.Texture | null);
+  get depthBuffer(): THREE.Texture | null;
+  set depthBuffer(v: THREE.Texture | null);
+  get resolution(): THREE.Vector2;
+  set resolution(v: THREE.Vector2);
+  get texelSize(): THREE.Vector2;
+  set texelSize(v: THREE.Vector2);
+  get halfTexelSize(): THREE.Vector2;
+  set halfTexelSize(v: THREE.Vector2);
+  get kernelValue(): number;
+  set kernelValue(v: number);
+  get scale(): number;
+  set scale(v: number);
+  get cameraNear(): number;
+  set cameraNear(v: number);
+  get cameraFar(): number;
+  set cameraFar(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 useDepth(): boolean;
+  set useDepth(v: boolean);
+}
+//#endregion
+//#region src/webgpu/Materials/DiscardMaterial/DiscardMaterial.d.ts
+declare const DiscardMaterial: MeshBasicNodeMaterial;
+//#endregion
+//#region src/webgpu/Textures/GradientTexture/GradientTexture.d.ts
+declare enum GradientType {
+  Linear = "linear",
+  Radial = "radial",
+}
+type GradientTextureProps = {
+  stops: number[];
+  colors: THREE$2.ColorRepresentation[];
+  size?: number;
+  width?: number;
+  type?: GradientType;
+  innerCircleRadius?: number;
+  outerCircleRadius?: number | 'auto';
+} & Omit<ThreeElements['canvasTexture'], 'args'>;
+declare function GradientTexture({
+  stops,
+  colors,
+  size,
+  width,
+  type,
+  innerCircleRadius,
+  outerCircleRadius,
+  ...props
+}: GradientTextureProps): React$1.JSX.Element;
+//#endregion
+//#region src/webgpu/UI/Image/Image.d.ts
+type ImageProps = Omit<ThreeElements['mesh'], 'scale'> & {
+  segments?: number;
+  scale?: number | [number, number];
+  color?: Color;
+  zoom?: number;
+  radius?: number;
+  grayscale?: number;
+  toneMapped?: boolean;
+  transparent?: boolean;
+  opacity?: number;
+  side?: THREE.Side;
+} & ({
+  texture: THREE.Texture;
+  url?: never;
+} | {
+  texture?: never;
+  url: string;
+});
+declare const Image: ForwardRefComponent<ImageProps, THREE.Mesh>;
+//#endregion
+//#region src/webgpu/Materials/MeshDistortMaterial/MeshDistortMaterial.d.ts
+declare class DistortMaterialImplWebGPU extends THREE.MeshPhysicalNodeMaterial {
+  timeUniform: ReturnType<typeof uniform>;
+  distortUniform: ReturnType<typeof uniform>;
+  radiusUniform: ReturnType<typeof uniform>;
+  constructor(parameters?: THREE.MeshPhysicalMaterialParameters);
+  get time(): unknown;
+  set time(v: unknown);
+  get distort(): unknown;
+  set distort(v: unknown);
+  get radius(): unknown;
+  set radius(v: unknown);
+}
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    distortMaterialImplWebGPU: ThreeElements['meshPhysicalMaterial'] & {
+      time?: number;
+      distort?: number;
+      radius?: number;
+    };
+  }
+}
+type MeshDistortMaterialProps = Omit<ThreeElements['distortMaterialImplWebGPU'], 'ref'> & {
+  speed?: number;
+  factor?: number;
+};
+declare const MeshDistortMaterial: ForwardRefComponent<MeshDistortMaterialProps, DistortMaterialImplWebGPU>;
+//#endregion
+//#region src/webgpu/Materials/MeshPortalMaterial/MeshPortalMaterial.d.ts
+type PortalProps = Omit<ThreeElements['meshBasicMaterial'], 'ref'> & {
+  blend?: number;
+  blur?: number;
+  resolution?: number;
+  worldUnits?: boolean;
+  eventPriority?: number;
+  renderPriority?: number;
+  events?: boolean;
+  children?: React$1.ReactNode;
+};
+declare class PortalMaterialImpl extends MeshBasicNodeMaterial {
+  private _blur;
+  private _map;
+  private _sdf;
+  private _blend;
+  private _size;
+  private _resolution;
+  constructor();
+  private _buildShader;
+  get blur(): number;
+  set blur(v: number);
+  get map(): THREE.Texture | null;
+  set map(v: THREE.Texture | null);
+  get sdf(): THREE.Texture | null;
+  set sdf(v: THREE.Texture | null);
+  get blend(): number;
+  set blend(v: number);
+  get size(): number;
+  set size(v: number);
+  get resolution(): THREE.Vector2 | [number, number];
+  set resolution(v: THREE.Vector2 | [number, number]);
+}
+declare const MeshPortalMaterial: ForwardRefComponent<PortalProps, PortalMaterialImpl>;
+//#endregion
+//#region src/webgpu/Materials/MeshReflectorMaterial/MeshReflectorMaterialClass.d.ts
+interface MeshReflectorMaterialOptions {
+  resolution?: number;
+  mixBlur?: number;
+  mixStrength?: number;
+  mirror?: number;
+  minDepthThreshold?: number;
+  maxDepthThreshold?: number;
+  depthScale?: number;
+  depthToBlurRatioBias?: number;
+  distortion?: number;
+  mixContrast?: number;
+  reflectorOffset?: number;
+}
+declare class MeshReflectorMaterial$1 extends THREE.MeshStandardNodeMaterial {
+  reflection: ReturnType<typeof reflector>;
+  mirrorUniform: ReturnType<typeof uniform<number>>;
+  mixBlurUniform: ReturnType<typeof uniform<number>>;
+  mixStrengthUniform: ReturnType<typeof uniform<number>>;
+  minDepthThresholdUniform: ReturnType<typeof uniform<number>>;
+  maxDepthThresholdUniform: ReturnType<typeof uniform<number>>;
+  depthScaleUniform: ReturnType<typeof uniform<number>>;
+  depthToBlurRatioBiasUniform: ReturnType<typeof uniform<number>>;
+  distortionUniform: ReturnType<typeof uniform<number>>;
+  mixContrastUniform: ReturnType<typeof uniform<number>>;
+  blurRadiusUniform: ReturnType<typeof uniform<number>>;
+  hasBlurUniform: ReturnType<typeof uniform<number>>;
+  hasDepthUniform: ReturnType<typeof uniform<number>>;
+  constructor(options?: MeshReflectorMaterialOptions, parameters?: THREE.MeshStandardMaterialParameters);
+  private setupNodes;
+  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);
+  get blurRadius(): number;
+  set blurRadius(v: number);
+  get reflectorTarget(): THREE.Object3D;
+}
+//#endregion
+//#region src/webgpu/Materials/MeshReflectorMaterial/MeshReflectorMaterial.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshReflectorMaterialWebGPU: ThreeElements['meshStandardMaterial'] & {
+      mirror?: number;
+      mixBlur?: number;
+      mixStrength?: number;
+      minDepthThreshold?: number;
+      maxDepthThreshold?: number;
+      depthScale?: number;
+      depthToBlurRatioBias?: number;
+      distortion?: number;
+      mixContrast?: number;
+    };
+  }
+}
+type MeshReflectorMaterialProps = Omit<ThreeElements['meshStandardMaterial'], 'ref'> & {
+  resolution?: number;
+  blur?: [number, number] | number;
+  reflectorOffset?: number;
+  mirror?: number;
+  mixBlur?: number;
+  mixStrength?: number;
+  minDepthThreshold?: number;
+  maxDepthThreshold?: number;
+  depthScale?: number;
+  depthToBlurRatioBias?: number;
+  distortion?: number;
+  mixContrast?: number;
+};
+declare const MeshReflectorMaterial: ForwardRefComponent<MeshReflectorMaterialProps, MeshReflectorMaterial$1>;
+//#endregion
+//#region src/webgpu/Materials/MeshRefractionMaterial/MeshRefractionMaterial.d.ts
+type MeshRefractionMaterialType = Omit<ThreeElements['meshPhysicalMaterial'], 'args' | 'color'> & {
+  envMap?: THREE.CubeTexture | THREE.Texture | null;
+  bounces?: number;
+  ior?: number;
+  fresnel?: number;
+  aberrationStrength?: number;
+  fastChroma?: boolean;
+  tintColor?: THREE.ColorRepresentation;
+  opacity?: number;
+};
+type MeshRefractionMaterialProps = Omit<MeshRefractionMaterialType, 'ref'>;
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshRefractionMaterial: MeshRefractionMaterialType;
+  }
+}
+declare class MeshRefractionMaterialImpl extends MeshPhysicalNodeMaterial {
+  private _envMap;
+  private _bounces;
+  private _ior;
+  private _fresnel;
+  private _aberrationStrength;
+  private _color;
+  private _opacityValue;
+  private _resolution;
+  private _thickness;
+  private _fastChroma;
+  readonly isMeshRefractionMaterial = true;
+  constructor(fastChroma?: boolean);
+  private _buildRefractionShader;
+  get envMap(): THREE.Texture | THREE.CubeTexture | null;
+  set envMap(v: THREE.Texture | THREE.CubeTexture | null);
+  get bounces(): number;
+  set bounces(v: number);
+  get ior(): number;
+  set ior(v: number);
+  get fresnel(): number;
+  set fresnel(v: number);
+  get aberrationStrength(): number;
+  set aberrationStrength(v: number);
+  get tintColor(): THREE.Color;
+  set tintColor(v: THREE.Color | THREE.ColorRepresentation);
+  get opacity(): number;
+  set opacity(v: number);
+  get resolution(): THREE.Vector2;
+  set resolution(v: THREE.Vector2);
+  get thickness(): number;
+  set thickness(v: number);
+}
+declare const MeshRefractionMaterial: ForwardRefComponent<MeshRefractionMaterialProps, MeshRefractionMaterialImpl>;
+//#endregion
+//#region src/webgpu/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.Texture;
+  time?: number;
+  args?: [samples: number, transmissionSampler: boolean];
+};
+type MeshTransmissionMaterialProps = Omit<MeshTransmissionMaterialType, 'ref' | 'args'> & {
+  transmissionSampler?: boolean;
+  backside?: boolean;
+  backsideThickness?: number;
+  backsideEnvMapIntensity?: number;
+  resolution?: number;
+  backsideResolution?: number;
+  samples?: number;
+  background?: THREE.Texture | THREE.Color;
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshTransmissionMaterial: MeshTransmissionMaterialType;
+  }
+}
+declare class MeshTransmissionMaterialImpl extends MeshPhysicalNodeMaterial {
+  private _chromaticAberration;
+  private _anisotropicBlur;
+  private _time;
+  private _distortion;
+  private _distortionScale;
+  private _temporalDistortion;
+  private _buffer;
+  private _transmissionValue;
+  private _attenuationDistance;
+  private _attenuationColor;
+  private _samples;
+  private _transmissionSampler;
+  readonly isMeshTransmissionMaterial = true;
+  constructor(samples?: number, transmissionSampler?: boolean);
+  private _buildTransmissionShader;
+  get chromaticAberration(): number;
+  set chromaticAberration(v: number);
+  get anisotropicBlur(): number;
+  set anisotropicBlur(v: number);
+  get time(): number;
+  set time(v: number);
+  get distortion(): number;
+  set distortion(v: number);
+  get distortionScale(): number;
+  set distortionScale(v: number);
+  get temporalDistortion(): number;
+  set temporalDistortion(v: number);
+  get buffer(): THREE.Texture | null;
+  set buffer(v: THREE.Texture | null);
+  get _transmission(): number;
+  set _transmission(v: number);
+  get attenuationDistance(): number;
+  set attenuationDistance(v: number);
+  get attenuationColor(): THREE.Color;
+  set attenuationColor(v: THREE.Color);
+}
+declare const MeshTransmissionMaterial: ForwardRefComponent<MeshTransmissionMaterialProps, MeshTransmissionMaterialImpl>;
+//#endregion
+//#region src/webgpu/Materials/MeshWobbleMaterial/MeshWobbleMaterial.d.ts
+declare class WobbleMaterialImpl extends THREE.MeshStandardNodeMaterial {
+  timeUniform: ReturnType<typeof uniform>;
+  factorUniform: ReturnType<typeof uniform>;
+  constructor(parameters?: THREE.MeshStandardMaterialParameters);
+  get time(): unknown;
+  set time(v: unknown);
+  get factor(): unknown;
+  set factor(v: unknown);
+}
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    wobbleMaterialImpl: ThreeElements['meshStandardMaterial'] & {
+      time?: number;
+      factor?: number;
+      speed?: number;
+    };
+  }
+}
+type WobbleMaterialProps = Omit<ThreeElements['meshStandardMaterial'], 'ref'> & {
+  speed?: number;
+  factor?: number;
+};
+declare const MeshWobbleMaterial: ForwardRefComponent<WobbleMaterialProps, WobbleMaterialImpl>;
+//#endregion
+//#region src/webgpu/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.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/webgpu/Staging/SoftShadows/SoftShadows.d.ts
+type SoftShadowsProps = {
+  size?: number;
+  samples?: number;
+  focus?: number;
+};
+declare function SoftShadows({
+  focus,
+  samples,
+  size
+}: SoftShadowsProps): null;
+//#endregion
+//#region src/webgpu/Materials/SpotLightMaterial/SpotLightMaterial.d.ts
+declare class SpotLightMaterial extends MeshBasicNodeMaterial {
+  private _depth;
+  private _opacity;
+  private _attenuation;
+  private _anglePower;
+  private _spotPosition;
+  private _lightColor;
+  private _cameraNear;
+  private _cameraFar;
+  private _resolution;
+  constructor();
+  private _buildShader;
+  get depth(): THREE.Texture | null;
+  set depth(v: THREE.Texture | null);
+  get opacity(): number;
+  set opacity(v: number);
+  get attenuation(): number;
+  set attenuation(v: number);
+  get anglePower(): number;
+  set anglePower(v: number);
+  get spotPosition(): THREE.Vector3;
+  set spotPosition(v: THREE.Vector3);
+  get lightColor(): THREE.Color;
+  set lightColor(v: THREE.Color);
+  get cameraNear(): number;
+  set cameraNear(v: number);
+  get cameraFar(): number;
+  set cameraFar(v: number);
+  get resolution(): THREE.Vector2;
+  set resolution(v: THREE.Vector2);
+}
+//#endregion
+//#region src/webgpu/Materials/WireframeMaterial/WireframeMaterial.d.ts
+interface WireframeMaterialProps {
+  fillOpacity?: number;
+  fillMix?: number;
+  strokeOpacity?: number;
+  thickness?: number;
+  colorBackfaces?: boolean;
+  dashInvert?: boolean;
+  dash?: boolean;
+  dashRepeats?: number;
+  dashLength?: number;
+  squeeze?: boolean;
+  squeezeMin?: number;
+  squeezeMax?: number;
+  stroke?: THREE.ColorRepresentation;
+  backfaceStroke?: THREE.ColorRepresentation;
+  fill?: THREE.ColorRepresentation;
+}
+type WireframeMaterialType = Omit<ThreeElements['meshBasicMaterial'], 'args'> & WireframeMaterialProps;
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    wireframeMaterial: WireframeMaterialType;
+  }
+}
+declare class WireframeMaterialImpl extends MeshBasicNodeMaterial {
+  private _strokeOpacity;
+  private _fillOpacity;
+  private _fillMix;
+  private _thickness;
+  private _colorBackfaces;
+  private _dashInvert;
+  private _dash;
+  private _dashRepeats;
+  private _dashLength;
+  private _squeeze;
+  private _squeezeMin;
+  private _squeezeMax;
+  private _stroke;
+  private _backfaceStroke;
+  private _fill;
+  readonly isWireframeMaterial = true;
+  constructor();
+  private _buildWireframeShader;
+  get strokeOpacity(): number;
+  set strokeOpacity(v: number);
+  get fillOpacity(): number;
+  set fillOpacity(v: number);
+  get fillMix(): number;
+  set fillMix(v: number);
+  get thickness(): number;
+  set thickness(v: number);
+  get colorBackfaces(): boolean;
+  set colorBackfaces(v: boolean);
+  get dashInvert(): boolean;
+  set dashInvert(v: boolean);
+  get dash(): boolean;
+  set dash(v: boolean);
+  get dashRepeats(): number;
+  set dashRepeats(v: number);
+  get dashLength(): number;
+  set dashLength(v: number);
+  get squeeze(): boolean;
+  set squeeze(v: boolean);
+  get squeezeMin(): number;
+  set squeezeMin(v: number);
+  get squeezeMax(): number;
+  set squeezeMax(v: number);
+  get stroke(): THREE.Color;
+  set stroke(v: THREE.Color | THREE.ColorRepresentation);
+  get backfaceStroke(): THREE.Color;
+  set backfaceStroke(v: THREE.Color | THREE.ColorRepresentation);
+  get fill(): THREE.Color;
+  set fill(v: THREE.Color | THREE.ColorRepresentation);
+}
+declare function setBarycentricCoordinates(geometry: THREE.BufferGeometry): THREE.BufferGeometry;
+declare const WireframeMaterial: ForwardRefComponent<WireframeMaterialProps, WireframeMaterialImpl>;
+declare const WireframeMaterialShaders: {
+  uniforms: {
+    strokeOpacity: number;
+    fillOpacity: number;
+    fillMix: number;
+    thickness: number;
+    colorBackfaces: boolean;
+    dashInvert: boolean;
+    dash: boolean;
+    dashRepeats: number;
+    dashLength: number;
+    squeeze: boolean;
+    squeezeMin: number;
+    squeezeMax: number;
+    stroke: THREE.Color;
+    backfaceStroke: THREE.Color;
+    fill: THREE.Color;
+  };
+  vertex: string;
+  fragment: string;
+};
+declare function setWireframeOverride(_material: THREE.Material, _uniforms: {
+  [key: string]: THREE.Uniform<any>;
+}): void;
+declare function useWireframeUniforms(_uniforms: {
+  [key: string]: THREE.Uniform<any>;
+}, _props: WireframeMaterialProps): void;
+//#endregion
+//#region src/webgpu/Materials/FakeCloudMaterial.d.ts
+declare function FakeCloudMaterial(BaseMaterial: typeof Material): Material;
+//#endregion
+//#region src/webgpu/Materials/StarsMaterial.d.ts
+declare class StarfieldMaterial extends SpriteNodeMaterial {
+  private _time;
+  private _fade;
+  positionNode: ReturnType<typeof Fn>;
+  scaleNode: ReturnType<typeof Fn>;
+  colorNode: ReturnType<typeof Fn>;
+  constructor();
+  setTime(time: number): void;
+  setFade(fade: number): void;
+  get time(): number;
+  set time(value: number);
+  get fade(): number;
+  set fade(value: number);
+}
+//#endregion
+//#region src/webgpu/Materials/SparklesMaterial.d.ts
+declare class SparklesMaterial extends SpriteNodeMaterial {
+  private _time;
+  private _pixelRatio;
+  positionNode: ReturnType<typeof Fn>;
+  scaleNode: ReturnType<typeof Fn>;
+  colorNode: ReturnType<typeof Fn>;
+  constructor();
+  get time(): number;
+  set time(value: number);
+  get pixelRatio(): number;
+  set pixelRatio(value: number);
+}
+//#endregion
+//#region src/webgpu/Staging/Grid/Grid.d.ts
+type GridMaterialType = {
+  cellSize?: number;
+  cellThickness?: number;
+  cellColor?: THREE.ColorRepresentation;
+  sectionSize?: number;
+  sectionThickness?: number;
+  sectionColor?: THREE.ColorRepresentation;
+  followCamera?: boolean;
+  infiniteGrid?: boolean;
+  fadeDistance?: number;
+  fadeStrength?: number;
+  fadeFrom?: number;
+  side?: THREE.Side;
+};
+type GridProps = Omit<ThreeElements['mesh'], 'ref' | 'args'> & GridMaterialType & {
+  args?: ConstructorParameters<typeof THREE.PlaneGeometry>;
+};
+declare const Grid: ForwardRefComponent<GridProps, THREE.Mesh>;
+//#endregion
+//#region src/webgpu/Staging/SpotLight/SpotLight.d.ts
+type SpotLightProps = Omit<ThreeElements['spotLight'], 'ref'> & {
+  depthBuffer?: Texture$2;
+  attenuation?: number;
+  anglePower?: number;
+  radiusTop?: number;
+  radiusBottom?: number;
+  opacity?: number;
+  color?: string | number;
+  volumetric?: boolean;
+  debug?: boolean;
+};
+declare const SpotLight: ForwardRefComponent<React$1.PropsWithChildren<SpotLightProps>, SpotLight$1>;
+//#endregion
+//#region src/webgpu/Staging/Stars/Stars.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    webgpuStarfieldMaterial: ThreeElement<typeof StarfieldMaterial>;
+  }
+}
+type StarsProps = Omit<ThreeElements['instancedMesh'], 'ref' | 'args'> & {
+  radius?: number;
+  depth?: number;
+  count?: number;
+  factor?: number;
+  saturation?: number;
+  fade?: boolean;
+  speed?: number;
+};
+declare const Stars: ForwardRefComponent<StarsProps, THREE$2.InstancedMesh>;
+//#endregion
+//#region src/webgpu/Effects/Sparkles/Sparkles.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    webgpuSparklesMaterial: ThreeElement<typeof SparklesMaterial>;
+  }
+}
+type SparklesProps = Omit<ThreeElements['mesh'], 'ref'> & {
+  count?: number;
+  speed?: number | Float32Array;
+  opacity?: number | Float32Array;
+  color?: THREE$2.ColorRepresentation | Float32Array;
+  size?: number | Float32Array;
+  scale?: number | [number, number, number] | THREE$2.Vector3;
+  noise?: number | [number, number, number] | THREE$2.Vector3 | Float32Array;
+};
+declare const Sparkles: ForwardRefComponent<SparklesProps, THREE$2.InstancedMesh>;
+//#endregion
+//#region src/webgpu/Effects/Trail/Trail.d.ts
+type Settings = {
+  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>;
+declare function useTrail(target: Object3D, settings: Partial<Settings>, pointCount: number): React$1.RefObject<Float32Array>;
+declare const Trail: ForwardRefComponent<React$1.PropsWithChildren<TrailProps>, Line2>;
+//#endregion
+//#region src/native/index.d.ts
+declare const Html: () => never;
+declare const Caustics: () => never;
+//#endregion
+export { AccumulativeShadows, type AccumulativeShadowsProps, AdaptiveDpr, AdaptiveEvents, ArcballControls, ArcballControlsProps, Args, BBAnchor, BBAnchorProps, Backdrop, BackdropProps, BakeShadows, Billboard, BillboardProps, BlurPass, BlurPassProps, Bounds, BoundsApi, BoundsProps, Box, CalculatePosition, CameraShake, CameraShakeProps, Capsule, CatmullRomLine, CatmullRomLineProps, Caustics, CausticsMaterial, CausticsNormalMaterial, CausticsProjectionMaterial, CausticsProps, Center, CenterProps, Circle, Clone, CloneProps, Cloud, CloudInstance, CloudProps, Clouds, CloudsProps, ComputedAttribute, ComputedAttributeProps, Cone, ContactShadows, type ContactShadowsProps, ContainerProps, ConvolutionMaterial, CubeCamera, CubeCameraOptions, CubeCameraProps, CubeTexture, CubeTextureProps, CubicBezierLine, CubicBezierLineProps, CurveModifier, CurveModifierProps, CurveModifierRef, CycleRaycast, CycleRaycastProps, Cylinder, Decal, DecalProps, Detailed, DetailedProps, DetectGPU, DetectGPUProps, DeviceOrientationControls, DeviceOrientationControlsProps, DiscardMaterial, Dodecahedron, DragControls, DragControlsProps, Edges, EdgesProps, Environment, EnvironmentCube, EnvironmentLoaderProps, EnvironmentMap, EnvironmentPortal, EnvironmentProps, Example, ExampleApi, ExampleProps, Extrude, FakeCloudMaterial, Fbo, FboProps, Fbx, FirstPersonControls, FirstPersonControlsProps, Fisheye, FisheyeProps, Float, FloatProps, FlyControls, FlyControlsProps, FontData, FrameData, GizmoHelper, GizmoHelperProps, GizmoViewcube, GizmoViewport, Gltf, GltfProps, Glyph, GradientTexture, GradientTextureProps, GradientType, Grid, GridMaterialType, GridProps, Helper, HelperProps, Html, HtmlProps, Hud, HudProps, Icosahedron, Image, ImageProps, Instance, InstanceProps, InstancedAttribute, InstancedAttributeProps, Instances, InstancesProps, IsObject, KeyboardControls, KeyboardControlsEntry, KeyboardControlsProps, Ktx2, Lathe, LightProps, Lightformer, Line, type LineProps, Loader, LoaderOptions, MapControls, MapControlsProps, Mask, MaskProps, MatcapTexture, Merged, MergedProps, MeshDistortMaterial, MeshDistortMaterialProps, MeshPortalMaterial, MeshReflectorMaterial, MeshReflectorMaterial$1 as MeshReflectorMaterialImpl, MeshReflectorMaterialProps, MeshRefractionMaterial, MeshRefractionMaterialProps, MeshRefractionMaterialType, MeshTransmissionMaterial, MeshTransmissionMaterialProps, MeshWobbleMaterial, 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, PortalProps, PositionMesh, PositionPoint, PositionalAudio, PositionalAudioProps, Preload, PreloadProps, PresentationControlProps, PresentationControls, PresetsType, Progress, QuadraticBezierLine, QuadraticBezierLineProps, QuadraticBezierLineRef, RandomizedLight, type RandomizedLightProps, 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, Segment, SegmentObject, type SegmentProps, Segments, type SegmentsProps, Select, SelectProps, Shadow, ShadowProps, ShadowType, ShakeController, Shape, ShapeProps, Size, SizeProps, Sky, SkyProps, SoftShadows, SoftShadowsProps, Sparkles, SparklesMaterial, SparklesProps, Sphere, SpotLight, SpotLightMaterial, SpotLightProps, SpriteAnimator, SpriteAnimatorProps, SpriteData, Stage, StageProps, StarfieldMaterial, Stars, StarsProps, Stats, StatsGl, StatsGlProps, StatsProps, Svg, SvgProps, 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, WireframeMaterial, WireframeMaterialProps, WireframeMaterialShaders, WireframeMaterialType, WobbleMaterialProps, accumulativeContext, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, meshBounds, presetsObj, setBarycentricCoordinates, setWireframeOverride, useAnimations, useAspect, useBounds, useContextBridge, useCubeCamera, useCubeTexture, useCursor, useCustomRaycast, useDepthBuffer, useDetectGPU, useEnvironment, useFBO, useFBX, useFont, useGLTF, useGizmoContext, useHelper, useIntersect, useKTX2, useKeyboardControls, useMask, useMatcapTexture, useMotion, useNormalTexture, usePerformanceMonitor, useProgress, useScroll, useSelect, useSpriteAnimator, useSpriteLoader, useSurfaceSampler, useSurfaceSamplerProps, useTexture, useTrail, useTrailTexture, useVideoTexture, useWireframeUniforms };