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

package/legacy/index.d.ts

@@ -0,0 +1,2350 @@
+import * as React from 'react';
+import { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, CSSProperties } from 'react';
+import * as _react_three_fiber from '@react-three/fiber';
+import { ThreeElements, ReactThreeFiber, ThreeElement, Vector2, Vector3, ThreeEvent, Color as Color$1, ObjectMap, ComputeFunction, Euler, ConstructorRepresentation } from '@react-three/fiber';
+import * as THREE from 'three';
+import { MeshStandardMaterial, Texture as Texture$1, Matrix4, MeshPhysicalMaterial, MeshPhysicalMaterialParameters, IUniform, MeshStandardMaterialParameters, Material, ColorSpace, TextureDataType, Color, ColorRepresentation, Object3D, Fog, FogExp2, WebGLCubeRenderTarget, CubeCamera as CubeCamera$1, OrthographicCamera as OrthographicCamera$1, PerspectiveCamera as PerspectiveCamera$1, Event, Camera, 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, Scene, PlaneGeometry, MeshBasicMaterial, WebGLRenderer, WebGLRenderTarget, ShaderMaterial, Uniform as Uniform$2, SpotLight as SpotLight$1, Points as Points$1 } from 'three';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
+import { LineMaterialParameters, LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
+import { ArcballControls as ArcballControls$1 } from 'three/examples/jsm/controls/ArcballControls.js';
+import { DeviceOrientationControls as DeviceOrientationControls$1 } from 'three-stdlib';
+import { DragConfig } from '@use-gesture/react';
+import { FirstPersonControls as FirstPersonControls$1 } from 'three/examples/jsm/controls/FirstPersonControls.js';
+import { FlyControls as FlyControls$1 } from 'three/examples/jsm/controls/FlyControls.js';
+import * as zustand from 'zustand';
+import { StoreApi } from 'zustand';
+import { MapControls as MapControls$1 } from 'three/examples/jsm/controls/MapControls.js';
+import { OrbitControls as OrbitControls$1 } from 'three/addons/controls/OrbitControls.js';
+import { PointerLockControls as PointerLockControls$1 } from 'three/examples/jsm/controls/PointerLockControls.js';
+import { TrackballControls as TrackballControls$1 } from 'three/examples/jsm/controls/TrackballControls.js';
+import { Line2 } from 'three/examples/jsm/lines/Line2.js';
+import { Flow } from 'three/examples/jsm/modifiers/CurveModifier.js';
+import { TextGeometry, TextGeometryParameters } from 'three/examples/jsm/geometries/TextGeometry.js';
+import * as three_examples_jsm_loaders_FontLoader_js from 'three/examples/jsm/loaders/FontLoader.js';
+import { TransformControls as TransformControls$1 } from 'three/examples/jsm/controls/TransformControls.js';
+import { Falsey, Assign } from 'utility-types';
+import * as hls_js from 'hls.js';
+import hls_js__default from 'hls.js';
+import { GLTFLoader, GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import * as detect_gpu from 'detect-gpu';
+import { GetGPUTier } from 'detect-gpu';
+import Stats$1 from 'stats-gl';
+import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
+import { Sky as Sky$1 } from 'three/examples/jsm/objects/Sky.js';
+import { MeshBVHUniformStruct } from 'three-mesh-bvh';
+
+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;
+
+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>;
+
+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.Mesh<THREE.PlaneGeometry, SoftShadowMaterialProps & THREE.ShaderMaterial>;
+    reset: () => void;
+    update: (frames?: number) => void;
+}
+interface AccumulativeLightContext {
+    update: () => void;
+}
+type SoftShadowMaterialProps = {
+    map: THREE.Texture;
+    color?: ReactThreeFiber.Color;
+    alphaTest?: number;
+    blend?: number;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps;
+    }
+}
+declare const accumulativeContext: React.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>;
+
+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.RefObject<THREE.Object3D>;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        causticsProjectionMaterial: ThreeElements['meshNormalMaterial'] & {
+            viewMatrix?: {
+                value: THREE.Matrix4;
+            };
+            color?: ReactThreeFiber.Color;
+            causticsTexture?: THREE.Texture;
+            causticsTextureB?: THREE.Texture;
+            lightProjMatrix?: THREE.Matrix4;
+            lightViewMatrix?: THREE.Matrix4;
+        };
+    }
+}
+declare const Caustics: ForwardRefComponent<CausticsProps, THREE.Group>;
+
+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 const MeshTransmissionMaterial: ForwardRefComponent<MeshTransmissionMaterialProps, ThreeElements['meshTransmissionMaterial']>;
+
+declare class MeshReflectorMaterial$1 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$1 | null;
+    set tDiffuse(v: Texture$1 | null);
+    get tDepth(): Texture$1 | null;
+    set tDepth(v: Texture$1 | null);
+    get distortionMap(): Texture$1 | null;
+    set distortionMap(v: Texture$1 | null);
+    get tDiffuseBlur(): Texture$1 | null;
+    set tDiffuseBlur(v: Texture$1 | null);
+    get textureMatrix(): Matrix4 | null;
+    set textureMatrix(v: Matrix4 | null);
+    get hasBlur(): boolean;
+    set hasBlur(v: boolean);
+    get mirror(): number;
+    set mirror(v: number);
+    get mixBlur(): number;
+    set mixBlur(v: number);
+    get mixStrength(): number;
+    set mixStrength(v: number);
+    get minDepthThreshold(): number;
+    set minDepthThreshold(v: number);
+    get maxDepthThreshold(): number;
+    set maxDepthThreshold(v: number);
+    get depthScale(): number;
+    set depthScale(v: number);
+    get depthToBlurRatioBias(): number;
+    set depthToBlurRatioBias(v: number);
+    get distortion(): number;
+    set distortion(v: number);
+    get mixContrast(): number;
+    set mixContrast(v: number);
+}
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        meshReflectorMaterialImpl: ThreeElement<typeof MeshReflectorMaterial$1>;
+    }
+}
+type MeshReflectorMaterialProps = ThreeElements['meshReflectorMaterialImpl'] & {
+    resolution?: number;
+    blur?: [number, number] | number;
+    reflectorOffset?: number;
+};
+declare const MeshReflectorMaterial: ForwardRefComponent<MeshReflectorMaterialProps, MeshReflectorMaterial$1>;
+
+declare const MeshRefractionMaterial: _react_three_fiber.ConstructorRepresentation<THREE.ShaderMaterial & {
+    envMap: null;
+    bounces: number;
+    ior: number;
+    correctMips: true;
+    aberrationStrength: number;
+    fresnel: number;
+    bvh: MeshBVHUniformStruct;
+    color: THREE.Color;
+    opacity: number;
+    resolution: THREE.Vector2;
+    viewMatrixInverse: THREE.Matrix4;
+    projectionMatrixInverse: THREE.Matrix4;
+}> & {
+    key: string;
+};
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        portalMaterialImpl: ThreeElements['shaderMaterial'] & {
+            resolution: ReactThreeFiber.Vector2;
+            blur: number;
+            blend: number;
+            size?: number;
+            sdf?: THREE.Texture;
+            map?: THREE.Texture;
+        };
+    }
+}
+type PortalProps = Omit<ThreeElements['portalMaterialImpl'], 'ref' | 'blend'> & {
+    blend?: number;
+    blur?: number;
+    resolution?: number;
+    worldUnits?: boolean;
+    eventPriority?: number;
+    renderPriority?: number;
+    events?: boolean;
+};
+declare const MeshPortalMaterial: ForwardRefComponent<PortalProps, ThreeElements['portalMaterialImpl']>;
+
+interface Uniform$1<T> {
+    value: T;
+}
+declare class DistortMaterialImpl extends MeshPhysicalMaterial {
+    _time: Uniform$1<number>;
+    _distort: Uniform$1<number>;
+    _radius: Uniform$1<number>;
+    constructor(parameters?: MeshPhysicalMaterialParameters);
+    onBeforeCompile(shader: {
+        vertexShader: string;
+        uniforms: {
+            [uniform: string]: IUniform;
+        };
+    }): void;
+    get time(): number;
+    set time(v: number);
+    get distort(): number;
+    set distort(v: number);
+    get radius(): number;
+    set radius(v: number);
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        distortMaterialImpl: ThreeElements['meshPhysicalMaterial'] & {
+            time?: number;
+            distort?: number;
+            radius?: number;
+        };
+    }
+}
+type MeshDistortMaterialProps = Omit<ThreeElements['distortMaterialImpl'], 'ref'> & {
+    speed?: number;
+    factor?: number;
+};
+declare const MeshDistortMaterial: ForwardRefComponent<MeshDistortMaterialProps, DistortMaterialImpl>;
+
+interface Uniform<T> {
+    value: T;
+}
+declare class WobbleMaterialImpl extends MeshStandardMaterial {
+    readonly timeUniform: Uniform<number>;
+    readonly factorUniform: Uniform<number>;
+    readonly isMeshStandardMaterial: true;
+    constructor(parameters?: MeshStandardMaterialParameters);
+    onBeforeCompile(shader: {
+        vertexShader: string;
+        uniforms: {
+            [uniform: string]: IUniform;
+        };
+    }): void;
+    get time(): number;
+    set time(v: number);
+    get factor(): number;
+    set factor(v: number);
+}
+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>;
+
+declare function CloudMaterial(BaseMaterial: typeof Material): Material;
+
+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.JSX.Element;
+
+type EffectsProps = Omit<ThreeElements['effectComposer'], 'ref' | 'args'> & {
+    multisamping?: number;
+    colorSpace?: ColorSpace;
+    type?: TextureDataType;
+    renderIndex?: number;
+    disableGamma?: boolean;
+    disableRenderPass?: boolean;
+    disableRender?: boolean;
+    depthBuffer?: boolean;
+    stencilBuffer?: boolean;
+    anisotropy?: number;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        effectComposer: ThreeElement<typeof EffectComposer>;
+        renderPass: ThreeElement<typeof RenderPass>;
+        shaderPass: ThreeElement<typeof ShaderPass>;
+    }
+}
+declare const isWebGL2Available: () => boolean;
+declare const Effects: ForwardRefComponent<EffectsProps, EffectComposer>;
+
+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.ReactNode;
+};
+declare const RenderTexture: ForwardRefComponent<RenderTextureProps, THREE.Texture>;
+
+type LineProps = Omit<{
+    points: ReadonlyArray<Vector2 | Vector3>;
+    vertexColors?: ReadonlyArray<Color | [number, number, number] | [number, number, number, number]>;
+    lineWidth?: number;
+    segments?: boolean;
+} & Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<ThreeElement<typeof Line2>, 'ref' | 'args'> & Omit<ThreeElement<typeof LineMaterial>, 'ref' | 'color' | 'vertexColors' | 'args'> & {
+    color?: ColorRepresentation;
+}, 'ref'>;
+declare const Line: ForwardRefComponent<LineProps, Line2 | LineSegments2>;
+
+type SegmentsProps = LineMaterialParameters & {
+    limit?: number;
+    lineWidth?: number;
+    children: React.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>;
+
+type Settings$1 = {
+    width: number;
+    length: number;
+    decay: number;
+    local: boolean;
+    stride: number;
+    interval: number;
+};
+type TrailProps = {
+    color?: ColorRepresentation;
+    attenuation?: (t: number) => number;
+    target?: React.RefObject<Object3D>;
+} & Partial<Settings$1>;
+declare function useTrail(target: Object3D, settings: Partial<Settings$1>, pointCount: number): React.RefObject<Float32Array>;
+declare const Trail: ForwardRefComponent<React.PropsWithChildren<TrailProps>, Line2>;
+
+type CubeCameraOptions = {
+    resolution?: number;
+    near?: number;
+    far?: number;
+    envMap?: Texture$1;
+    fog?: Fog | FogExp2;
+};
+type CubeCameraProps = Omit<ThreeElements['group'], 'children'> & {
+    children?: (tex: Texture$1) => React.ReactNode;
+    frames?: number;
+} & CubeCameraOptions;
+declare function useCubeCamera({ resolution, near, far, envMap, fog }?: CubeCameraOptions): {
+    fbo: WebGLCubeRenderTarget;
+    camera: CubeCamera$1;
+    update: () => void;
+};
+declare function CubeCamera({ children, frames, resolution, near, far, envMap, fog, ...props }: CubeCameraProps): React.JSX.Element;
+
+type OrthographicCameraProps = Omit<ThreeElements['orthographicCamera'], 'ref' | 'children'> & {
+    makeDefault?: boolean;
+    manual?: boolean;
+    children?: React.ReactNode | ((texture: THREE.Texture) => React.ReactNode);
+    frames?: number;
+    resolution?: number;
+    envMap?: THREE.Texture;
+};
+declare const OrthographicCamera: ForwardRefComponent<OrthographicCameraProps, OrthographicCamera$1>;
+
+type PerspectiveCameraProps = Omit<ThreeElements['perspectiveCamera'], 'ref' | 'children'> & {
+    makeDefault?: boolean;
+    manual?: boolean;
+    children?: React.ReactNode | ((texture: THREE.Texture) => React.ReactNode);
+    frames?: number;
+    resolution?: number;
+    envMap?: THREE.Texture;
+};
+declare const PerspectiveCamera: ForwardRefComponent<PerspectiveCameraProps, PerspectiveCamera$1>;
+
+type ArcballControlsProps = Omit<Overwrite<ThreeElement<typeof ArcballControls$1>, {
+    target?: ReactThreeFiber.Vector3;
+    camera?: OrthographicCamera$1 | PerspectiveCamera$1;
+    domElement?: HTMLElement;
+    regress?: boolean;
+    makeDefault?: boolean;
+    onChange?: (e?: Event) => void;
+    onStart?: (e?: Event) => void;
+    onEnd?: (e?: Event) => void;
+}>, 'ref' | 'args'>;
+declare const ArcballControls: ForwardRefComponent<ArcballControlsProps, ArcballControls$1>;
+
+type DeviceOrientationControlsProps = Omit<ThreeElement<typeof DeviceOrientationControls$1>, 'ref' | 'args'> & {
+    camera?: THREE.Camera;
+    onChange?: (e?: THREE.Event) => void;
+    makeDefault?: boolean;
+};
+declare const DeviceOrientationControls: ForwardRefComponent<DeviceOrientationControlsProps, DeviceOrientationControls$1>;
+
+type DragControlsProps = {
+    autoTransform?: boolean;
+    matrix?: THREE.Matrix4;
+    axisLock?: 'x' | 'y' | 'z';
+    dragLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    onHover?: (hovering: boolean) => void;
+    onDragStart?: (origin: THREE.Vector3) => void;
+    onDrag?: (localMatrix: THREE.Matrix4, deltaLocalMatrix: THREE.Matrix4, worldMatrix: THREE.Matrix4, deltaWorldMatrix: THREE.Matrix4) => void;
+    onDragEnd?: () => void;
+    children: React.ReactNode;
+    dragConfig?: DragConfig;
+};
+declare const DragControls: ForwardRefComponent<DragControlsProps, THREE.Group>;
+
+type FirstPersonControlsProps = Omit<ThreeElement<typeof FirstPersonControls$1>, 'ref' | 'args'> & {
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+};
+declare const FirstPersonControls: ForwardRefComponent<FirstPersonControlsProps, FirstPersonControls$1>;
+
+type FlyControlsProps = Omit<ThreeElement<typeof FlyControls$1>, 'ref' | 'args'> & {
+    onChange?: (e?: THREE.Event) => void;
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+};
+declare const FlyControls: ForwardRefComponent<FlyControlsProps, FlyControls$1>;
+
+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.ReactNode;
+    onChange?: (name: string, pressed: boolean, state: KeyboardControlsState) => void;
+    domElement?: HTMLElement;
+};
+declare function KeyboardControls({ map, children, onChange, domElement }: KeyboardControlsProps): React.JSX.Element;
+type Selector<T extends string = string> = (state: KeyboardControlsState<T>) => boolean;
+declare function useKeyboardControls<T extends string = string>(): [
+    StoreApiWithSubscribeWithSelector<KeyboardControlsState<T>>['subscribe'],
+    StoreApiWithSubscribeWithSelector<KeyboardControlsState<T>>['getState']
+];
+declare function useKeyboardControls<T extends string = string>(sel: Selector<T>): ReturnType<Selector<T>>;
+
+type MapControlsProps = Omit<Overwrite<ThreeElement<typeof MapControls$1>, {
+    target?: ReactThreeFiber.Vector3;
+    camera?: THREE.Camera;
+    makeDefault?: boolean;
+    onChange?: (e?: THREE.Event) => void;
+    onStart?: (e?: THREE.Event) => void;
+    onEnd?: (e?: THREE.Event) => void;
+    domElement?: HTMLElement;
+}>, 'ref' | 'args'>;
+declare const MapControls: ForwardRefComponent<MapControlsProps, MapControls$1>;
+
+type MotionPathProps = ThreeElements['group'] & {
+    curves?: THREE.Curve<THREE.Vector3>[];
+    debug?: boolean;
+    debugColor?: THREE.ColorRepresentation;
+    object?: React.RefObject<THREE.Object3D>;
+    focus?: [x: number, y: number, z: number] | React.RefObject<THREE.Object3D>;
+    loop?: boolean;
+    offset?: number;
+    smooth?: boolean | number;
+    eps?: number;
+    damping?: number;
+    focusDamping?: number;
+    maxSpeed?: number;
+};
+type MotionState = {
+    current: number;
+    path: THREE.CurvePath<THREE.Vector3>;
+    focus: React.RefObject<THREE.Object3D> | [x: number, y: number, z: number] | undefined;
+    object: React.RefObject<THREE.Object3D>;
+    offset: number;
+    point: THREE.Vector3;
+    tangent: THREE.Vector3;
+    next: THREE.Vector3;
+};
+type MotionPathRef = THREE.Group & {
+    motion: MotionState;
+};
+declare function useMotion(): MotionState;
+declare const MotionPathControls: React.ForwardRefExoticComponent<Omit<MotionPathProps, "ref"> & React.RefAttributes<MotionPathRef>>;
+
+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>;
+
+type PointerLockControlsProps = Omit<ThreeElement<typeof PointerLockControls$1>, 'ref' | 'args'> & {
+    domElement?: HTMLElement;
+    selector?: string;
+    enabled?: boolean;
+    camera?: THREE.Camera;
+    onChange?: (e?: THREE.Event) => void;
+    onLock?: (e?: THREE.Event) => void;
+    onUnlock?: (e?: THREE.Event) => void;
+    makeDefault?: boolean;
+};
+declare const PointerLockControls: ForwardRefComponent<PointerLockControlsProps, PointerLockControls$1>;
+
+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.ReactNode;
+    domElement?: HTMLElement;
+};
+declare function PresentationControls({ enabled, snap, global, domElement, cursor, children, speed, rotation, zoom, polar, azimuth, damping, }: PresentationControlProps): React.JSX.Element;
+
+type ScrollControlsProps = {
+    eps?: number;
+    horizontal?: boolean;
+    infinite?: boolean;
+    pages?: number;
+    distance?: number;
+    damping?: number;
+    maxSpeed?: number;
+    prepend?: boolean;
+    enabled?: boolean;
+    style?: React.CSSProperties;
+    children: React.ReactNode;
+};
+type ScrollControlsState = {
+    el: HTMLDivElement;
+    eps: number;
+    fill: HTMLDivElement;
+    fixed: HTMLDivElement;
+    horizontal: boolean | undefined;
+    damping: number;
+    offset: number;
+    delta: number;
+    pages: number;
+    range(from: number, distance: number, margin?: number): number;
+    curve(from: number, distance: number, margin?: number): number;
+    visible(from: number, distance: number, margin?: number): boolean;
+};
+declare function useScroll(): ScrollControlsState;
+declare function ScrollControls({ eps, enabled, infinite, horizontal, pages, distance, damping, maxSpeed, prepend, style, children, }: ScrollControlsProps): React.JSX.Element;
+interface ScrollPropsWithFalseHtml {
+    children?: React.ReactNode;
+    html?: false;
+    style?: never;
+}
+interface ScrollPropsWithTrueHtml {
+    children?: React.ReactNode;
+    html: true;
+    style?: React.CSSProperties;
+}
+type ScrollProps = ScrollPropsWithFalseHtml | ScrollPropsWithTrueHtml;
+declare const Scroll: ForwardRefComponent<ScrollProps, THREE.Group & HTMLDivElement>;
+
+type TrackballControlsProps = Omit<Overwrite<ThreeElement<typeof TrackballControls$1>, {
+    target?: ReactThreeFiber.Vector3;
+    camera?: THREE.Camera;
+    domElement?: HTMLElement;
+    regress?: boolean;
+    makeDefault?: boolean;
+    onChange?: (e?: THREE.Event) => void;
+    onStart?: (e?: THREE.Event) => void;
+    onEnd?: (e?: THREE.Event) => void;
+}>, 'ref' | 'args'>;
+declare const TrackballControls: ForwardRefComponent<TrackballControlsProps, TrackballControls$1>;
+
+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>;
+
+type CloudState = {
+    uuid: string;
+    index: number;
+    segments: number;
+    dist: number;
+    matrix: Matrix4;
+    bounds: Vector3$1;
+    position: Vector3$1;
+    volume: number;
+    length: number;
+    ref: React.RefObject<Group>;
+    speed: number;
+    growth: number;
+    opacity: number;
+    fade: number;
+    density: number;
+    rotation: number;
+    rotationFactor: number;
+    color: Color;
+};
+type CloudsProps = Omit<ThreeElements['group'], 'ref'> & {
+    texture?: string;
+    limit?: number;
+    range?: number;
+    material?: typeof Material;
+    materialFactory?: (baseMaterial: typeof Material) => Material;
+    frustumCulled?: boolean;
+};
+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$1;
+        volume?: number;
+    };
+    growth?: number;
+    speed?: number;
+    fade?: number;
+    opacity?: number;
+    color?: ReactThreeFiber.Color;
+};
+declare const Clouds: React.ForwardRefExoticComponent<Omit<CloudsProps, "ref"> & React.RefAttributes<Group<THREE.Object3DEventMap>>>;
+declare const CloudInstance: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group<THREE.Object3DEventMap>>>;
+declare const Cloud: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group<THREE.Object3DEventMap>>>;
+
+type CatmullRomLineProps = Omit<LineProps, 'ref' | 'segments'> & {
+    closed?: boolean;
+    curveType?: 'centripetal' | 'chordal' | 'catmullrom';
+    tension?: number;
+    segments?: number;
+    LineComponent?: React.ComponentType<LineProps>;
+};
+declare const CatmullRomLine: ForwardRefComponent<CatmullRomLineProps, Line2>;
+
+type CubicBezierLineProps = Omit<LineProps, 'points' | 'ref'> & {
+    start: Vector3$1 | [number, number, number];
+    end: Vector3$1 | [number, number, number];
+    midA: Vector3$1 | [number, number, number];
+    midB: Vector3$1 | [number, number, number];
+    segments?: number;
+    LineComponent?: React.ComponentType<LineProps>;
+};
+declare const CubicBezierLine: ForwardRefComponent<CubicBezierLineProps, Line2>;
+
+interface CurveModifierProps {
+    children: React.ReactElement<ThreeElements['mesh']>;
+    curve?: THREE.Curve<THREE.Vector3>;
+}
+type CurveModifierRef = Flow;
+declare const CurveModifier: ForwardRefComponent<CurveModifierProps, CurveModifierRef>;
+
+type DecalProps = Omit<_react_three_fiber.ThreeElements['mesh'], 'ref' | 'children'> & {
+    debug?: boolean;
+    mesh?: React.RefObject<THREE.Mesh>;
+    position?: _react_three_fiber.Vector3;
+    rotation?: _react_three_fiber.Euler | number;
+    scale?: _react_three_fiber.Vector3;
+    map?: THREE.Texture;
+    children?: React.ReactNode;
+    polygonOffsetFactor?: number;
+    depthTest?: boolean;
+};
+declare const Decal: ForwardRefComponent<DecalProps, THREE.Mesh>;
+
+type DetailedProps = Omit<ThreeElements['lOD'], 'ref'> & {
+    children: React.ReactElement<Object3D>[];
+    hysteresis?: number;
+    distances: number[];
+};
+declare const Detailed: ForwardRefComponent<DetailedProps, LOD>;
+
+interface EdgesProps {
+    threshold?: number;
+    geometry?: THREE.BufferGeometry;
+    lineWidth?: number;
+    color?: THREE.ColorRepresentation;
+    scale?: number;
+    LineComponent?: React.ComponentType<LineProps>;
+}
+interface EdgesRef {
+    computeLineDistances: () => void;
+}
+declare const Edges: ForwardRefComponent<EdgesProps, EdgesRef>;
+
+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.Group {
+    size: number;
+    color: THREE.Color;
+    instance: React.RefObject<THREE.Points | undefined>;
+    instanceKey: React.RefObject<PositionPoint | undefined>;
+    constructor();
+    get geometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}
+declare const Point: ForwardRefComponent<ThreeElements['positionPoint'], PositionPoint>;
+type PointsBuffersProps = ThreeElements['points'] & {
+    positions: Float32Array;
+    colors?: Float32Array;
+    sizes?: Float32Array;
+    stride?: 2 | 3;
+};
+declare const PointsBuffer: ForwardRefComponent<PointsBuffersProps, THREE.Points>;
+declare const Points: ForwardRefComponent<PointsBuffersProps | PointsInstancesProps, THREE.Points>;
+
+type QuadraticBezierLineRef = Line2 & {
+    setPoints(start: Vector3$1 | [number, number, number], end: Vector3$1 | [number, number, number], mid: Vector3$1 | [number, number, number]): void;
+};
+type QuadraticBezierLineProps = Omit<LineProps, 'points' | 'ref'> & {
+    start: Vector3$1 | [number, number, number];
+    end: Vector3$1 | [number, number, number];
+    mid?: Vector3$1 | [number, number, number];
+    segments?: number;
+    LineComponent?: React.ComponentType<LineProps>;
+};
+declare const QuadraticBezierLine: ForwardRefComponent<QuadraticBezierLineProps, QuadraticBezierLineRef>;
+
+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>;
+declare const RoundedBoxGeometry: ForwardRefComponent<RoundedBoxGeometryProps, ExtrudeGeometry>;
+
+type ScreenQuadProps = Omit<ThreeElements['mesh'], 'ref' | 'args'>;
+declare const ScreenQuad: ForwardRefComponent<ScreenQuadProps, THREE.Mesh>;
+
+type Args<T> = T extends new (...args: any) => any ? ConstructorParameters<T> : T;
+type ShapeProps<T> = Omit<ThreeElements['mesh'], 'ref' | 'args'> & {
+    args?: Args<T>;
+};
+declare const Box: ForwardRefComponent<ShapeProps<typeof THREE.BoxGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Circle: ForwardRefComponent<ShapeProps<typeof THREE.CircleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Cone: ForwardRefComponent<ShapeProps<typeof THREE.ConeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Cylinder: ForwardRefComponent<ShapeProps<typeof THREE.CylinderGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Sphere: ForwardRefComponent<ShapeProps<typeof THREE.SphereGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Plane: ForwardRefComponent<ShapeProps<typeof THREE.PlaneGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Tube: ForwardRefComponent<ShapeProps<typeof THREE.TubeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Torus: ForwardRefComponent<ShapeProps<typeof THREE.TorusGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const TorusKnot: ForwardRefComponent<ShapeProps<typeof THREE.TorusKnotGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Tetrahedron: ForwardRefComponent<ShapeProps<typeof THREE.TetrahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Ring: ForwardRefComponent<ShapeProps<typeof THREE.RingGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Polyhedron: ForwardRefComponent<ShapeProps<typeof THREE.PolyhedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Icosahedron: ForwardRefComponent<ShapeProps<typeof THREE.IcosahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Octahedron: ForwardRefComponent<ShapeProps<typeof THREE.OctahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Dodecahedron: ForwardRefComponent<ShapeProps<typeof THREE.DodecahedronGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Extrude: ForwardRefComponent<ShapeProps<typeof THREE.ExtrudeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Lathe: ForwardRefComponent<ShapeProps<typeof THREE.LatheGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Capsule: ForwardRefComponent<ShapeProps<typeof THREE.CapsuleGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+declare const Shape: ForwardRefComponent<ShapeProps<typeof THREE.ShapeGeometry>, THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+
+type Glyph = {
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
+};
+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_FontLoader_js.Font;
+declare namespace useFont {
+    var preload: (font: FontInput) => undefined;
+    var clear: (font: FontInput) => void;
+}
+
+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.PropsWithChildren<Text3DProps & {
+    letterSpacing?: number;
+    lineHeight?: number;
+}>, THREE.Mesh>;
+
+interface WireframeMaterialProps extends THREE.ShaderMaterialParameters {
+    fillOpacity?: number;
+    fillMix?: number;
+    strokeOpacity?: number;
+    thickness?: number;
+    colorBackfaces?: boolean;
+    dashInvert?: boolean;
+    dash?: boolean;
+    dashRepeats?: number;
+    dashLength?: number;
+    squeeze?: boolean;
+    squeezeMin?: number;
+    squeezeMax?: number;
+    stroke?: THREE.ColorRepresentation;
+    backfaceStroke?: THREE.ColorRepresentation;
+    fill?: THREE.ColorRepresentation;
+}
+declare const 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 const WireframeMaterial: _react_three_fiber.ConstructorRepresentation<THREE.ShaderMaterial & {
+    strokeOpacity: number;
+    fillOpacity: number;
+    fillMix: number;
+    thickness: number;
+    colorBackfaces: boolean;
+    dashInvert: boolean;
+    dash: boolean;
+    dashRepeats: number;
+    dashLength: number;
+    squeeze: boolean;
+    squeezeMin: number;
+    squeezeMax: number;
+    stroke: THREE.Color;
+    backfaceStroke: THREE.Color;
+    fill: THREE.Color;
+}> & {
+    key: string;
+};
+declare function setWireframeOverride(material: THREE.Material, uniforms: {
+    [key: string]: THREE.IUniform<any>;
+}): void;
+declare function useWireframeUniforms(uniforms: {
+    [key: string]: THREE.IUniform<any>;
+}, props: WireframeMaterialProps): void;
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        meshWireframeMaterial: ThreeElement<typeof WireframeMaterial>;
+    }
+}
+interface WireframeProps {
+    geometry?: THREE.BufferGeometry | React.RefObject<THREE.BufferGeometry>;
+    simplify?: boolean;
+}
+declare function Wireframe({ geometry: customGeometry, ...props }: WireframeProps & WireframeMaterialProps): React.JSX.Element;
+
+type GizmoHelperContext = {
+    tweenCamera: (direction: Vector3$1) => void;
+};
+declare const useGizmoContext: () => GizmoHelperContext;
+type GizmoHelperProps = ThreeElements['group'] & {
+    alignment?: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center';
+    margin?: [number, number];
+    renderPriority?: number;
+    autoClear?: boolean;
+    onUpdate?: () => void;
+    onTarget?: () => Vector3$1;
+};
+declare const GizmoHelper: ({ alignment, margin, renderPriority, onUpdate, onTarget, children, }: GizmoHelperProps) => any;
+
+type GenericProps = {
+    font?: string;
+    opacity?: number;
+    color?: string;
+    hoverColor?: string;
+    textColor?: string;
+    strokeColor?: string;
+    onClick?: (e: ThreeEvent<MouseEvent>) => null;
+    faces?: string[];
+};
+declare const GizmoViewcube: (props: GenericProps) => React.JSX.Element;
+
+type GizmoViewportProps = ThreeElements['group'] & {
+    axisColors?: [string, string, string];
+    axisScale?: [number, number, number];
+    labels?: [string, string, string];
+    axisHeadScale?: number;
+    labelColor?: string;
+    hideNegativeAxes?: boolean;
+    hideAxisHeads?: boolean;
+    disabled?: boolean;
+    font?: string;
+    onClick?: (e: ThreeEvent<MouseEvent>) => null;
+};
+declare const GizmoViewport: ({ hideNegativeAxes, hideAxisHeads, disabled, font, axisColors, axisHeadScale, axisScale, labels, labelColor, onClick, ...props }: GizmoViewportProps) => React.JSX.Element;
+
+type OnDragStartProps = {
+    component: 'Arrow' | 'Slider' | 'Rotator' | 'Sphere';
+    axis: 0 | 1 | 2;
+    origin: THREE.Vector3;
+    directions: THREE.Vector3[];
+};
+
+type PivotControlsProps = {
+    enabled?: boolean;
+    scale?: number;
+    lineWidth?: number;
+    fixed?: boolean;
+    offset?: [number, number, number];
+    rotation?: [number, number, number];
+    matrix?: THREE.Matrix4;
+    anchor?: [number, number, number];
+    autoTransform?: boolean;
+    activeAxes?: [boolean, boolean, boolean];
+    disableAxes?: boolean;
+    disableSliders?: boolean;
+    disableRotations?: boolean;
+    disableScaling?: boolean;
+    translationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    rotationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    scaleLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    axisColors?: [string | number, string | number, string | number];
+    hoveredColor?: string | number;
+    annotations?: boolean;
+    annotationsClass?: string;
+    onDragStart?: (props: OnDragStartProps) => void;
+    onDrag?: (l: THREE.Matrix4, deltaL: THREE.Matrix4, w: THREE.Matrix4, deltaW: THREE.Matrix4) => void;
+    onDragEnd?: () => void;
+    depthTest?: boolean;
+    renderOrder?: number;
+    opacity?: number;
+    visible?: boolean;
+    userData?: {
+        [key: string]: any;
+    };
+    children?: React.ReactNode;
+    LineComponent?: React.ComponentType<LineProps>;
+};
+declare const PivotControls: ForwardRefComponent<PivotControlsProps, THREE.Group>;
+
+type TransformControlsProps = Omit<ThreeElement<typeof TransformControls$1>, 'ref' | 'args'> & Omit<ThreeElements['group'], 'ref'> & {
+    object?: THREE.Object3D | React.RefObject<THREE.Object3D>;
+    enabled?: boolean;
+    axis?: string | null;
+    domElement?: HTMLElement;
+    mode?: 'translate' | 'rotate' | 'scale';
+    translationSnap?: number | null;
+    rotationSnap?: number | null;
+    scaleSnap?: number | null;
+    space?: 'world' | 'local';
+    size?: number;
+    showX?: boolean;
+    showY?: boolean;
+    showZ?: boolean;
+    children?: React.ReactElement<THREE.Object3D>;
+    camera?: THREE.Camera;
+    onChange?: (e?: THREE.Event) => void;
+    onMouseDown?: (e?: THREE.Event) => void;
+    onMouseUp?: (e?: THREE.Event) => void;
+    onObjectChange?: (e?: THREE.Event) => void;
+    makeDefault?: boolean;
+};
+declare const TransformControls: ForwardRefComponent<TransformControlsProps, TransformControls$1>;
+
+type HelperType = Object3D & {
+    update: () => void;
+    dispose: () => void;
+};
+type HelperConstructor = new (...args: any[]) => any;
+type HelperArgs<T> = T extends [infer _, ...infer R] ? R : never;
+declare function useHelper<T extends HelperConstructor>(object3D: React.RefObject<Object3D> | Falsey, helperConstructor: T, ...args: HelperArgs<ConstructorParameters<T>>): React.RefObject<HelperType | null>;
+type HelperProps<T extends HelperConstructor> = {
+    type: T;
+    args?: HelperArgs<ConstructorParameters<T>>;
+};
+declare const Helper: <T extends HelperConstructor>({ type: helperConstructor, args, }: HelperProps<T>) => React.JSX.Element;
+
+declare class PointMaterialImpl extends THREE.PointsMaterial {
+    constructor(props?: THREE.PointsMaterialParameters | null);
+}
+type PointMaterialProps = Omit<ThreeElements['pointsMaterial'], 'ref'>;
+declare const PointMaterial: ForwardRefComponent<PointMaterialProps, PointMaterialImpl>;
+
+type PositionalAudioProps = Omit<ThreeElements['positionalAudio'], 'ref' | 'args'> & {
+    url: string;
+    distance?: number;
+    loop?: boolean;
+};
+declare const PositionalAudio: ForwardRefComponent<PositionalAudioProps, PositionalAudio$1>;
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        positionMesh: ThreeElement<typeof PositionMesh>;
+    }
+}
+type Api$1 = {
+    getParent: () => React.RefObject<InstancedMesh>;
+    subscribe: <T>(ref: React.RefObject<T>) => void;
+};
+type InstancesProps = Omit<ThreeElements['instancedMesh'], 'ref' | 'args'> & {
+    context?: React.Context<Api$1>;
+    range?: number;
+    limit?: number;
+    frames?: number;
+};
+type InstanceProps = Omit<ThreeElements['positionMesh'], 'ref'> & {
+    context?: React.Context<Api$1>;
+};
+type InstancedAttributeProps = Omit<ThreeElements['instancedBufferAttribute'], 'ref' | 'args'> & {
+    name: string;
+    defaultValue: any;
+    normalized?: boolean;
+    usage?: number;
+};
+type InstancedMesh = Omit<THREE.InstancedMesh, 'instanceMatrix' | 'instanceColor'> & {
+    instanceMatrix: THREE.InstancedBufferAttribute;
+    instanceColor: THREE.InstancedBufferAttribute;
+};
+declare class PositionMesh extends THREE.Group {
+    color: THREE.Color;
+    instance: React.RefObject<THREE.InstancedMesh | undefined>;
+    instanceKey: React.RefObject<PositionMesh | undefined>;
+    constructor();
+    get geometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}
+declare const Instance: React.ForwardRefExoticComponent<Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
+    context?: React.Context<Api$1>;
+} & React.RefAttributes<unknown>>;
+declare const Instances: ForwardRefComponent<InstancesProps, THREE.InstancedMesh>;
+interface MergedProps extends Omit<InstancesProps, 'children'> {
+    meshes: THREE.Mesh[] | Record<string, THREE.Object3D>;
+    children: (...instances: [React.FC<InstanceProps> & Record<string, React.FC<InstanceProps>>, ...React.FC<InstanceProps>[]]) => React.ReactNode;
+}
+declare const Merged: ForwardRefComponent<MergedProps, THREE.Group>;
+declare function createInstances<T = InstanceProps>(): readonly [React.ForwardRefExoticComponent<Omit<InstancesProps, "ref"> & React.RefAttributes<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap>>>, React.ForwardRefExoticComponent<React.PropsWithoutRef<T & Omit<_react_three_fiber.Mutable<_react_three_fiber.Overwrite<Partial<_react_three_fiber.Overwrite<PositionMesh, _react_three_fiber.MathProps<PositionMesh> & _react_three_fiber.ReactProps<PositionMesh> & Partial<_react_three_fiber.EventHandlers>>>, Omit<_react_three_fiber.InstanceProps<PositionMesh, typeof PositionMesh>, "object">>>, "ref"> & {
+    context?: React.Context<Api$1>;
+}> & React.RefAttributes<PositionMesh & T>>];
+declare const InstancedAttribute: React.ForwardRefExoticComponent<Omit<InstancedAttributeProps, "ref"> & React.RefAttributes<THREE.InstancedBufferAttribute>>;
+
+type Size = {
+    w: number;
+    h: number;
+};
+type FrameData = {
+    frame: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    scaleRatio?: number;
+    rotated: boolean;
+    trimmed: boolean;
+    spriteSourceSize: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    sourceSize: Size;
+};
+type 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$1, textureData?: SpriteData | null) => void, canvasRenderingContext2DSettings?: CanvasRenderingContext2DSettings): {
+    spriteObj: {
+        spriteTexture: THREE.Texture;
+        spriteData: SpriteData | null;
+        aspect: Vector3;
+    } | null;
+    loadJsonAndTexture: (textureUrl: string, jsonUrl?: string) => void;
+};
+declare namespace useSpriteLoader {
+    var preload: (url: string) => void;
+    var clear: (input: string) => void;
+}
+
+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.ComponentProps<'mesh'>, React.ComponentProps<typeof Instance>, React.ComponentProps<typeof Instances>>;
+type SpriteAnimatorProps = {
+    startFrame?: number;
+    endFrame?: number;
+    fps?: number;
+    frameName?: string;
+    textureDataURL?: string;
+    textureImageURL?: string;
+    loop?: boolean;
+    numberOfFrames?: number;
+    autoPlay?: boolean;
+    animationNames?: Array<string>;
+    onStart?: (data: AnimationEventData) => void;
+    onEnd?: (data: AnimationEventData) => void;
+    onLoopEnd?: (data: AnimationEventData) => void;
+    onFrame?: (data: AnimationEventData) => void;
+    play?: boolean;
+    pause?: boolean;
+    flipX?: boolean;
+    alphaTest?: number;
+    asSprite?: boolean;
+    offset?: number;
+    playBackwards?: boolean;
+    resetOnEnd?: boolean;
+    instanceItems?: Vector3[];
+    maxItems?: number;
+    spriteDataset?: {
+        spriteTexture: THREE.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.Ref<THREE.Group>;
+};
+declare function useSpriteAnimator(): SpriteAnimatorState | null;
+declare const SpriteAnimator: React.ForwardRefExoticComponent<Omit<SpriteAnimatorProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+
+type Api<T extends AnimationClip> = {
+    ref: React.RefObject<Object3D | undefined | null>;
+    clips: AnimationClip[];
+    mixer: AnimationMixer;
+    names: T['name'][];
+    actions: {
+        [key in T['name']]: AnimationAction | null;
+    };
+};
+declare function useAnimations<T extends AnimationClip>(clips: T[], root?: React.RefObject<Object3D | undefined | null> | Object3D): Api<T>;
+
+declare function useContextBridge(...contexts: Array<React.Context<any>>): ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+
+type CloneProps = Omit<ThreeElements['group'], 'ref' | 'children'> & {
+    object: THREE.Object3D | THREE.Object3D[];
+    children?: React.ReactNode;
+    deep?: boolean | 'materialsOnly' | 'geometriesOnly';
+    keys?: string[];
+    inject?: ThreeElements['mesh'] | React.ReactNode | ((object: THREE.Object3D) => React.ReactNode);
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    isChild?: boolean;
+};
+declare const Clone: ForwardRefComponent<CloneProps, THREE.Group>;
+
+type ComputedAttributeProps = Omit<ThreeElements['bufferAttribute'], 'args'> & {
+    compute: (geometry: BufferGeometry) => BufferAttribute;
+    name: string;
+};
+declare const ComputedAttribute: ({ compute, name, ...props }: ComputedAttributeProps) => React.JSX.Element;
+
+type ExampleProps = {
+    font: string;
+    color?: Color$1;
+    debug?: boolean;
+    bevelSize?: number;
+} & React.ComponentProps<'group'>;
+type ExampleApi = {
+    incr: (x?: number) => void;
+    decr: (x?: number) => void;
+};
+declare const Example: React.ForwardRefExoticComponent<Omit<ExampleProps, "ref"> & React.RefAttributes<ExampleApi>>;
+
+type SamplePayload = {
+    position: Vector3$1;
+    normal: Vector3$1;
+    color: Color;
+};
+type TransformFn = (payload: TransformPayload, i: number) => void;
+type TransformPayload = SamplePayload & {
+    dummy: Object3D;
+    sampledMesh: Mesh;
+};
+type SamplerProps = Omit<ThreeElements['group'], 'ref'> & {
+    mesh?: React.RefObject<Mesh>;
+    instances?: React.RefObject<InstancedMesh$1>;
+    weight?: string;
+    transform?: TransformFn;
+    count?: number;
+};
+interface useSurfaceSamplerProps {
+    transform?: TransformFn;
+    weight?: string;
+    count?: number;
+}
+declare function useSurfaceSampler(mesh: React.RefObject<Mesh>, count?: number, transform?: TransformFn, weight?: string, instanceMesh?: React.RefObject<InstancedMesh$1> | null): InstancedBufferAttribute;
+declare function Sampler({ children, weight, transform, instances, mesh, count, ...props }: SamplerProps): React.JSX.Element;
+
+interface SvgProps extends Omit<ThreeElements['object3D'], 'ref'> {
+    src: string;
+    skipFill?: boolean;
+    skipStrokes?: boolean;
+    fillMaterial?: ThreeElements['meshBasicMaterial'];
+    strokeMaterial?: ThreeElements['meshBasicMaterial'];
+    fillMeshProps?: ThreeElements['mesh'];
+    strokeMeshProps?: ThreeElements['mesh'];
+}
+declare const Svg: ForwardRefComponent<SvgProps, Object3D>;
+
+declare function useDepthBuffer({ size, frames }?: {
+    size?: number;
+    frames?: number;
+}): DepthTexture | null;
+
+interface CubeTextureOptions {
+    path: string;
+}
+interface CubeTextureProps extends CubeTextureOptions {
+    children?: (texture: CubeTexture$1) => React.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.JSX.Element;
+
+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.JSX.Element | null;
+
+type PreloadProps = {
+    all?: boolean;
+    scene?: Object3D;
+    camera?: Camera;
+};
+declare function Preload({ all, scene, camera }: PreloadProps): null;
+
+declare function getHls(...args: ConstructorParameters<typeof hls_js__default>): Promise<hls_js__default | null>;
+declare function useVideoTexture(srcOrSrcObject: HTMLVideoElement['src' | 'srcObject'], { unsuspend, start, hls: hlsConfig, crossOrigin, muted, loop, playsInline, onVideoFrame, ...videoProps }?: {
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<typeof getHls>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, 'children' | 'src' | 'srcObject'>>): THREE.VideoTexture<HTMLVideoElement>;
+type UseVideoTextureParams = Parameters<typeof useVideoTexture>;
+type VideoTextureProps = {
+    children?: (texture: VideoTexture) => React.ReactNode;
+    src: UseVideoTextureParams[0];
+} & UseVideoTextureParams[1];
+type VideoTexture = ReturnType<typeof useVideoTexture>;
+declare const VideoTexture: React.ForwardRefExoticComponent<{
+    children?: (texture: VideoTexture) => React.ReactNode;
+    src: UseVideoTextureParams[0];
+} & {
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<typeof getHls>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">> & React.RefAttributes<THREE.VideoTexture<HTMLVideoElement>>>;
+
+type ScreenVideoTextureProps = Omit<VideoTextureProps, 'src'> & {
+    options?: DisplayMediaStreamOptions;
+};
+declare const ScreenVideoTexture: React.ForwardRefExoticComponent<Omit<{
+    children?: (texture: THREE.VideoTexture<HTMLVideoElement>) => React.ReactNode;
+    src: string | MediaProvider | null;
+} & {
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<(userConfig?: Partial<hls_js.HlsConfig> | undefined) => Promise<hls_js.default | null>>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">>, "src"> & {
+    options?: DisplayMediaStreamOptions;
+} & React.RefAttributes<THREE.VideoTexture<HTMLVideoElement>>>;
+
+type TrailConfig = {
+    size?: number;
+    maxAge?: number;
+    radius?: number;
+    intensity?: number;
+    interpolate?: number;
+    smoothing?: number;
+    minForce?: number;
+    blend?: CanvasRenderingContext2D['globalCompositeOperation'];
+    ease?: (t: number) => number;
+};
+declare function useTrailTexture(config?: Partial<TrailConfig>): [Texture$1, (ThreeEvent: any) => void];
+type TrailTextureProps = {
+    children?: (texture: ReturnType<typeof useTrailTexture>) => React.ReactNode;
+} & TrailConfig;
+declare const TrailTexture: ({ children, ...config }: TrailTextureProps) => React.JSX.Element;
+
+declare function useFBX(path: string): Group;
+declare namespace useFBX {
+    var preload: (path: string) => void;
+    var clear: (input: string | string[]) => void;
+}
+declare function Fbx({ path, ...props }: {
+    path: Parameters<typeof useFBX>[0];
+} & Omit<React.ComponentProps<typeof Clone>, 'object'>): React.JSX.Element;
+
+type Path = string | string[];
+type UseDraco = boolean | string;
+type UseMeshopt = boolean;
+type ExtendLoader = (loader: GLTFLoader) => void;
+declare const useGLTF: {
+    <T extends Path>(path: T, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader): T extends any[] ? (GLTF & ObjectMap)[] : GLTF & ObjectMap;
+    preload(path: Path, useDraco?: UseDraco, useMeshopt?: UseMeshopt, extendLoader?: ExtendLoader): void;
+    clear(path: Path): void;
+    setDecoderPath(path: string): void;
+};
+type GltfProps = Omit<CloneProps, 'object'> & {
+    src: string;
+    useDraco?: UseDraco;
+    useMeshOpt?: UseMeshopt;
+    extendLoader?: ExtendLoader;
+};
+declare const Gltf: React.ForwardRefExoticComponent<Omit<GltfProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+
+declare function useKTX2<Url extends string[] | string | Record<string, string>>(input: Url, basisPath?: string): Url extends any[] ? Texture$1[] : Url extends object ? {
+    [key in keyof Url]: Texture$1;
+} : Texture$1;
+declare namespace useKTX2 {
+    var preload: (url: string extends any[] ? string[] : string, basisPath?: string) => void;
+    var clear: (input: string | string[]) => void;
+}
+declare const Ktx2: ({ children, input, basisPath, }: {
+    children?: (texture: ReturnType<typeof useKTX2>) => React.ReactNode;
+    input: Parameters<typeof useKTX2>[0];
+    basisPath?: Parameters<typeof useKTX2>[1];
+}) => React.JSX.Element;
+
+type Data = {
+    errors: string[];
+    active: boolean;
+    progress: number;
+    item: string;
+    loaded: number;
+    total: number;
+};
+declare const useProgress: zustand.UseBoundStore<zustand.StoreApi<Data>>;
+
+declare function Progress({ children }: {
+    children?: (result: Data) => React.ReactNode;
+}): React.JSX.Element;
+
+type MappedTextureType<T extends string | string[] | Record<string, string>> = T extends string[] ? Texture$1[] : T extends Record<string, string> ? {
+    [K in keyof T]: Texture$1;
+} : Texture$1;
+declare const IsObject: (url: unknown) => url is Record<string, string>;
+declare function useTexture<Url extends string[] | string | Record<string, string>>(input: Url, onLoad?: (texture: MappedTextureType<Url>) => void): MappedTextureType<Url>;
+declare namespace useTexture {
+    var preload: (url: string | string[]) => void;
+    var clear: (input: string | string[]) => void;
+}
+declare const Texture: ({ children, input, onLoad, }: {
+    children?: (texture: ReturnType<typeof useTexture>) => React.ReactNode;
+    input: Parameters<typeof useTexture>[0];
+    onLoad?: Parameters<typeof useTexture>[1];
+}) => React.JSX.Element;
+
+type WebcamVideoTextureProps = Omit<VideoTextureProps, 'src'> & {
+    constraints?: MediaStreamConstraints;
+};
+declare const WebcamVideoTexture: React.ForwardRefExoticComponent<Omit<{
+    children?: (texture: THREE.VideoTexture<HTMLVideoElement>) => React.ReactNode;
+    src: string | MediaProvider | null;
+} & {
+    unsuspend?: keyof HTMLVideoElementEventMap;
+    start?: boolean;
+    hls?: Parameters<(userConfig?: Partial<hls_js.HlsConfig> | undefined) => Promise<hls_js.default | null>>[0];
+    onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">>, "src"> & {
+    constraints?: MediaStreamConstraints;
+} & React.RefAttributes<THREE.VideoTexture<HTMLVideoElement>>>;
+
+declare function AdaptiveDpr({ pixelated }: {
+    pixelated?: boolean;
+}): null;
+
+declare function AdaptiveEvents(): null;
+
+declare const useDetectGPU: (props?: GetGPUTier) => detect_gpu.TierResult;
+type DetectGPUProps = {
+    children?: (result: ReturnType<typeof useDetectGPU>) => React.ReactNode;
+} & Parameters<typeof useDetectGPU>[0];
+declare function DetectGPU({ children, ...options }: DetectGPUProps): React.JSX.Element;
+
+declare function meshBounds(raycaster: Raycaster, intersects: Intersection[]): void;
+
+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.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.ReactNode;
+};
+declare function PerformanceMonitor({ iterations, ms, threshold, step, factor: _factor, flipflops, bounds, onIncline, onDecline, onChange, onFallback, children, }: PerformanceMonitorProps): React.JSX.Element;
+declare function usePerformanceMonitor({ onIncline, onDecline, onChange, onFallback, }: Partial<PerformanceMonitorHookApi>): void;
+
+type StatsProps = {
+    showPanel?: number;
+    className?: string;
+    parent?: React.RefObject<HTMLElement>;
+};
+declare function Stats({ showPanel, className, parent }: StatsProps): null;
+
+type StatsOptions = ConstructorParameters<typeof Stats$1>[0];
+type StatsGlProps = Partial<StatsOptions> & {
+    id?: string;
+    clearStatsGlStyle?: boolean;
+    showPanel?: number;
+    className?: string;
+    parent?: React.RefObject<HTMLElement>;
+    ref?: React.RefObject<HTMLElement>;
+};
+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>>;
+type UseFBOParams = Parameters<typeof useFBO>;
+type FboProps = {
+    children?: (target: Fbo) => React.ReactNode;
+    width?: UseFBOParams[0];
+    height?: UseFBOParams[1];
+} & FBOSettings;
+type Fbo = ReturnType<typeof useFBO>;
+declare const Fbo: React.ForwardRefExoticComponent<{
+    children?: (target: Fbo) => React.ReactNode;
+    width?: UseFBOParams[0];
+    height?: UseFBOParams[1];
+} & {
+    depth?: boolean;
+} & THREE.RenderTargetOptions & React.RefAttributes<THREE.WebGLRenderTarget<THREE.Texture<unknown>>>>;
+
+type FisheyeProps = ThreeElements['mesh'] & {
+    zoom?: number;
+    segments?: number;
+    resolution?: number;
+    children: React.ReactNode;
+    renderPriority?: number;
+};
+declare function Fisheye({ renderPriority, zoom, segments, children, resolution, ...props }: FisheyeProps): React.JSX.Element;
+
+type HudProps = {
+    children: React.ReactNode;
+    renderPriority?: number;
+};
+declare function Hud({ children, renderPriority }: HudProps): React.JSX.Element;
+
+type MaskProps = Omit<ThreeElements['mesh'], 'ref' | 'id'> & {
+    id: number;
+    colorWrite?: boolean;
+    depthWrite?: boolean;
+};
+declare const Mask: ForwardRefComponent<MaskProps, THREE.Mesh>;
+declare function useMask(id: number, inverse?: boolean): {
+    stencilWrite: boolean;
+    stencilRef: number;
+    stencilFunc: 514 | 517;
+    stencilFail: 7680;
+    stencilZFail: 7680;
+    stencilZPass: 7680;
+};
+
+type RenderCubeTextureProps = Omit<ThreeElements['texture'], 'ref' | 'args' | 'rotation'> & {
+    stencilBuffer?: boolean;
+    depthBuffer?: boolean;
+    generateMipmaps?: boolean;
+    renderPriority?: number;
+    eventPriority?: number;
+    frames?: number;
+    compute?: ComputeFunction;
+    flip?: boolean;
+    resolution?: number;
+    children: React.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.Scene;
+    fbo: THREE.WebGLCubeRenderTarget;
+    camera: THREE.CubeCamera;
+};
+declare const RenderCubeTexture: ForwardRefComponent<RenderCubeTextureProps, RenderCubeTextureApi>;
+
+declare function useCustomRaycast(camera: Camera | React.RefObject<Camera>, props?: Partial<Raycaster>): (_: Raycaster, intersects: Intersection[]) => void;
+
+type CanvasSize = {
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+};
+type ContainerProps = {
+    visible: boolean;
+    scene: THREE.Scene;
+    index: number;
+    children?: React.ReactNode;
+    frames: number;
+    rect: React.RefObject<DOMRect>;
+    track?: React.RefObject<HTMLElement>;
+    canvasSize: CanvasSize;
+};
+type ViewProps = {
+    as?: string;
+    id?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    visible?: boolean;
+    index?: number;
+    frames?: number;
+    children?: React.ReactNode;
+    track?: React.RefObject<HTMLElement>;
+};
+type ViewportProps = {
+    Port: () => React.JSX.Element;
+} & React.ForwardRefExoticComponent<ViewProps & React.RefAttributes<HTMLElement | THREE.Group>>;
+declare const View: ViewportProps;
+
+type BackdropProps = ThreeElements['group'] & {
+    floor?: number;
+    segments?: number;
+    receiveShadow?: boolean;
+    children?: React.ReactNode;
+};
+declare function Backdrop({ children, floor, segments, receiveShadow, ...props }: {
+    [x: string]: any;
+    children: any;
+    floor?: number | undefined;
+    segments?: number | undefined;
+    receiveShadow: any;
+}): React.JSX.Element;
+
+type BBAnchorProps = ThreeElements['group'] & {
+    anchor: THREE.Vector3 | [number, number, number];
+};
+declare const BBAnchor: ({ anchor, ...props }: BBAnchorProps) => React.JSX.Element;
+
+type BillboardProps = Omit<ThreeElements['group'], 'ref'> & {
+    follow?: boolean;
+    lockX?: boolean;
+    lockY?: boolean;
+    lockZ?: boolean;
+};
+declare const Billboard: ForwardRefComponent<BillboardProps, Group>;
+
+type SizeProps = {
+    box: THREE.Box3;
+    size: THREE.Vector3;
+    center: THREE.Vector3;
+    distance: number;
+};
+type BoundsApi = {
+    getSize: () => SizeProps;
+    refresh(object?: THREE.Object3D | THREE.Box3): BoundsApi;
+    reset(): BoundsApi;
+    moveTo(position: THREE.Vector3 | [number, number, number]): BoundsApi;
+    lookAt({ target, up, }: {
+        target?: THREE.Vector3 | [number, number, number];
+        up?: THREE.Vector3 | [number, number, number];
+    }): BoundsApi;
+    to({ position, target }: {
+        position: [number, number, number];
+        target: [number, number, number];
+    }): BoundsApi;
+    fit(): BoundsApi;
+    clip(): BoundsApi;
+};
+type BoundsProps = Omit<ThreeElements['group'], 'ref'> & {
+    maxDuration?: number;
+    margin?: number;
+    observe?: boolean;
+    fit?: boolean;
+    clip?: boolean;
+    interpolateFunc?: (t: number) => number;
+    onFit?: (data: SizeProps) => void;
+};
+declare function Bounds({ children, maxDuration, margin, observe, fit, clip, interpolateFunc, onFit, }: BoundsProps): React.JSX.Element;
+declare function useBounds(): BoundsApi;
+
+type OnCenterCallbackProps = {
+    parent: Object3D;
+    container: Object3D;
+    width: number;
+    height: number;
+    depth: number;
+    boundingBox: Box3;
+    boundingSphere: Sphere$1;
+    center: Vector3$1;
+    verticalAlignment: number;
+    horizontalAlignment: number;
+    depthAlignment: number;
+};
+type CenterProps = Omit<ThreeElements['group'], 'ref'> & {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+    front?: boolean;
+    back?: boolean;
+    disable?: boolean;
+    disableX?: boolean;
+    disableY?: boolean;
+    disableZ?: boolean;
+    object?: Object3D | null;
+    precise?: boolean;
+    onCentered?: (props: OnCenterCallbackProps) => void;
+    cacheKey?: any;
+};
+declare const Center: ForwardRefComponent<CenterProps, Group>;
+
+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;
+
+type EnvironmentLoaderProps = {
+    files?: string | string[];
+    path?: string;
+    preset?: PresetsType;
+    extensions?: (loader: Loader$1) => void;
+    colorSpace?: ColorSpace;
+};
+declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<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'>;
+
+type EnvironmentProps = {
+    children?: React.ReactNode;
+    frames?: number;
+    near?: number;
+    far?: number;
+    resolution?: number;
+    background?: boolean | 'only';
+    blur?: number;
+    backgroundBlurriness?: number;
+    backgroundIntensity?: number;
+    backgroundRotation?: Euler;
+    environmentIntensity?: number;
+    environmentRotation?: Euler;
+    map?: Texture$1;
+    preset?: PresetsType;
+    scene?: Scene | React.RefObject<Scene>;
+    ground?: boolean | {
+        radius?: number;
+        height?: number;
+        scale?: number;
+    };
+} & EnvironmentLoaderProps;
+declare function EnvironmentMap({ scene, background, map, ...config }: EnvironmentProps): null;
+declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, ...rest }: EnvironmentProps): null;
+declare function EnvironmentPortal({ children, near, far, resolution, frames, map, background, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, scene, files, path, preset, extensions, }: EnvironmentProps): React.JSX.Element;
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        groundProjectedEnvImpl: ThreeElement<typeof GroundedSkybox>;
+    }
+}
+declare function Environment(props: EnvironmentProps): React.JSX.Element;
+
+type FloatProps = Omit<ThreeElements['group'], 'ref'> & {
+    enabled?: boolean;
+    speed?: number;
+    rotationIntensity?: number;
+    floatIntensity?: number;
+    children?: React.ReactNode;
+    floatingRange?: [number?, number?];
+    autoInvalidate?: boolean;
+};
+declare const Float: ForwardRefComponent<FloatProps, THREE.Group>;
+
+type LightProps = Omit<ThreeElements['mesh'], 'ref'> & {
+    args?: any[];
+    map?: THREE.Texture;
+    toneMapped?: boolean;
+    color?: ReactThreeFiber.Color;
+    form?: 'circle' | 'ring' | 'rect' | 'plane' | 'box' | any;
+    scale?: number | [number, number, number] | [number, number];
+    intensity?: number;
+    target?: boolean | [number, number, number] | THREE.Vector3;
+    light?: Partial<ThreeElements['pointLight']>;
+};
+declare const Lightformer: ForwardRefComponent<LightProps, THREE.Mesh>;
+
+type ResizeProps = Omit<ThreeElements['group'], 'ref'> & {
+    width?: boolean;
+    height?: boolean;
+    depth?: boolean;
+    box3?: THREE.Box3;
+    precise?: boolean;
+};
+declare const Resize: React.ForwardRefExoticComponent<Omit<ResizeProps, "ref"> & React.RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;
+
+type ScreenSizerProps = Omit<ThreeElements['object3D'], 'ref'> & {
+    scale?: number;
+};
+declare const ScreenSizer: ForwardRefComponent<ScreenSizerProps, Object3D>;
+
+type ShadowProps = Omit<ThreeElements['mesh'], 'ref'> & {
+    colorStop?: number;
+    fog?: boolean;
+    color?: Color | number | string;
+    opacity?: number;
+    depthWrite?: boolean;
+};
+type ShadowType = Mesh<PlaneGeometry, MeshBasicMaterial>;
+declare const Shadow: ForwardRefComponent<ShadowProps, ShadowType>;
+
+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$1): Vector3$1;
+declare const Sky: ForwardRefComponent<SkyProps, Sky$1>;
+
+type StageShadows = Partial<AccumulativeShadowsProps> & Partial<RandomizedLightProps> & Partial<ContactShadowsProps> & {
+    type: 'contact' | 'accumulative';
+    offset?: number;
+    bias?: number;
+    normalBias?: number;
+    size?: number;
+};
+type StageProps = Omit<ThreeElements['group'], 'ref'> & {
+    preset?: 'rembrandt' | 'portrait' | 'upfront' | 'soft' | {
+        main: [x: number, y: number, z: number];
+        fill: [x: number, y: number, z: number];
+    };
+    shadows?: boolean | 'contact' | 'accumulative' | StageShadows;
+    adjustCamera?: boolean | number;
+    environment?: PresetsType | Partial<EnvironmentProps> | null;
+    intensity?: number;
+    center?: Partial<CenterProps>;
+};
+declare function Stage({ children, center, adjustCamera, intensity, shadows, environment, preset, ...props }: StageProps): React.JSX.Element;
+
+declare function useMatcapTexture(id?: number | string, format?: number, onLoad?: (texture: Texture$1 | Texture$1[]) => void): [Texture$1, string, number];
+declare const MatcapTexture: ({ children, id, format, onLoad, }: {
+    children?: (texture: ReturnType<typeof useMatcapTexture>) => React.ReactNode;
+    id?: Parameters<typeof useMatcapTexture>[0];
+    format?: Parameters<typeof useMatcapTexture>[1];
+    onLoad?: Parameters<typeof useMatcapTexture>[2];
+}) => React.JSX.Element;
+
+type Settings = {
+    repeat?: number[];
+    anisotropy?: number;
+    offset?: number[];
+};
+declare function useNormalTexture(id?: number, settings?: Settings, onLoad?: (texture: Texture$1 | Texture$1[]) => void): [Texture$1, string, number];
+declare const NormalTexture: ({ children, id, onLoad, ...settings }: {
+    children?: (texture: ReturnType<typeof useNormalTexture>) => React.ReactNode;
+    id?: Parameters<typeof useNormalTexture>[0];
+    onLoad?: Parameters<typeof useNormalTexture>[2];
+} & Settings) => React.JSX.Element;
+
+type CycleRaycastProps = {
+    onChanged?: (hits: THREE.Intersection[], cycle: number) => null;
+    preventDefault?: boolean;
+    scroll?: boolean;
+    keyCode?: number;
+    portal?: React.RefObject<HTMLElement>;
+};
+declare function CycleRaycast({ onChanged, portal, preventDefault, scroll, keyCode, }: CycleRaycastProps): null;
+
+declare function defaultCalculatePosition(el: Object3D, camera: Camera, size: {
+    width: number;
+    height: number;
+}): number[];
+type CalculatePosition = typeof defaultCalculatePosition;
+type PointerEventsProperties = 'auto' | 'none' | 'visiblePainted' | 'visibleFill' | 'visibleStroke' | 'visible' | 'painted' | 'fill' | 'stroke' | 'all' | 'inherit';
+interface HtmlProps extends Omit<Assign<React.HTMLAttributes<HTMLDivElement>, ThreeElements['group']>, 'ref'> {
+    prepend?: boolean;
+    center?: boolean;
+    fullscreen?: boolean;
+    eps?: number;
+    portal?: React.RefObject<HTMLElement>;
+    distanceFactor?: number;
+    sprite?: boolean;
+    transform?: boolean;
+    zIndexRange?: Array<number>;
+    calculatePosition?: CalculatePosition;
+    as?: string;
+    wrapperClass?: string;
+    pointerEvents?: PointerEventsProperties;
+    occlude?: React.RefObject<Object3D>[] | boolean | 'raycast' | 'blending';
+    onOcclude?: (hidden: boolean) => void;
+    material?: React.ReactNode;
+    geometry?: React.ReactNode;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+}
+declare const Html: ForwardRefComponent<HtmlProps, HTMLDivElement>;
+
+declare function useAspect(width: number, height: number, factor?: number): [number, number, number];
+
+declare function useCursor(hovered: boolean, onPointerOver?: string, onPointerOut?: string, container?: HTMLElement): void;
+
+declare function useIntersect<T extends Object3D>(onChange: (visible: boolean) => void): React.RefObject<T>;
+
+type ScreenSpaceProps = Omit<ThreeElements['group'], 'ref'> & {
+    depth?: number;
+};
+declare const ScreenSpace: ForwardRefComponent<ScreenSpaceProps, Group>;
+
+type SelectProps = Omit<ThreeElements['group'], 'ref'> & {
+    multiple?: boolean;
+    box?: boolean;
+    border?: string;
+    backgroundColor?: string;
+    onChange?: (selected: THREE.Object3D[]) => void;
+    onChangePointerUp?: (selected: THREE.Object3D[]) => void;
+    filter?: (selected: THREE.Object3D[]) => THREE.Object3D[];
+};
+declare function Select({ box, multiple, children, onChange, onChangePointerUp, border, backgroundColor, filter: customFilter, ...props }: SelectProps): React.JSX.Element;
+declare function useSelect(): THREE.Object3D[];
+
+type AsciiRendererProps = {
+    renderIndex?: number;
+    bgColor?: string;
+    fgColor?: string;
+    characters?: string;
+    invert?: boolean;
+    color?: boolean;
+    resolution?: number;
+};
+declare function AsciiRenderer({ renderIndex, bgColor, fgColor, characters, invert, color, resolution, }: AsciiRendererProps): React.JSX.Element;
+
+declare function BakeShadows(): null;
+
+declare class ConvolutionMaterial extends THREE.ShaderMaterial {
+    readonly kernel: Float32Array;
+    constructor(texelSize?: THREE.Vector2);
+    setTexelSize(x: number, y: number): void;
+    setResolution(resolution: THREE.Vector2): void;
+}
+
+interface BlurPassProps {
+    gl: WebGLRenderer;
+    resolution: number;
+    width?: number;
+    height?: number;
+    minDepthThreshold?: number;
+    maxDepthThreshold?: number;
+    depthScale?: number;
+    depthToBlurRatioBias?: number;
+}
+declare class BlurPass {
+    readonly renderTargetA: WebGLRenderTarget;
+    readonly renderTargetB: WebGLRenderTarget;
+    readonly convolutionMaterial: ConvolutionMaterial;
+    readonly scene: Scene;
+    readonly camera: Camera;
+    readonly screen: Mesh;
+    renderToScreen: boolean;
+    constructor({ gl, resolution, width, height, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, }: BlurPassProps);
+    render(renderer: any, inputBuffer: any, outputBuffer: any): void;
+}
+
+declare const DiscardMaterial: _react_three_fiber.ConstructorRepresentation<THREE.ShaderMaterial> & {
+    key: string;
+};
+
+declare enum GradientType {
+    Linear = "linear",
+    Radial = "radial"
+}
+type GradientTextureProps = {
+    stops: number[];
+    colors: string[];
+    size?: number;
+    width?: number;
+    type?: GradientType;
+    innerCircleRadius?: number;
+    outerCircleRadius?: number | 'auto';
+};
+declare function GradientTexture({ stops, colors, size, width, type, innerCircleRadius, outerCircleRadius, ...props }: GradientTextureProps): React.JSX.Element;
+
+type ImageProps = Omit<ThreeElements['mesh'], 'scale'> & {
+    segments?: number;
+    scale?: number | [number, number];
+    color?: Color$1;
+    zoom?: number;
+    radius?: number;
+    grayscale?: number;
+    toneMapped?: boolean;
+    transparent?: boolean;
+    opacity?: number;
+    side?: THREE.Side;
+} & ({
+    texture: THREE.Texture;
+    url?: never;
+} | {
+    texture?: never;
+    url: string;
+});
+type ImageMaterialType = ThreeElements['shaderMaterial'] & {
+    scale?: number[];
+    imageBounds?: number[];
+    radius?: number;
+    resolution?: number;
+    color?: Color$1;
+    map: THREE.Texture;
+    zoom?: number;
+    grayscale?: number;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        imageMaterial: ImageMaterialType;
+    }
+}
+declare const Image: ForwardRefComponent<ImageProps, THREE.Mesh>;
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        discardMaterialImpl: ThreeElements['shaderMaterial'];
+    }
+}
+type MeshDiscardMaterialProps = Omit<ThreeElements['shaderMaterial'], 'ref'>;
+declare const MeshDiscardMaterial: ForwardRefComponent<MeshDiscardMaterialProps, ShaderMaterial>;
+
+type UniformValue = THREE.Texture | THREE.TypedArray | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | THREE.Color | MeshBVHUniformStruct | number | boolean | null;
+type Uniforms = Record<string, UniformValue | Record<string, UniformValue> | Array<UniformValue>>;
+declare function shaderMaterial<U extends Uniforms, M extends THREE.ShaderMaterial & U>(uniforms: U, vertexShader: string, fragmentShader: string, onInit?: (material?: M) => void): ConstructorRepresentation<M> & {
+    key: string;
+};
+
+type SoftShadowsProps = {
+    size?: number;
+    samples?: number;
+    focus?: number;
+};
+declare function SoftShadows({ focus, samples, size }: SoftShadowsProps): null;
+
+declare class SpotLightMaterial extends THREE.ShaderMaterial {
+    constructor();
+}
+
+declare class StarfieldMaterial extends ShaderMaterial {
+    uniforms: {
+        time: {
+            value: number;
+        };
+        fade: {
+            value: number;
+        };
+    };
+    constructor();
+    setTime(time: number): void;
+    setFade(fade: number): void;
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        starfieldMaterial: ThreeElement<typeof StarfieldMaterial>;
+    }
+}
+
+declare class SparklesMaterial extends ShaderMaterial {
+    uniforms: {
+        time: Uniform$2<number>;
+        pixelRatio: Uniform$2<number>;
+    };
+    constructor();
+    get time(): number;
+    set time(value: number);
+    get pixelRatio(): number;
+    set pixelRatio(value: number);
+}
+
+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 module '@react-three/fiber' {
+    interface ThreeElements {
+        gridMaterial: ThreeElements['shaderMaterial'] & GridMaterialType;
+    }
+}
+declare const Grid: ForwardRefComponent<GridProps, THREE.Mesh>;
+
+type SpotLightProps = Omit<ThreeElements['spotLight'], 'ref'> & {
+    depthBuffer?: DepthTexture;
+    attenuation?: number;
+    anglePower?: number;
+    radiusTop?: number;
+    radiusBottom?: number;
+    opacity?: number;
+    color?: string | number;
+    volumetric?: boolean;
+    debug?: boolean;
+};
+interface ShadowMeshProps {
+    distance?: number;
+    alphaTest?: number;
+    scale?: number;
+    map?: Texture$1;
+    shader?: string;
+    width?: number;
+    height?: number;
+}
+declare function SpotLightShadow(props: React.PropsWithChildren<ShadowMeshProps>): React.JSX.Element;
+declare const SpotLight: ForwardRefComponent<React.PropsWithChildren<SpotLightProps>, SpotLight$1>;
+
+type StarsProps = {
+    radius?: number;
+    depth?: number;
+    count?: number;
+    factor?: number;
+    saturation?: number;
+    fade?: boolean;
+    speed?: number;
+};
+declare const Stars: ForwardRefComponent<StarsProps, Points$1>;
+
+interface MaterialShader {
+    vertexShader: string;
+    fragmentShader: string;
+    defines: {
+        [define: string]: string | number | boolean;
+    } | undefined;
+    uniforms: {
+        [uniform: string]: THREE.IUniform;
+    };
+}
+declare function useBoxProjectedEnv(position?: ReactThreeFiber.Vector3, size?: ReactThreeFiber.Vector3): {
+    ref: React.RefObject<THREE.Material>;
+    onBeforeCompile: (shader: MaterialShader) => void;
+    customProgramCacheKey: () => string;
+};
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        sparklesMaterial: ThreeElement<typeof SparklesMaterial>;
+    }
+}
+type SparklesProps = Omit<ThreeElements['points'], 'ref'> & {
+    count?: number;
+    speed?: number | Float32Array;
+    opacity?: number | Float32Array;
+    color?: THREE.ColorRepresentation | Float32Array;
+    size?: number | Float32Array;
+    scale?: number | [number, number, number] | THREE.Vector3;
+    noise?: number | [number, number, number] | THREE.Vector3 | Float32Array;
+};
+declare const Sparkles: ForwardRefComponent<SparklesProps, THREE.Points>;
+
+type TextProps = Omit<ThreeElements['mesh'], 'ref'> & {
+    children: React.ReactNode;
+    characters?: string;
+    color?: ReactThreeFiber.Color;
+    fontSize?: number;
+    fontWeight?: number | string;
+    fontStyle?: 'italic' | 'normal';
+    maxWidth?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    textAlign?: 'left' | 'right' | 'center' | 'justify';
+    font?: string;
+    anchorX?: number | 'left' | 'center' | 'right';
+    anchorY?: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom';
+    clipRect?: [number, number, number, number];
+    depthOffset?: number;
+    direction?: 'auto' | 'ltr' | 'rtl';
+    overflowWrap?: 'normal' | 'break-word';
+    whiteSpace?: 'normal' | 'overflowWrap' | 'nowrap';
+    outlineWidth?: number | string;
+    outlineOffsetX?: number | string;
+    outlineOffsetY?: number | string;
+    outlineBlur?: number | string;
+    outlineColor?: ReactThreeFiber.Color;
+    outlineOpacity?: number;
+    strokeWidth?: number | string;
+    strokeColor?: ReactThreeFiber.Color;
+    strokeOpacity?: number;
+    fillOpacity?: number;
+    sdfGlyphSize?: number;
+    debugSDF?: boolean;
+    glyphGeometryDetail?: number;
+    onSync?: (troika: any) => void;
+};
+declare const Text: ForwardRefComponent<TextProps, any>;
+
+export { AccumulativeShadows, AdaptiveDpr, AdaptiveEvents, ArcballControls, AsciiRenderer, BBAnchor, Backdrop, BakeShadows, Billboard, BlurPass, Bounds, Box, CameraShake, Capsule, CatmullRomLine, Caustics, Center, Circle, Clone, Cloud, CloudInstance, CloudMaterial, Clouds, ComputedAttribute, Cone, ContactShadows, ConvolutionMaterial, CubeCamera, CubeTexture, CubicBezierLine, CurveModifier, CycleRaycast, Cylinder, Decal, Detailed, DetectGPU, DeviceOrientationControls, DiscardMaterial, Dodecahedron, DragControls, Edges, Effects, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, Example, Extrude, Fbo, Fbx, FirstPersonControls, Fisheye, Float, FlyControls, GizmoHelper, GizmoViewcube, GizmoViewport, Gltf, GradientTexture, GradientType, Grid, Helper, Html, Hud, Icosahedron, Image, Instance, InstancedAttribute, Instances, IsObject, KeyboardControls, Ktx2, Lathe, Lightformer, Line, Loader, MapControls, Mask, MatcapTexture, Merged, MeshDiscardMaterial, MeshDistortMaterial, MeshPortalMaterial, MeshReflectorMaterial, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, MotionPathControls, NormalTexture, Octahedron, OrbitControls, OrthographicCamera, Outlines, PerformanceMonitor, PerspectiveCamera, PivotControls, Plane, Point, PointMaterial, PointMaterialImpl, PointerLockControls, Points, PointsBuffer, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, Preload, PresentationControls, Progress, QuadraticBezierLine, RandomizedLight, RenderCubeTexture, RenderTexture, Resize, Ring, RoundedBox, RoundedBoxGeometry, Sampler, ScreenQuad, ScreenSizer, ScreenSpace, ScreenVideoTexture, Scroll, ScrollControls, Segment, SegmentObject, Segments, Select, Shadow, Shape, Sky, SoftShadows, Sparkles, SparklesMaterial, Sphere, SpotLight, SpotLightMaterial, SpotLightShadow, SpriteAnimator, Stage, StarfieldMaterial, Stars, Stats, StatsGl, Svg, Tetrahedron, Text, Text3D, Texture, Torus, TorusKnot, TrackballControls, Trail, TrailTexture, TransformControls, Tube, VideoTexture, View, WebcamVideoTexture, Wireframe, WireframeMaterial, WireframeMaterialShaders, accumulativeContext, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, isWebGL2Available, meshBounds, presetsObj, setWireframeOverride, shaderMaterial, useAnimations, useAspect, useBounds, useBoxProjectedEnv, 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 { AccumulativeContext, AccumulativeLightContext, AccumulativeShadowsProps, ArcballControlsProps, Args, AsciiRendererProps, BBAnchorProps, BackdropProps, BillboardProps, BlurPassProps, BoundsApi, BoundsProps, CalculatePosition, CameraShakeProps, CatmullRomLineProps, CausticsProps, CenterProps, CloneProps, CloudProps, CloudsProps, ComputedAttributeProps, ContactShadowsProps, ContainerProps, CubeCameraOptions, CubeCameraProps, CubeTextureProps, CubicBezierLineProps, CurveModifierProps, CurveModifierRef, CycleRaycastProps, DecalProps, DetailedProps, DetectGPUProps, DeviceOrientationControlsProps, DragControlsProps, EdgesProps, EffectsProps, EnvironmentLoaderProps, EnvironmentProps, ExampleApi, ExampleProps, FboProps, FirstPersonControlsProps, FisheyeProps, FloatProps, FlyControlsProps, FontData, FrameData, GizmoHelperProps, GltfProps, Glyph, GradientTextureProps, GridMaterialType, GridProps, HelperProps, HtmlProps, HudProps, ImageProps, InstanceProps, InstancedAttributeProps, InstancesProps, KeyboardControlsEntry, KeyboardControlsProps, LightProps, LineProps, LoaderOptions, MapControlsProps, MaskProps, MergedProps, MeshDiscardMaterialProps, MeshDistortMaterialProps, MeshReflectorMaterialProps, MeshTransmissionMaterialProps, MetaData, MotionPathProps, MotionPathRef, OnCenterCallbackProps, OrbitControlsChangeEvent, OrbitControlsProps, OrthographicCameraProps, OutlinesProps, PerformanceMonitorApi, PerformanceMonitorProps, PerspectiveCameraProps, PivotControlsProps, PointMaterialProps, PointerLockControlsProps, PointsBuffersProps, PointsInstancesProps, PortalProps, PositionalAudioProps, PreloadProps, PresentationControlProps, PresetsType, QuadraticBezierLineProps, QuadraticBezierLineRef, RandomizedLightProps, RenderCubeTextureApi, RenderCubeTextureProps, RenderTextureProps, ResizeProps, RoundedBoxGeometryProps, RoundedBoxProps, SamplerProps, ScreenQuadProps, ScreenSizerProps, ScreenSpaceProps, ScreenVideoTextureProps, ScrollControlsProps, ScrollControlsState, ScrollProps, SegmentProps, SegmentsProps, SelectProps, ShadowProps, ShadowType, ShakeController, ShapeProps, Size, SizeProps, SkyProps, SoftShadowsProps, SparklesProps, SpotLightProps, SpriteAnimatorProps, SpriteData, StageProps, StarsProps, StatsGlProps, StatsProps, SvgProps, Text3DProps, TextProps, TrackballControlsProps, TrailProps, TrailTextureProps, TransformControlsProps, TransformFn, VideoTextureProps, ViewProps, ViewportProps, WebcamVideoTextureProps, WireframeMaterialProps, WobbleMaterialProps, useSurfaceSamplerProps };