@react-three/drei 11.0.0-alpha.5 → 11.0.0-alpha.7

package/native/index.d.ts

@@ -3,10 +3,9 @@ import { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, CSSPropertie
 import * as _react_three_fiber from '@react-three/fiber';
 import { ThreeElements, ReactThreeFiber, ComputeFunction, Vector2, Vector3, ThreeElement, ThreeEvent, Color as Color$1, ObjectMap, Euler } from '@react-three/fiber';
 import * as THREE from 'three/webgpu';
-import { MeshBasicNodeMaterial, MeshNormalNodeMaterial, MeshPhysicalNodeMaterial, Material, Color, ColorRepresentation, Object3D, Texture as Texture$1, Fog, FogExp2, WebGLCubeRenderTarget, CubeCamera as CubeCamera$1, OrthographicCamera as OrthographicCamera$1, PerspectiveCamera as PerspectiveCamera$1, EventDispatcher, Camera, Matrix4, Vector3 as Vector3$1, Group, LOD, Mesh, ExtrudeGeometry, PositionalAudio as PositionalAudio$1, AnimationClip, AnimationMixer, AnimationAction, BufferGeometry, BufferAttribute, InstancedMesh as InstancedMesh$1, InstancedBufferAttribute, DepthTexture, CubeTexture as CubeTexture$1, Raycaster, Intersection, RenderTargetOptions, Box3, Sphere as Sphere$1, Loader as Loader$1, ColorSpace, Scene, PlaneGeometry, MeshBasicMaterial, SpriteNodeMaterial, SpotLight as SpotLight$1 } from 'three/webgpu';
-import { reflector, uniform, Fn } from 'three/tsl';
+import { Material, UniformNode, TextureNode, Texture as Texture$1, MeshNormalNodeMaterial, CubeRenderTarget, Color, ColorRepresentation, Object3D, Fog, FogExp2, CubeCamera as CubeCamera$1, OrthographicCamera as OrthographicCamera$1, PerspectiveCamera as PerspectiveCamera$1, EventDispatcher, Camera, Group, Matrix4, Vector3 as Vector3$1, LOD, Mesh, ExtrudeGeometry, PositionalAudio as PositionalAudio$1, AnimationClip, AnimationMixer, AnimationAction, BufferGeometry, BufferAttribute, InstancedMesh as InstancedMesh$1, InstancedBufferAttribute, DepthTexture, CubeTexture as CubeTexture$1, Raycaster, Intersection, RenderTargetOptions, Box3, Sphere as Sphere$1, Loader as Loader$1, ColorSpace, Scene, PlaneGeometry, MeshBasicMaterial, MeshBasicNodeMaterial, SpriteNodeMaterial, SpotLight as SpotLight$1 } from 'three/webgpu';
+import { reflector } from 'three/tsl';
 import { LineSegments2 } from 'three/examples/jsm/lines/webgpu/LineSegments2.js';
-import { DragConfig } from '@use-gesture/react';
 import * as zustand from 'zustand';
 import { StoreApi } from 'zustand';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
@@ -47,6 +46,22 @@ type ContactShadowsProps = Omit<ThreeElements['group'], 'ref' | 'scale'> & {
 };
 declare const ContactShadows: ForwardRefComponent<ContactShadowsProps, THREE.Group>;
 
+type AnyCtor = new (...args: any[]) => Material;
+type UniformFactory = () => UniformNode<any, any> | TextureNode;
+type UniformValue<F> = F extends () => TextureNode ? Texture$1 | null : F extends () => UniformNode<any, infer V> ? V : never;
+type UniformProps<U> = {
+    [K in keyof U]: UniformValue<U[K]>;
+};
+type UniformNodes<U extends Record<string, UniformFactory>> = {
+    [K in keyof U]: ReturnType<U[K]>;
+};
+type UniformParameters<B extends AnyCtor, U> = NonNullable<ConstructorParameters<B>[0]> & Partial<UniformProps<U>>;
+type WithUniforms<B extends AnyCtor, U extends Record<string, UniformFactory>> = Omit<B, 'prototype'> & {
+    new (parameters?: UniformParameters<B, U>, ...rest: any[]): InstanceType<B> & UniformProps<U> & {
+        readonly uniforms: UniformNodes<U>;
+    };
+};
+
 type AccumulativeShadowsProps = Omit<ThreeElements['group'], 'ref'> & {
     frames?: number;
     blend?: number;
@@ -66,7 +81,7 @@ interface AccumulativeContext {
     frames: number;
     blend: number;
     count: number;
-    getMesh: () => THREE.Mesh<THREE.PlaneGeometry, THREE.ShaderMaterial>;
+    getMesh: () => THREE.Mesh<THREE.PlaneGeometry, SoftShadowMaterialImpl>;
     reset: () => void;
     update: (frames?: number) => void;
 }
@@ -74,6 +89,14 @@ interface AccumulativeLightContext {
     update: () => void;
 }
 declare const accumulativeContext: React.Context<AccumulativeContext>;
+declare const SoftShadowMaterialImpl_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    shadowColor: () => THREE.UniformNode<"color", THREE.Color>;
+    blend: () => THREE.UniformNode<"float", number>;
+}>;
+declare class SoftShadowMaterialImpl extends SoftShadowMaterialImpl_base {
+    constructor();
+    private _buildShader;
+}
 declare const AccumulativeShadows: ForwardRefComponent<AccumulativeShadowsProps, AccumulativeContext>;
 type RandomizedLightProps = Omit<ThreeElements['group'], 'ref'> & {
     frames?: number;
@@ -91,70 +114,35 @@ type RandomizedLightProps = Omit<ThreeElements['group'], 'ref'> & {
 };
 declare const RandomizedLight: ForwardRefComponent<RandomizedLightProps, AccumulativeLightContext>;
 
-declare class CausticsProjectionMaterial extends MeshBasicNodeMaterial {
-    private _causticsTexture;
-    private _causticsTextureB;
-    private _color;
-    private _lightProjMatrix;
-    private _lightViewMatrix;
+declare const CausticsProjectionMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    causticsTexture: () => THREE.TextureNode<"vec4">;
+    causticsTextureB: () => THREE.TextureNode<"vec4">;
+    lightProjMatrix: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+    lightViewMatrix: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+}>;
+declare class CausticsProjectionMaterial extends CausticsProjectionMaterial_base {
     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;
+declare const CausticsMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    cameraMatrixWorld: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+    cameraProjectionMatrixInv: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+    normalTexture: () => THREE.TextureNode<"vec4">;
+    depthTexture: () => THREE.TextureNode<"vec4">;
+    lightDir: () => THREE.UniformNode<"vec3", THREE.Vector3>;
+    lightPlaneNormal: () => THREE.UniformNode<"vec3", THREE.Vector3>;
+    lightPlaneConstant: () => THREE.UniformNode<"float", number>;
+    near: () => THREE.UniformNode<"float", number>;
+    far: () => THREE.UniformNode<"float", number>;
+    worldRadius: () => THREE.UniformNode<"float", number>;
+    ior: () => THREE.UniformNode<"float", number>;
+    resolution: () => THREE.UniformNode<"float", number>;
+    size: () => THREE.UniformNode<"float", number>;
+    intensity: () => THREE.UniformNode<"float", number>;
+}>;
+declare class CausticsMaterial extends CausticsMaterial_base {
     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);
@@ -172,6 +160,7 @@ type MeshTransmissionMaterialType = Omit<ThreeElements['meshPhysicalMaterial'],
     temporalDistortion?: number;
     buffer?: THREE.Texture;
     time?: number;
+    debugMode?: number;
     args?: [samples: number, transmissionSampler: boolean];
 };
 type MeshTransmissionMaterialProps = Omit<MeshTransmissionMaterialType, 'ref' | 'args'> & {
@@ -189,44 +178,7 @@ declare module '@react-three/fiber' {
         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>;
+declare const MeshTransmissionMaterial: ForwardRefComponent<MeshTransmissionMaterialProps, ThreeElements['meshTransmissionMaterial']>;
 
 interface MeshReflectorMaterialOptions {
     resolution?: number;
@@ -241,43 +193,23 @@ interface MeshReflectorMaterialOptions {
     mixContrast?: number;
     reflectorOffset?: number;
 }
-declare class MeshReflectorMaterial$1 extends THREE.MeshStandardNodeMaterial {
+declare const MeshReflectorMaterial_base: WithUniforms<typeof THREE.MeshStandardNodeMaterial, {
+    mirror: () => THREE.UniformNode<"float", number>;
+    mixBlur: () => THREE.UniformNode<"float", number>;
+    mixStrength: () => THREE.UniformNode<"float", number>;
+    minDepthThreshold: () => THREE.UniformNode<"float", number>;
+    maxDepthThreshold: () => THREE.UniformNode<"float", number>;
+    depthScale: () => THREE.UniformNode<"float", number>;
+    depthToBlurRatioBias: () => THREE.UniformNode<"float", number>;
+    distortion: () => THREE.UniformNode<"float", number>;
+    mixContrast: () => THREE.UniformNode<"float", number>;
+    blurRadius: () => THREE.UniformNode<"float", number>;
+}>;
+declare class MeshReflectorMaterial$1 extends MeshReflectorMaterial_base {
     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>>;
+    get reflectorTarget(): THREE.Object3D;
     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;
 }
 
 declare module '@react-three/fiber' {
@@ -320,6 +252,7 @@ type MeshRefractionMaterialType = Omit<ThreeElements['meshPhysicalMaterial'], 'a
     fastChroma?: boolean;
     tintColor?: THREE.ColorRepresentation;
     opacity?: number;
+    args?: [fastChroma?: boolean];
 };
 type MeshRefractionMaterialProps = Omit<MeshRefractionMaterialType, 'ref'>;
 declare module '@react-three/fiber' {
@@ -327,38 +260,17 @@ declare module '@react-three/fiber' {
         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;
+declare const MeshRefractionMaterialImpl_base: WithUniforms<typeof THREE.MeshPhysicalNodeMaterial, {
+    bounces: () => THREE.UniformNode<"float", number>;
+    fresnel: () => THREE.UniformNode<"float", number>;
+    aberrationStrength: () => THREE.UniformNode<"float", number>;
+    tintColor: () => THREE.UniformNode<"color", THREE.Color>;
+}>;
+declare class MeshRefractionMaterialImpl extends MeshRefractionMaterialImpl_base {
     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>;
 
@@ -372,41 +284,26 @@ type PortalProps = Omit<ThreeElements['meshBasicMaterial'], 'ref'> & {
     events?: boolean;
     children?: React.ReactNode;
 };
-declare class PortalMaterialImpl extends MeshBasicNodeMaterial {
-    private _blur;
-    private _map;
-    private _sdf;
-    private _blend;
-    private _size;
-    private _resolution;
+declare const PortalMaterialImpl_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    blur: () => THREE.UniformNode<"float", number>;
+    sdf: () => THREE.TextureNode<"vec4">;
+    blend: () => THREE.UniformNode<"float", number>;
+    size: () => THREE.UniformNode<"float", number>;
+    resolution: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+}>;
+declare class PortalMaterialImpl extends PortalMaterialImpl_base {
     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>;
 
-declare class DistortMaterialImplWebGPU extends THREE.MeshPhysicalNodeMaterial {
-    timeUniform: ReturnType<typeof uniform>;
-    distortUniform: ReturnType<typeof uniform>;
-    radiusUniform: ReturnType<typeof uniform>;
+declare const DistortMaterialImplWebGPU_base: WithUniforms<typeof THREE.MeshPhysicalNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    distort: () => THREE.UniformNode<"float", number>;
+    radius: () => THREE.UniformNode<"float", number>;
+}>;
+declare class DistortMaterialImplWebGPU extends DistortMaterialImplWebGPU_base {
     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 {
@@ -423,14 +320,12 @@ type MeshDistortMaterialProps = Omit<ThreeElements['distortMaterialImplWebGPU'],
 };
 declare const MeshDistortMaterial: ForwardRefComponent<MeshDistortMaterialProps, DistortMaterialImplWebGPU>;
 
-declare class WobbleMaterialImpl extends THREE.MeshStandardNodeMaterial {
-    timeUniform: ReturnType<typeof uniform>;
-    factorUniform: ReturnType<typeof uniform>;
+declare const WobbleMaterialImpl_base: WithUniforms<typeof THREE.MeshStandardNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    factor: () => THREE.UniformNode<"float", number>;
+}>;
+declare class WobbleMaterialImpl extends WobbleMaterialImpl_base {
     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 {
@@ -447,7 +342,7 @@ type WobbleMaterialProps = Omit<ThreeElements['meshStandardMaterial'], 'ref'> &
 };
 declare const MeshWobbleMaterial: ForwardRefComponent<WobbleMaterialProps, WobbleMaterialImpl>;
 
-declare function FakeCloudMaterial(BaseMaterial: typeof Material): Material;
+declare function FakeCloudMaterial(BaseMaterial: typeof Material): Material<three.MaterialEventMap>;
 
 type OutlinesProps = Omit<ThreeElements['group'], 'ref'> & {
     color?: ReactThreeFiber.Color;
@@ -501,7 +396,7 @@ type RenderCubeTextureProps = Omit<ThreeElements['texture'], 'ref' | 'args' | 'r
 };
 type RenderCubeTextureApi = {
     scene: THREE.Scene;
-    fbo: THREE.WebGLCubeRenderTarget;
+    fbo: CubeRenderTarget;
     camera: THREE.CubeCamera;
 };
 declare const RenderCubeTexture: ForwardRefComponent<RenderCubeTextureProps, RenderCubeTextureApi>;
@@ -577,7 +472,7 @@ type CubeCameraProps = Omit<ThreeElements['group'], 'children'> & {
     frames?: number;
 } & CubeCameraOptions;
 declare function useCubeCamera({ resolution, near, far, envMap, fog }?: CubeCameraOptions): {
-    fbo: WebGLCubeRenderTarget;
+    fbo: CubeRenderTarget;
     camera: CubeCamera$1;
     update: () => void;
 };
@@ -638,10 +533,6 @@ type DeviceOrientationControlsProps = Omit<ThreeElement<typeof DeviceOrientation
 };
 declare const DeviceOrientationControls: ForwardRefComponent<DeviceOrientationControlsProps, DeviceOrientationControls$1>;
 
-type ExpandedDragConfig = DragConfig & {
-    preventOverlap?: boolean;
-};
-
 type State = object;
 type StateSelector<T extends State, U> = (state: T) => U;
 type EqualityChecker<T> = (state: T, newState: T) => boolean;
@@ -796,6 +687,7 @@ type CloudsProps = Omit<ThreeElements['group'], 'ref'> & {
     frustumCulled?: boolean;
 };
 type CloudProps = Omit<ThreeElements['group'], 'ref'> & {
+    materialFactory?: (baseMaterial: typeof Material) => Material;
     seed?: number;
     segments?: number;
     bounds?: ReactThreeFiber.Vector3;
@@ -813,9 +705,52 @@ type CloudProps = Omit<ThreeElements['group'], 'ref'> & {
     opacity?: number;
     color?: ReactThreeFiber.Color;
 };
-declare const Clouds: React.ForwardRefExoticComponent<Omit<CloudsProps, "ref"> & React.RefAttributes<Group<three.Object3DEventMap>>>;
-declare const CloudInstance: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group<three.Object3DEventMap>>>;
-declare const Cloud: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group<three.Object3DEventMap>>>;
+declare const Clouds: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<Group<three.Object3DEventMap>, _react_three_fiber.MathProps<Group<three.Object3DEventMap>> & _react_three_fiber.ReactProps<Group<three.Object3DEventMap>> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<Group<three.Object3DEventMap>>>>, Omit<_react_three_fiber.InstanceProps<Group<three.Object3DEventMap>, typeof Group>, "object">>>, "ref"> & {
+    texture?: string;
+    limit?: number;
+    range?: number;
+    material?: typeof Material;
+    materialFactory?: (baseMaterial: typeof Material) => Material;
+    frustumCulled?: boolean;
+} & React.RefAttributes<Group<three.Object3DEventMap>>>;
+declare const CloudInstance: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<Group<three.Object3DEventMap>, _react_three_fiber.MathProps<Group<three.Object3DEventMap>> & _react_three_fiber.ReactProps<Group<three.Object3DEventMap>> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<Group<three.Object3DEventMap>>>>, Omit<_react_three_fiber.InstanceProps<Group<three.Object3DEventMap>, typeof Group>, "object">>>, "ref"> & {
+    materialFactory?: (baseMaterial: typeof Material) => Material;
+    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$1;
+        volume?: number;
+    };
+    growth?: number;
+    speed?: number;
+    fade?: number;
+    opacity?: number;
+    color?: ReactThreeFiber.Color;
+} & React.RefAttributes<Group<three.Object3DEventMap>>>;
+declare const Cloud: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<Group<three.Object3DEventMap>, _react_three_fiber.MathProps<Group<three.Object3DEventMap>> & _react_three_fiber.ReactProps<Group<three.Object3DEventMap>> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<Group<three.Object3DEventMap>>>>, Omit<_react_three_fiber.InstanceProps<Group<three.Object3DEventMap>, typeof Group>, "object">>>, "ref"> & {
+    materialFactory?: (baseMaterial: typeof Material) => Material;
+    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$1;
+        volume?: number;
+    };
+    growth?: number;
+    speed?: number;
+    fade?: number;
+    opacity?: number;
+    color?: ReactThreeFiber.Color;
+} & React.RefAttributes<Group<three.Object3DEventMap>>>;
 
 type CatmullRomLineProps = Omit<LineProps, 'ref' | 'segments'> & {
     closed?: boolean;
@@ -935,25 +870,25 @@ type Args<T> = T extends new (...args: any) => any ? ConstructorParameters<T> :
 type ShapeProps<T> = Omit<ThreeElements['mesh'], 'ref' | 'args'> & {
     args?: Args<T>;
 };
-declare const Box: ForwardRefComponent<ShapeProps<typeof THREE.BoxGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Circle: ForwardRefComponent<ShapeProps<typeof THREE.CircleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Cone: ForwardRefComponent<ShapeProps<typeof THREE.ConeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Cylinder: ForwardRefComponent<ShapeProps<typeof THREE.CylinderGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Sphere: ForwardRefComponent<ShapeProps<typeof THREE.SphereGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Plane: ForwardRefComponent<ShapeProps<typeof THREE.PlaneGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Tube: ForwardRefComponent<ShapeProps<typeof THREE.TubeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Torus: ForwardRefComponent<ShapeProps<typeof THREE.TorusGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const TorusKnot: ForwardRefComponent<ShapeProps<typeof THREE.TorusKnotGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Tetrahedron: ForwardRefComponent<ShapeProps<typeof THREE.TetrahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Ring: ForwardRefComponent<ShapeProps<typeof THREE.RingGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Polyhedron: ForwardRefComponent<ShapeProps<typeof THREE.PolyhedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Icosahedron: ForwardRefComponent<ShapeProps<typeof THREE.IcosahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Octahedron: ForwardRefComponent<ShapeProps<typeof THREE.OctahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Dodecahedron: ForwardRefComponent<ShapeProps<typeof THREE.DodecahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Extrude: ForwardRefComponent<ShapeProps<typeof THREE.ExtrudeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Lathe: ForwardRefComponent<ShapeProps<typeof THREE.LatheGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Capsule: ForwardRefComponent<ShapeProps<typeof THREE.CapsuleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-declare const Shape: ForwardRefComponent<ShapeProps<typeof THREE.ShapeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Box: ForwardRefComponent<ShapeProps<typeof THREE.BoxGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Circle: ForwardRefComponent<ShapeProps<typeof THREE.CircleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Cone: ForwardRefComponent<ShapeProps<typeof THREE.ConeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Cylinder: ForwardRefComponent<ShapeProps<typeof THREE.CylinderGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Sphere: ForwardRefComponent<ShapeProps<typeof THREE.SphereGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Plane: ForwardRefComponent<ShapeProps<typeof THREE.PlaneGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Tube: ForwardRefComponent<ShapeProps<typeof THREE.TubeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Torus: ForwardRefComponent<ShapeProps<typeof THREE.TorusGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const TorusKnot: ForwardRefComponent<ShapeProps<typeof THREE.TorusKnotGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Tetrahedron: ForwardRefComponent<ShapeProps<typeof THREE.TetrahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Ring: ForwardRefComponent<ShapeProps<typeof THREE.RingGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Polyhedron: ForwardRefComponent<ShapeProps<typeof THREE.PolyhedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Icosahedron: ForwardRefComponent<ShapeProps<typeof THREE.IcosahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Octahedron: ForwardRefComponent<ShapeProps<typeof THREE.OctahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Dodecahedron: ForwardRefComponent<ShapeProps<typeof THREE.DodecahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Extrude: ForwardRefComponent<ShapeProps<typeof THREE.ExtrudeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Lathe: ForwardRefComponent<ShapeProps<typeof THREE.LatheGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Capsule: ForwardRefComponent<ShapeProps<typeof THREE.CapsuleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
+declare const Shape: ForwardRefComponent<ShapeProps<typeof THREE.ShapeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>>;
 
 type Glyph = {
     _cachedOutline: string[];
@@ -992,7 +927,8 @@ type Text3DProps = Omit<ThreeElements['mesh'], 'ref'> & {
     font: FontData | string;
     bevelSegments?: number;
     smooth?: number;
-} & Omit<TextGeometryParameters, 'font'>;
+    height?: number;
+} & Omit<TextGeometryParameters, 'font' | 'depth'>;
 declare const Text3D: ForwardRefComponent<React.PropsWithChildren<Text3DProps & {
     letterSpacing?: number;
     lineHeight?: number;
@@ -1044,6 +980,12 @@ type OnDragStartProps = {
     origin: THREE.Vector3;
     directions: THREE.Vector3[];
 };
+type OnDragProps = {
+    local: THREE.Matrix4;
+    deltaLocal: THREE.Matrix4;
+    world: THREE.Matrix4;
+    deltaWorld: THREE.Matrix4;
+};
 type OnHoverProps = {
     component: 'Arrow' | 'Slider' | 'Rotator' | 'Sphere';
     axis: 0 | 1 | 2;
@@ -1074,8 +1016,8 @@ type PivotControlsProps = {
     annotations?: boolean;
     annotationsClass?: string;
     onDragStart?: (props: OnDragStartProps) => void;
-    onDrag?: (l: THREE.Matrix4, deltaL: THREE.Matrix4, w: THREE.Matrix4, deltaW: THREE.Matrix4) => void;
-    onDragEnd?: () => void;
+    onDrag?: (props: OnDragProps) => void;
+    onDragEnd?: (props: OnDragProps) => void;
     onHover?: (props: OnHoverProps) => void;
     depthTest?: boolean;
     renderOrder?: number;
@@ -1118,8 +1060,8 @@ type HelperType = Object3D & {
     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.RefObject<Object3D> | Falsey, helperConstructor: T, ...args: HelperArgs<ConstructorParameters<T>>): React.RefObject<HelperType | null>;
+type HelperArgs<T> = T extends [infer _, ...infer R] ? R : [];
+declare function useHelper<T extends HelperConstructor>(object3D: React.RefObject<Object3D | null> | Falsey, helperConstructor: T, ...args: HelperArgs<ConstructorParameters<T>>): React.RefObject<HelperType | null>;
 type HelperProps<T extends HelperConstructor> = {
     type: T;
     args?: HelperArgs<ConstructorParameters<T>>;
@@ -1176,7 +1118,7 @@ declare class PositionMesh extends THREE.Group {
     get geometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
     raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
 }
-declare const Instance: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
+declare const Instance: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<PositionMesh>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
     context?: React.Context<Api$1>;
 } & React.RefAttributes<unknown>>;
 declare const Instances: ForwardRefComponent<InstancesProps, THREE.InstancedMesh>;
@@ -1185,10 +1127,21 @@ interface MergedProps extends Omit<InstancesProps, 'children'> {
     children: (...instances: [React.FC<InstanceProps> & Record<string, React.FC<InstanceProps>>, ...React.FC<InstanceProps>[]]) => React.ReactNode;
 }
 declare const Merged: ForwardRefComponent<MergedProps, THREE.Group>;
-declare function createInstances<T = InstanceProps>(): readonly [React.ForwardRefExoticComponent<Omit<InstancesProps, "ref"> & React.RefAttributes<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap>>>, React.ForwardRefExoticComponent<React.PropsWithoutRef<T & Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
+declare function createInstances<T = InstanceProps>(): readonly [React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.InstancedMeshEventMap>, _react_three_fiber.MathProps<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.InstancedMeshEventMap>> & _react_three_fiber.ReactProps<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.InstancedMeshEventMap>> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.InstancedMeshEventMap>>>>, Omit<_react_three_fiber.InstanceProps<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.InstancedMeshEventMap>, typeof THREE.InstancedMesh>, "object">>>, "ref" | "args"> & {
+    context?: React.Context<Api$1>;
+    range?: number;
+    limit?: number;
+    frames?: number;
+} & React.RefAttributes<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.InstancedMeshEventMap>>>, React.ForwardRefExoticComponent<React.PropsWithoutRef<T & Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<PositionMesh>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
     context?: React.Context<Api$1>;
 }> & React.RefAttributes<PositionMesh & T>>];
-declare const InstancedAttribute: React.ForwardRefExoticComponent<Omit<InstancedAttributeProps, "ref"> & React.RefAttributes<THREE.InstancedBufferAttribute>>;
+declare const InstancedAttribute: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<THREE.InstancedBufferAttribute, _react_three_fiber.MathProps<THREE.InstancedBufferAttribute> & _react_three_fiber.ReactProps<THREE.InstancedBufferAttribute> & _react_three_fiber.NodeProps<THREE.InstancedBufferAttribute>>>, Omit<_react_three_fiber.InstanceProps<THREE.InstancedBufferAttribute, typeof THREE.InstancedBufferAttribute>, "object">>>, "ref" | "args"> & {
+    name: string;
+    defaultValue: any;
+    normalized?: boolean;
+    usage?: number;
+    type?: "float" | "int" | "uint" | "short" | "ushort" | "byte";
+} & React.RefAttributes<THREE.InstancedBufferAttribute>>;
 
 type Size = {
     w: number;
@@ -1292,7 +1245,40 @@ type SpriteAnimatorState = {
     ref: React.Ref<THREE.Group>;
 };
 declare function useSpriteAnimator(): SpriteAnimatorState | null;
-declare const SpriteAnimator: React.ForwardRefExoticComponent<Omit<SpriteAnimatorProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+declare const SpriteAnimator: React.ForwardRefExoticComponent<{
+    startFrame?: number;
+    endFrame?: number;
+    fps?: number;
+    frameName?: string;
+    textureDataURL?: string;
+    textureImageURL?: string;
+    loop?: boolean;
+    numberOfFrames?: number;
+    autoPlay?: boolean;
+    animationNames?: Array<string>;
+    onStart?: (data: AnimationEventData) => void;
+    onEnd?: (data: AnimationEventData) => void;
+    onLoopEnd?: (data: AnimationEventData) => void;
+    onFrame?: (data: AnimationEventData) => void;
+    play?: boolean;
+    pause?: boolean;
+    flipX?: boolean;
+    alphaTest?: number;
+    asSprite?: boolean;
+    offset?: number;
+    playBackwards?: boolean;
+    resetOnEnd?: boolean;
+    instanceItems?: Vector3[];
+    maxItems?: number;
+    spriteDataset?: {
+        spriteTexture: THREE.Texture;
+        spriteData: SpriteData | null;
+        aspect: Vector3;
+    } | null;
+    canvasRenderingContext2DSettings?: CanvasRenderingContext2DSettings;
+    roundFramePosition?: boolean;
+    meshProps?: CommonMeshProps;
+} & Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<THREE.Group<THREE.Object3DEventMap>, _react_three_fiber.MathProps<THREE.Group<THREE.Object3DEventMap>> & _react_three_fiber.ReactProps<THREE.Group<THREE.Object3DEventMap>> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<THREE.Group<THREE.Object3DEventMap>>>>, Omit<_react_three_fiber.InstanceProps<THREE.Group<THREE.Object3DEventMap>, typeof THREE.Group>, "object">>>, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
 
 type Api<T extends AnimationClip> = {
     ref: React.RefObject<Object3D | undefined | null>;
@@ -1378,7 +1364,7 @@ declare const Svg: ForwardRefComponent<SvgProps, Object3D>;
 declare function useDepthBuffer({ size, frames }?: {
     size?: number;
     frames?: number;
-}): DepthTexture | null;
+}): DepthTexture<three.DepthTextureImageData> | null;
 
 interface CubeTextureOptions {
     path: string;
@@ -1477,27 +1463,42 @@ declare function Fbx({ path, ...props }: {
 type Path = string | string[];
 type UseDraco = boolean | string;
 type UseMeshopt = boolean;
+type UseKTX2 = boolean | string;
 type ExtendLoader$1 = (loader: GLTFLoader) => void;
-declare const useGLTF: {
-    <T extends Path>(path: T, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader$1): T extends any[] ? (GLTF & ObjectMap)[] : GLTF & ObjectMap;
-    preload(path: Path, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader$1): void;
-    clear(path: Path): void;
-    setDecoderPath(path: string): void;
-};
+interface UseGLTFOptions {
+    draco?: UseDraco;
+    meshopt?: UseMeshopt;
+    ktx2?: UseKTX2;
+    extendLoader?: ExtendLoader$1;
+}
+declare function useGLTF<T extends Path>(path: T, optionsOrDraco?: UseGLTFOptions | UseDraco, useMeshoptArg?: UseMeshopt, useKTX2Arg?: UseKTX2, extendLoaderArg?: ExtendLoader$1): T extends any[] ? (GLTF & ObjectMap)[] : GLTF & ObjectMap;
+declare namespace useGLTF {
+    var preload: (path: Path, optionsOrDraco?: UseGLTFOptions | UseDraco, useMeshoptArg?: UseMeshopt, useKTX2Arg?: UseKTX2, extendLoaderArg?: ExtendLoader$1) => void;
+    var clear: (path: Path) => void;
+    var setDecoderPath: (path: string) => void;
+    var setKTX2TranscoderPath: (path: string) => void;
+}
 type GltfProps = Omit<CloneProps, 'object'> & {
     src: string;
     useDraco?: UseDraco;
     useMeshOpt?: UseMeshopt;
     extendLoader?: ExtendLoader$1;
+    options?: UseGLTFOptions;
 };
-declare const Gltf: React.ForwardRefExoticComponent<Omit<GltfProps, "ref"> & React.RefAttributes<three.Group<three.Object3DEventMap>>>;
+declare const Gltf: React.ForwardRefExoticComponent<Omit<CloneProps, "object"> & {
+    src: string;
+    useDraco?: UseDraco;
+    useMeshOpt?: UseMeshopt;
+    extendLoader?: ExtendLoader$1;
+    options?: UseGLTFOptions;
+} & React.RefAttributes<three.Group<three.Object3DEventMap>>>;
 
 type ExtendLoader = (loader: KTX2Loader) => void;
 declare function useKTX2<Url extends string[] | string | Record<string, string>>(input: Url, basisPath?: boolean | string, extendLoader?: ExtendLoader): Url extends any[] ? Texture$1[] : Url extends object ? {
     [key in keyof Url]: Texture$1;
 } : Texture$1;
 declare namespace useKTX2 {
-    var preload: (url: string extends any[] ? string[] : string, basisPath?: boolean | string, extendLoader?: ExtendLoader) => void;
+    var preload: (url: string | string[], basisPath?: boolean | string, extendLoader?: ExtendLoader) => void;
     var clear: (input: string | string[]) => void;
     var setTranscoderPath: (path: string) => void;
 }
@@ -1623,7 +1624,7 @@ declare const StatsGl: ForwardRefComponent<StatsGlProps, HTMLDivElement>;
 type FBOSettings = {
     depth?: boolean;
 } & RenderTargetOptions;
-declare function useFBO(width?: number | FBOSettings, height?: number, settings?: FBOSettings): THREE.WebGLRenderTarget<THREE.Texture<unknown>>;
+declare function useFBO(width?: number | FBOSettings, height?: number, settings?: FBOSettings): THREE.WebGLRenderTarget<THREE.Texture<unknown, THREE.TextureEventMap>>;
 type UseFBOParams = Parameters<typeof useFBO>;
 type FboProps = {
     children?: (target: Fbo) => React.ReactNode;
@@ -1637,7 +1638,7 @@ declare const Fbo: React.ForwardRefExoticComponent<{
     height?: UseFBOParams[1];
 } & {
     depth?: boolean;
-} & THREE.RenderTargetOptions & React.RefAttributes<THREE.WebGLRenderTarget<THREE.Texture<unknown>>>>;
+} & THREE.RenderTargetOptions & React.RefAttributes<THREE.WebGLRenderTarget<THREE.Texture<unknown, THREE.TextureEventMap>>>>;
 
 type FisheyeProps = ThreeElements['mesh'] & {
     zoom?: number;
@@ -1657,7 +1658,7 @@ declare const Mask: ForwardRefComponent<MaskProps, THREE.Mesh>;
 declare function useMask(id: number, inverse?: boolean): {
     stencilWrite: boolean;
     stencilRef: number;
-    stencilFunc: 517 | 514;
+    stencilFunc: 514 | 517;
     stencilFail: 7680;
     stencilZFail: 7680;
     stencilZPass: 7680;
@@ -1810,7 +1811,7 @@ type EnvironmentLoaderProps = {
     extensions?: (loader: Loader$1) => void;
     colorSpace?: ColorSpace;
 };
-declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<unknown> | CubeTexture$1<unknown>;
+declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<unknown, three.TextureEventMap> | CubeTexture$1<unknown>;
 declare namespace useEnvironment {
     var preload: (preloadOptions?: EnvironmentLoaderPreloadOptions) => void;
     var clear: (clearOptions?: EnvironmentLoaderClearOptions) => void;
@@ -1881,7 +1882,13 @@ type ResizeProps = Omit<ThreeElements['group'], 'ref'> & {
     box3?: THREE.Box3;
     precise?: boolean;
 };
-declare const Resize: React.ForwardRefExoticComponent<Omit<ResizeProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+declare const Resize: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<THREE.Group<THREE.Object3DEventMap>, _react_three_fiber.MathProps<THREE.Group<THREE.Object3DEventMap>> & _react_three_fiber.ReactProps<THREE.Group<THREE.Object3DEventMap>> & Partial<_react_three_fiber.EventHandlers> & _react_three_fiber.NodeProps<THREE.Group<THREE.Object3DEventMap>>>>, Omit<_react_three_fiber.InstanceProps<THREE.Group<THREE.Object3DEventMap>, typeof THREE.Group>, "object">>>, "ref"> & {
+    width?: boolean;
+    height?: boolean;
+    depth?: boolean;
+    box3?: THREE.Box3;
+    precise?: boolean;
+} & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
 
 type ScreenSizerProps = Omit<ThreeElements['object3D'], 'ref'> & {
     scale?: number;
@@ -2012,55 +2019,27 @@ declare module '@react-three/fiber' {
         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;
+declare const WireframeMaterialImpl_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    strokeOpacity: () => THREE.UniformNode<"float", number>;
+    fillOpacity: () => THREE.UniformNode<"float", number>;
+    fillMix: () => THREE.UniformNode<"float", number>;
+    thickness: () => THREE.UniformNode<"float", number>;
+    colorBackfaces: () => THREE.UniformNode<"bool", boolean>;
+    dashInvert: () => THREE.UniformNode<"bool", boolean>;
+    dash: () => THREE.UniformNode<"bool", boolean>;
+    dashRepeats: () => THREE.UniformNode<"float", number>;
+    dashLength: () => THREE.UniformNode<"float", number>;
+    squeeze: () => THREE.UniformNode<"bool", boolean>;
+    squeezeMin: () => THREE.UniformNode<"float", number>;
+    squeezeMax: () => THREE.UniformNode<"float", number>;
+    stroke: () => THREE.UniformNode<"color", THREE.Color>;
+    backfaceStroke: () => THREE.UniformNode<"color", THREE.Color>;
+    fill: () => THREE.UniformNode<"color", THREE.Color>;
+}>;
+declare class WireframeMaterialImpl extends WireframeMaterialImpl_base {
     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>;
@@ -2100,57 +2079,34 @@ declare function Wireframe({ geometry: customGeometry, ...props }: WireframeProp
 
 declare function BakeShadows(): null;
 
-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;
+declare const ConvolutionMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    inputBuffer: () => THREE.TextureNode<"vec4">;
+    depthBuffer: () => THREE.TextureNode<"vec4">;
+    resolution: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+    texelSize: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+    halfTexelSize: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+    kernelValue: () => THREE.UniformNode<"float", number>;
+    scale: () => THREE.UniformNode<"float", number>;
+    cameraNear: () => THREE.UniformNode<"float", number>;
+    cameraFar: () => THREE.UniformNode<"float", number>;
+    minDepthThreshold: () => THREE.UniformNode<"float", number>;
+    maxDepthThreshold: () => THREE.UniformNode<"float", number>;
+    depthScale: () => THREE.UniformNode<"float", number>;
+    depthToBlurRatioBias: () => THREE.UniformNode<"float", number>;
+    useDepth: () => THREE.UniformNode<"bool", boolean>;
+}>;
+declare class ConvolutionMaterial extends ConvolutionMaterial_base {
     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);
 }
 
-declare const DiscardMaterial: MeshBasicNodeMaterial;
+declare class DiscardNodeMaterial extends MeshBasicNodeMaterial {
+    constructor();
+}
+declare const DiscardMaterial: DiscardNodeMaterial;
 
 declare enum GradientType {
     Linear = "linear",
@@ -2164,7 +2120,7 @@ type GradientTextureProps = {
     type?: GradientType;
     innerCircleRadius?: number;
     outerCircleRadius?: number | 'auto';
-} & Omit<ThreeElements['canvasTexture'], 'args'>;
+} & Omit<ThreeElements['canvasTexture'], 'args' | 'type'>;
 declare function GradientTexture({ stops, colors, size, width, type, innerCircleRadius, outerCircleRadius, ...props }: GradientTextureProps): React.JSX.Element;
 
 type ImageProps = Omit<ThreeElements['mesh'], 'scale'> & {
@@ -2187,64 +2143,37 @@ type ImageProps = Omit<ThreeElements['mesh'], 'scale'> & {
 });
 declare const Image: ForwardRefComponent<ImageProps, THREE.Mesh>;
 
-declare class SpotLightMaterial extends MeshBasicNodeMaterial {
-    private _depth;
-    private _opacity;
-    private _attenuation;
-    private _anglePower;
-    private _spotPosition;
-    private _lightColor;
-    private _cameraNear;
-    private _cameraFar;
-    private _resolution;
+declare const SpotLightMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    depth: () => THREE.TextureNode<"vec4">;
+    attenuation: () => THREE.UniformNode<"float", number>;
+    anglePower: () => THREE.UniformNode<"float", number>;
+    spotPosition: () => THREE.UniformNode<"vec3", THREE.Vector3>;
+    lightColor: () => THREE.UniformNode<"color", THREE.Color>;
+    cameraNear: () => THREE.UniformNode<"float", number>;
+    cameraFar: () => THREE.UniformNode<"float", number>;
+    resolution: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+}>;
+declare class SpotLightMaterial extends SpotLightMaterial_base {
     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);
 }
 
-declare class StarfieldMaterial extends SpriteNodeMaterial {
-    private _time;
-    private _fade;
-    positionNode: ReturnType<typeof Fn>;
-    scaleNode: ReturnType<typeof Fn>;
-    colorNode: ReturnType<typeof Fn>;
+declare const StarfieldMaterial_base: WithUniforms<typeof SpriteNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    fade: () => THREE.UniformNode<"float", number>;
+}>;
+declare class StarfieldMaterial extends StarfieldMaterial_base {
     constructor();
     setTime(time: number): void;
     setFade(fade: number): void;
-    get time(): number;
-    set time(value: number);
-    get fade(): number;
-    set fade(value: number);
 }
 
-declare class SparklesMaterial extends SpriteNodeMaterial {
-    private _time;
-    private _pixelRatio;
-    positionNode: ReturnType<typeof Fn>;
-    scaleNode: ReturnType<typeof Fn>;
-    colorNode: ReturnType<typeof Fn>;
+declare const SparklesMaterial_base: WithUniforms<typeof SpriteNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    pixelRatio: () => THREE.UniformNode<"float", number>;
+}>;
+declare class SparklesMaterial extends SparklesMaterial_base {
     constructor();
-    get time(): number;
-    set time(value: number);
-    get pixelRatio(): number;
-    set pixelRatio(value: number);
 }
 
 type GridMaterialType = {
@@ -2271,7 +2200,7 @@ type SoftShadowsProps = {
     samples?: number;
     focus?: number;
 };
-declare function SoftShadows(props: SoftShadowsProps): null;
+declare function SoftShadows({ size, samples, focus }: SoftShadowsProps): null;
 
 type SpotLightProps = Omit<ThreeElements['spotLight'], 'ref'> & {
     depthBuffer?: Texture$1;
@@ -2319,4 +2248,4 @@ type SparklesProps = Omit<ThreeElements['mesh'], 'ref'> & {
 declare const Sparkles: ForwardRefComponent<SparklesProps, THREE.InstancedMesh>;
 
 export { AccumulativeShadows, AdaptiveDpr, AdaptiveEvents, BBAnchor, Backdrop, BakeShadows, Billboard, Bounds, Box, CameraShake, Capsule, CatmullRomLine, CausticsMaterial, CausticsNormalMaterial, CausticsProjectionMaterial, Center, Circle, Clone, Cloud, CloudInstance, Clouds, ComputedAttribute, Cone, ContactShadows, ConvolutionMaterial, CubeCamera, CubeTexture, CubicBezierLine, CurveModifier, CycleRaycast, Cylinder, Decal, Detailed, DetectGPU, DeviceOrientationControls, DiscardMaterial, Dodecahedron, Edges, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, Example, Extrude, FakeCloudMaterial, Fbo, Fbx, Fisheye, Float, GizmoHelper, GizmoViewcube, GizmoViewport, Gltf, GradientTexture, GradientType, Grid, Helper, Hud, Icosahedron, Image, Instance, InstancedAttribute, Instances, IsObject, Ktx2, Lathe, Lightformer, Line, Loader, Mask, MatcapTexture, Merged, MeshDistortMaterial, MeshPortalMaterial, MeshReflectorMaterial, MeshReflectorMaterial$1 as MeshReflectorMaterialImpl, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, MotionPathControls, NormalTexture, Octahedron, OrthographicCamera, Outlines, PerformanceMonitor, PerspectiveCamera, PivotControls, Plane, Point, PointMaterial, PointMaterialImpl, Points, PointsBuffer, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, Preload, PresentationControls, Progress, QuadraticBezierLine, RandomizedLight, RenderCubeTexture, RenderTexture, Resize, Ring, RoundedBox, RoundedBoxGeometry, Sampler, ScreenQuad, ScreenSizer, ScreenSpace, ScreenVideoTexture, Scroll, Segment, SegmentObject, Segments, Select, Shadow, Shape, Sky, SoftShadows, Sparkles, SparklesMaterial, Sphere, SpotLight, SpotLightMaterial, SpriteAnimator, Stage, StarfieldMaterial, Stars, Stats, StatsGl, Svg, Tetrahedron, Text3D, Texture, Torus, TorusKnot, Trail, TrailTexture, TransformControls, Tube, VideoTexture, View, WebcamVideoTexture, Wireframe, WireframeMaterial, WireframeMaterialShaders, 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, useTexture, useTrail, useTrailTexture, useVideoTexture, useWireframeUniforms };
-export type { AccumulativeShadowsProps, Args, BBAnchorProps, BackdropProps, BillboardProps, BoundsApi, BoundsProps, CalculatePosition, CameraShakeProps, CatmullRomLineProps, CenterProps, CloneProps, CloudProps, CloudsProps, ComputedAttributeProps, ContactShadowsProps, ContainerProps, CubeCameraOptions, CubeCameraProps, CubeTextureProps, CubicBezierLineProps, CurveModifierProps, CurveModifierRef, CycleRaycastProps, DecalProps, DetailedProps, DetectGPUProps, DeviceOrientationControlsProps, EdgesProps, EdgesRef, EnvironmentLoaderProps, EnvironmentProps, ExampleApi, ExampleProps, ExpandedDragConfig, FboProps, FisheyeProps, FloatProps, FontData, FrameData, GizmoHelperProps, GltfProps, Glyph, GradientTextureProps, GridMaterialType, GridProps, HelperProps, HudProps, ImageProps, InstanceProps, InstancedAttributeProps, InstancesProps, KeyboardControlsEntry, LightProps, LineProps, LoaderOptions, MaskProps, MergedProps, MeshDistortMaterialProps, MeshReflectorMaterialProps, MeshRefractionMaterialProps, MeshRefractionMaterialType, MeshTransmissionMaterialProps, MetaData, MotionPathProps, MotionPathRef, OnCenterCallbackProps, OnDragStartProps, OnHoverProps, OrbitControlsChangeEvent, OrthographicCameraProps, OutlinesProps, PerformanceMonitorApi, PerformanceMonitorProps, PerspectiveCameraProps, PivotControlsProps, PointMaterialProps, PointsBuffersProps, PointsInstancesProps, PortalProps, PositionalAudioProps, PreloadProps, PresentationControlProps, PresetsType, QuadraticBezierLineProps, QuadraticBezierLineRef, RandomizedLightProps, RenderCubeTextureApi, RenderCubeTextureProps, RenderTextureProps, ResizeProps, RoundedBoxGeometryProps, RoundedBoxProps, SamplerProps, ScreenQuadProps, ScreenSizerProps, ScreenSpaceProps, ScreenVideoTextureProps, ScrollControlsState, ScrollProps, SegmentProps, SegmentsProps, SelectProps, ShadowProps, ShadowType, ShakeController, ShapeProps, Size, SizeProps, SkyProps, SoftShadowsProps, SparklesProps, SpotLightProps, SpriteAnimatorProps, SpriteData, StageProps, StarsProps, StatsGlProps, StatsProps, SvgProps, Text3DProps, TrailProps, TrailTextureProps, TransformControlsProps, TransformFn, VideoTextureProps, ViewProps, ViewportProps, WebcamVideoTextureProps, WireframeMaterialProps, WireframeMaterialType, WobbleMaterialProps, useSurfaceSamplerProps };
+export type { AccumulativeShadowsProps, Args, BBAnchorProps, BackdropProps, BillboardProps, BoundsApi, BoundsProps, CalculatePosition, CameraShakeProps, CatmullRomLineProps, CenterProps, CloneProps, CloudProps, CloudsProps, ComputedAttributeProps, ContactShadowsProps, ContainerProps, CubeCameraOptions, CubeCameraProps, CubeTextureProps, CubicBezierLineProps, CurveModifierProps, CurveModifierRef, CycleRaycastProps, DecalProps, DetailedProps, DetectGPUProps, DeviceOrientationControlsProps, EdgesProps, EdgesRef, EnvironmentLoaderProps, EnvironmentProps, ExampleApi, ExampleProps, FboProps, FisheyeProps, FloatProps, FontData, FrameData, GizmoHelperProps, GltfProps, Glyph, GradientTextureProps, GridMaterialType, GridProps, HelperProps, HudProps, ImageProps, InstanceProps, InstancedAttributeProps, InstancesProps, KeyboardControlsEntry, LightProps, LineProps, LoaderOptions, MaskProps, MergedProps, MeshDistortMaterialProps, MeshReflectorMaterialProps, MeshRefractionMaterialProps, MeshRefractionMaterialType, MeshTransmissionMaterialProps, MetaData, MotionPathProps, MotionPathRef, OnCenterCallbackProps, OnDragStartProps, OnHoverProps, OrbitControlsChangeEvent, OrthographicCameraProps, OutlinesProps, PerformanceMonitorApi, PerformanceMonitorProps, PerspectiveCameraProps, PivotControlsProps, PointMaterialProps, PointsBuffersProps, PointsInstancesProps, PortalProps, PositionalAudioProps, PreloadProps, PresentationControlProps, PresetsType, QuadraticBezierLineProps, QuadraticBezierLineRef, RandomizedLightProps, RenderCubeTextureApi, RenderCubeTextureProps, RenderTextureProps, ResizeProps, RoundedBoxGeometryProps, RoundedBoxProps, SamplerProps, ScreenQuadProps, ScreenSizerProps, ScreenSpaceProps, ScreenVideoTextureProps, ScrollControlsState, ScrollProps, SegmentProps, SegmentsProps, SelectProps, ShadowProps, ShadowType, ShakeController, ShapeProps, Size, SizeProps, SkyProps, SoftShadowsProps, SparklesProps, SpotLightProps, SpriteAnimatorProps, SpriteData, StageProps, StarsProps, StatsGlProps, StatsProps, SvgProps, Text3DProps, TrailProps, TrailTextureProps, TransformControlsProps, TransformFn, VideoTextureProps, ViewProps, ViewportProps, WebcamVideoTextureProps, WireframeMaterialProps, WireframeMaterialType, WobbleMaterialProps, useSurfaceSamplerProps };