@react-three/drei 9.109.3 → 9.109.5

package/core/AccumulativeShadows.d.ts

@@ -0,0 +1,61 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { ReactThreeFiber } from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type AccumulativeShadowsProps = {
+    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 global {
+    namespace JSX {
+        interface IntrinsicElements {
+            softShadowMaterial: JSX.IntrinsicElements['shaderMaterial'] & SoftShadowMaterialProps;
+        }
+    }
+}
+export declare const accumulativeContext: React.Context<AccumulativeContext>;
+export declare const AccumulativeShadows: ForwardRefComponent<JSX.IntrinsicElements['group'] & AccumulativeShadowsProps, AccumulativeContext>;
+export type RandomizedLightProps = {
+    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;
+};
+export declare const RandomizedLight: ForwardRefComponent<JSX.IntrinsicElements['group'] & RandomizedLightProps, AccumulativeLightContext>;
+export {};

package/core/AdaptiveDpr.d.ts

@@ -0,0 +1,3 @@
+export declare function AdaptiveDpr({ pixelated }: {
+    pixelated?: boolean;
+}): null;

package/core/AdaptiveEvents.d.ts

@@ -0,0 +1 @@
+export declare function AdaptiveEvents(): null;

package/core/ArcballControls.d.ts

@@ -0,0 +1,15 @@
+import { ReactThreeFiber } from '@react-three/fiber';
+import { ArcballControls as ArcballControlsImpl } from 'three-stdlib';
+import type { Event, OrthographicCamera, PerspectiveCamera } from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type ArcballControlsProps = Omit<ReactThreeFiber.Overwrite<ReactThreeFiber.Object3DNode<ArcballControlsImpl, typeof ArcballControlsImpl>, {
+    target?: ReactThreeFiber.Vector3;
+    camera?: OrthographicCamera | PerspectiveCamera;
+    domElement?: HTMLElement;
+    regress?: boolean;
+    makeDefault?: boolean;
+    onChange?: (e?: Event) => void;
+    onStart?: (e?: Event) => void;
+    onEnd?: (e?: Event) => void;
+}>, 'ref'>;
+export declare const ArcballControls: ForwardRefComponent<ArcballControlsProps, ArcballControlsImpl>;

package/core/AsciiRenderer.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+type AsciiRendererProps = {
+    renderIndex?: number;
+    bgColor?: string;
+    fgColor?: string;
+    characters?: string;
+    invert?: boolean;
+    color?: boolean;
+    resolution?: number;
+};
+export declare function AsciiRenderer({ renderIndex, bgColor, fgColor, characters, invert, color, resolution, }: AsciiRendererProps): React.JSX.Element;
+export {};

package/core/BBAnchor.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { GroupProps } from '@react-three/fiber';
+export interface BBAnchorProps extends GroupProps {
+    anchor: THREE.Vector3 | [number, number, number];
+}
+export declare const BBAnchor: ({ anchor, ...props }: BBAnchorProps) => React.JSX.Element;

package/core/Backdrop.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+export type BackdropProps = JSX.IntrinsicElements['group'] & {
+    floor?: number;
+    segments?: number;
+    receiveShadow?: boolean;
+    children?: React.ReactNode;
+};
+export declare function Backdrop({ children, floor, segments, receiveShadow, ...props }: {
+    [x: string]: any;
+    children: any;
+    floor?: number | undefined;
+    segments?: number | undefined;
+    receiveShadow: any;
+}): React.JSX.Element;

package/core/BakeShadows.d.ts

@@ -0,0 +1 @@
+export declare function BakeShadows(): null;

package/core/Billboard.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("react"),t=require("three"),n=require("@react-three/fiber");function u(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function o(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var a=u(e),c=o(r);const i=c.forwardRef((function({children:e,follow:r=!0,lockX:u=!1,lockY:o=!1,lockZ:i=!1,...l},f){const d=c.useRef(null),p=c.useRef(null),s=new t.Quaternion;return n.useFrame((({camera:e})=>{if(!r||!p.current)return;const t=p.current.rotation.clone();p.current.updateMatrix(),p.current.updateWorldMatrix(!1,!1),p.current.getWorldQuaternion(s),e.getWorldQuaternion(d.current.quaternion).premultiply(s.invert()),u&&(p.current.rotation.x=t.x),o&&(p.current.rotation.y=t.y),i&&(p.current.rotation.z=t.z)})),c.useImperativeHandle(f,(()=>p.current),[]),c.createElement("group",a.default({ref:p,matrixAutoUpdate:!1,matrixWorldAutoUpdate:!1},l),c.createElement("group",{ref:d},e))}));exports.Billboard=i;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("react"),t=require("three"),n=require("@react-three/fiber");function u(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function o(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var c=u(e),a=o(r);const i=a.forwardRef((function({children:e,follow:r=!0,lockX:u=!1,lockY:o=!1,lockZ:i=!1,...l},f){const d=a.useRef(null),s=a.useRef(null),p=new t.Quaternion;return n.useFrame((({camera:e})=>{if(!r||!s.current)return;const t=s.current.rotation.clone();s.current.updateMatrix(),s.current.updateWorldMatrix(!1,!1),s.current.getWorldQuaternion(p),e.getWorldQuaternion(d.current.quaternion).premultiply(p.invert()),u&&(s.current.rotation.x=t.x),o&&(s.current.rotation.y=t.y),i&&(s.current.rotation.z=t.z)})),a.useImperativeHandle(f,(()=>s.current),[]),a.createElement("group",c.default({ref:s},l),a.createElement("group",{ref:d},e))}));exports.Billboard=i;

package/core/Billboard.d.ts

@@ -0,0 +1,9 @@
+import { Group } from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type BillboardProps = {
+    follow?: boolean;
+    lockX?: boolean;
+    lockY?: boolean;
+    lockZ?: boolean;
+} & JSX.IntrinsicElements['group'];
+export declare const Billboard: ForwardRefComponent<BillboardProps, Group>;

package/core/Billboard.js

@@ -44,9 +44,7 @@ const Billboard = /* @__PURE__ */React.forwardRef(function Billboard({
   });
   React.useImperativeHandle(fref, () => localRef.current, []);
   return /*#__PURE__*/React.createElement("group", _extends({
-    ref: localRef,
-    matrixAutoUpdate: false,
-    matrixWorldAutoUpdate: false
+    ref: localRef
   }, props), /*#__PURE__*/React.createElement("group", {
     ref: inner
   }, children));

package/core/Bounds.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import * as THREE from 'three';
+export type SizeProps = {
+    box: THREE.Box3;
+    size: THREE.Vector3;
+    center: THREE.Vector3;
+    distance: number;
+};
+export 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;
+};
+export type BoundsProps = JSX.IntrinsicElements['group'] & {
+    maxDuration?: number;
+    margin?: number;
+    observe?: boolean;
+    fit?: boolean;
+    clip?: boolean;
+    interpolateFunc?: (t: number) => number;
+    onFit?: (data: SizeProps) => void;
+};
+export declare function Bounds({ children, maxDuration, margin, observe, fit, clip, interpolateFunc, onFit, }: BoundsProps): React.JSX.Element;
+export declare function useBounds(): BoundsApi;

package/core/Bvh.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { Mesh, Group } from 'three';
+import { SplitStrategy } from 'three-mesh-bvh';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export interface BVHOptions {
+    strategy?: SplitStrategy;
+    verbose?: boolean;
+    setBoundingBox?: boolean;
+    maxDepth?: number;
+    maxLeafTris?: number;
+    indirect?: boolean;
+}
+export type BvhProps = BVHOptions & JSX.IntrinsicElements['group'] & {
+    enabled?: boolean;
+    firstHitOnly?: boolean;
+};
+export declare function useBVH(mesh: React.MutableRefObject<Mesh | undefined>, options?: BVHOptions): void;
+export declare const Bvh: ForwardRefComponent<BvhProps, Group>;

package/core/CameraControls.d.ts

@@ -0,0 +1,22 @@
+import { EventDispatcher, OrthographicCamera, PerspectiveCamera } from 'three';
+import { ReactThreeFiber } from '@react-three/fiber';
+import CameraControlsImpl from 'camera-controls';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type CameraControlsProps = Omit<ReactThreeFiber.Overwrite<ReactThreeFiber.Node<CameraControlsImpl, typeof CameraControlsImpl>, {
+    camera?: PerspectiveCamera | OrthographicCamera;
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+    onStart?: (e?: {
+        type: 'controlstart';
+    }) => void;
+    onEnd?: (e?: {
+        type: 'controlend';
+    }) => void;
+    onChange?: (e?: {
+        type: 'update';
+    }) => void;
+    events?: boolean;
+    regress?: boolean;
+}>, 'ref' | keyof EventDispatcher>;
+export declare const CameraControls: ForwardRefComponent<CameraControlsProps, CameraControlsImpl>;
+export type CameraControls = CameraControlsImpl;

package/core/CameraShake.d.ts

@@ -0,0 +1,17 @@
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export interface ShakeController {
+    getIntensity: () => number;
+    setIntensity: (val: number) => void;
+}
+export interface CameraShakeProps {
+    intensity?: number;
+    decay?: boolean;
+    decayRate?: number;
+    maxYaw?: number;
+    maxPitch?: number;
+    maxRoll?: number;
+    yawFrequency?: number;
+    pitchFrequency?: number;
+    rollFrequency?: number;
+}
+export declare const CameraShake: ForwardRefComponent<CameraShakeProps, ShakeController | undefined>;

package/core/CatmullRomLine.d.ts

@@ -0,0 +1,11 @@
+import { Line2 } from 'three-stdlib';
+import { LineProps } from './Line';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type Props = Omit<LineProps, 'ref'> & {
+    closed?: boolean;
+    curveType?: 'centripetal' | 'chordal' | 'catmullrom';
+    tension?: number;
+    segments?: number;
+};
+export declare const CatmullRomLine: ForwardRefComponent<Props, Line2>;
+export {};

package/core/Caustics.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { ReactThreeFiber } from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type CausticsProps = JSX.IntrinsicElements['group'] & {
+    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.MutableRefObject<THREE.Object3D>;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            causticsProjectionMaterial: ReactThreeFiber.MeshNormalMaterialProps & {
+                viewMatrix?: {
+                    value: THREE.Matrix4;
+                };
+                color?: ReactThreeFiber.Color;
+                causticsTexture?: THREE.Texture;
+                causticsTextureB?: THREE.Texture;
+                lightProjMatrix?: THREE.Matrix4;
+                lightViewMatrix?: THREE.Matrix4;
+            };
+        }
+    }
+}
+export declare const Caustics: ForwardRefComponent<CausticsProps, THREE.Group>;
+export {};

package/core/Center.d.ts

@@ -0,0 +1,31 @@
+import { Box3, Vector3, Sphere, Group, Object3D } from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type OnCenterCallbackProps = {
+    parent: Object3D;
+    container: Object3D;
+    width: number;
+    height: number;
+    depth: number;
+    boundingBox: Box3;
+    boundingSphere: Sphere;
+    center: Vector3;
+    verticalAlignment: number;
+    horizontalAlignment: number;
+    depthAlignment: number;
+};
+export type CenterProps = {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+    front?: boolean;
+    back?: boolean;
+    disable?: boolean;
+    disableX?: boolean;
+    disableY?: boolean;
+    disableZ?: boolean;
+    precise?: boolean;
+    onCentered?: (props: OnCenterCallbackProps) => void;
+    cacheKey?: any;
+};
+export declare const Center: ForwardRefComponent<JSX.IntrinsicElements['group'] & CenterProps, Group>;

package/core/Clone.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { MeshProps } from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type CloneProps = {
+    object: THREE.Object3D | THREE.Object3D[];
+    children?: React.ReactNode;
+    deep?: boolean | 'materialsOnly' | 'geometriesOnly';
+    keys?: string[];
+    inject?: MeshProps | React.ReactNode | ((object: THREE.Object3D) => React.ReactNode);
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    isChild?: boolean;
+};
+export declare const Clone: ForwardRefComponent<Omit<JSX.IntrinsicElements['group'], 'children'> & CloneProps, THREE.Group>;

package/core/Cloud.d.ts

@@ -0,0 +1,59 @@
+import * as React from 'react';
+import { Color, Group, Vector3, Material, MeshLambertMaterial, Matrix4 } from 'three';
+import { MaterialNode, ReactThreeFiber } from '@react-three/fiber';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            cloudMaterial: MaterialNode<MeshLambertMaterial, typeof MeshLambertMaterial>;
+        }
+    }
+}
+type CloudState = {
+    uuid: string;
+    index: number;
+    segments: number;
+    dist: number;
+    matrix: Matrix4;
+    bounds: Vector3;
+    position: Vector3;
+    volume: number;
+    length: number;
+    ref: React.MutableRefObject<Group>;
+    speed: number;
+    growth: number;
+    opacity: number;
+    fade: number;
+    density: number;
+    rotation: number;
+    rotationFactor: number;
+    color: Color;
+};
+type CloudsProps = JSX.IntrinsicElements['group'] & {
+    texture?: string;
+    limit?: number;
+    range?: number;
+    material?: typeof Material;
+    frustumCulled?: boolean;
+};
+type CloudProps = JSX.IntrinsicElements['group'] & {
+    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;
+        volume?: number;
+    };
+    growth?: number;
+    speed?: number;
+    fade?: number;
+    opacity?: number;
+    color?: ReactThreeFiber.Color;
+};
+export declare const Clouds: React.ForwardRefExoticComponent<Omit<CloudsProps, "ref"> & React.RefAttributes<Group>>;
+export declare const CloudInstance: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group>>;
+export declare const Cloud: React.ForwardRefExoticComponent<Omit<CloudProps, "ref"> & React.RefAttributes<Group>>;
+export {};

package/core/ComputedAttribute.d.ts

@@ -0,0 +1,9 @@
+import { BufferAttributeProps } from '@react-three/fiber';
+import * as React from 'react';
+import { BufferAttribute, BufferGeometry } from 'three';
+type Props = {
+    compute: (geometry: BufferGeometry) => BufferAttribute;
+    name: string;
+};
+export declare const ComputedAttribute: ({ compute, name, ...props }: React.PropsWithChildren<Props & BufferAttributeProps>) => React.JSX.Element;
+export {};

package/core/ContactShadows.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type ContactShadowsProps = {
+    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;
+};
+export declare const ContactShadows: ForwardRefComponent<Omit<JSX.IntrinsicElements['group'], 'scale'> & ContactShadowsProps, THREE.Group>;

package/core/CubeCamera.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import { Fog, FogExp2, Texture } from 'three';
+import * as React from 'react';
+export type CubeCameraOptions = {
+    resolution?: number;
+    near?: number;
+    far?: number;
+    envMap?: THREE.Texture;
+    fog?: Fog | FogExp2;
+};
+export declare function useCubeCamera({ resolution, near, far, envMap, fog }?: CubeCameraOptions): {
+    fbo: THREE.WebGLCubeRenderTarget;
+    camera: THREE.CubeCamera;
+    update: () => void;
+};
+type Props = Omit<JSX.IntrinsicElements['group'], 'children'> & {
+    children?: (tex: Texture) => React.ReactNode;
+    frames?: number;
+} & CubeCameraOptions;
+export declare function CubeCamera({ children, frames, resolution, near, far, envMap, fog, ...props }: Props): React.JSX.Element;
+export {};

package/core/CubeTexture.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { CubeTexture as _CubeTexture, Texture } from 'three';
+type Options = {
+    path: string;
+};
+export declare function useCubeTexture(files: string[], { path }: Options): _CubeTexture;
+export declare namespace useCubeTexture {
+    var preload: (files: string[], { path }: Options) => undefined;
+}
+type CubeTextureProps = {
+    children?: (tex: Texture) => React.ReactNode;
+    files: Parameters<typeof useCubeTexture>[0];
+} & Options;
+export declare function CubeTexture({ children, files, ...options }: CubeTextureProps): React.JSX.Element;
+export {};

package/core/CubicBezierLine.d.ts

@@ -0,0 +1,13 @@
+import { Vector3 } from 'three';
+import { Line2 } from 'three-stdlib';
+import { LineProps } from './Line';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type Props = Omit<LineProps, 'points' | 'ref'> & {
+    start: Vector3 | [number, number, number];
+    end: Vector3 | [number, number, number];
+    midA: Vector3 | [number, number, number];
+    midB: Vector3 | [number, number, number];
+    segments?: number;
+};
+export declare const CubicBezierLine: ForwardRefComponent<Props, Line2>;
+export {};

package/core/CurveModifier.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { Flow } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export interface CurveModifierProps {
+    children: React.ReactElement<JSX.IntrinsicElements['mesh']>;
+    curve?: THREE.Curve<THREE.Vector3>;
+}
+export type CurveModifierRef = Pick<Flow, 'moveAlongCurve'>;
+export declare const CurveModifier: ForwardRefComponent<CurveModifierProps, CurveModifierRef>;

package/core/Decal.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import * as FIBER from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type DecalProps = Omit<JSX.IntrinsicElements['mesh'], 'children'> & {
+    debug?: boolean;
+    mesh?: React.MutableRefObject<THREE.Mesh>;
+    position?: FIBER.Vector3;
+    rotation?: FIBER.Euler | number;
+    scale?: FIBER.Vector3;
+    map?: THREE.Texture;
+    children?: React.ReactNode;
+    polygonOffsetFactor?: number;
+    depthTest?: boolean;
+};
+export declare const Decal: ForwardRefComponent<DecalProps, THREE.Mesh>;

package/core/Detailed.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { LOD, Object3D } from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type Props = JSX.IntrinsicElements['lOD'] & {
+    children: React.ReactElement<Object3D>[];
+    hysteresis?: number;
+    distances: number[];
+};
+export declare const Detailed: ForwardRefComponent<Props, LOD>;
+export {};

package/core/DetectGPU.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { GetGPUTier } from 'detect-gpu';
+export declare const useDetectGPU: (props?: GetGPUTier) => import("detect-gpu").TierResult;
+type DetectGPUProps = {
+    children?: (result: ReturnType<typeof useDetectGPU>) => React.ReactNode;
+} & Parameters<typeof useDetectGPU>[0];
+export declare function DetectGPU({ children, ...options }: DetectGPUProps): React.JSX.Element;
+export {};

package/core/DeviceOrientationControls.d.ts

@@ -0,0 +1,10 @@
+import { ReactThreeFiber } from '@react-three/fiber';
+import * as THREE from 'three';
+import { DeviceOrientationControls as DeviceOrientationControlsImp } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type DeviceOrientationControlsProps = ReactThreeFiber.Object3DNode<DeviceOrientationControlsImp, typeof DeviceOrientationControlsImp> & {
+    camera?: THREE.Camera;
+    onChange?: (e?: THREE.Event) => void;
+    makeDefault?: boolean;
+};
+export declare const DeviceOrientationControls: ForwardRefComponent<DeviceOrientationControlsProps, DeviceOrientationControlsImp>;

package/core/Edges.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+import { ReactThreeFiber, type ThreeElements } from '@react-three/fiber';
+import { LineSegmentsGeometry, LineMaterial, LineMaterialParameters, Line2 } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type EdgesRef = THREE.Mesh<LineSegmentsGeometry, LineMaterial>;
+export type EdgesProps = Partial<ThreeElements['mesh']> & {
+    threshold?: number;
+    lineWidth?: number;
+} & Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<ReactThreeFiber.Object3DNode<Line2, typeof Line2>, 'args' | 'geometry'> & Omit<ReactThreeFiber.Object3DNode<LineMaterial, [LineMaterialParameters]>, 'color' | 'vertexColors' | 'args'> & {
+    geometry?: THREE.BufferGeometry;
+    color?: THREE.ColorRepresentation;
+};
+export declare const Edges: ForwardRefComponent<EdgesProps, EdgesRef>;

package/core/Effects.d.ts

@@ -0,0 +1,29 @@
+import { TextureDataType } from 'three';
+import { ReactThreeFiber } from '@react-three/fiber';
+import { EffectComposer, RenderPass, ShaderPass } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+import { TextureEncoding } from '../helpers/deprecated';
+type Props = ReactThreeFiber.Node<EffectComposer, typeof EffectComposer> & {
+    multisamping?: number;
+    encoding?: TextureEncoding;
+    type?: TextureDataType;
+    renderIndex?: number;
+    disableGamma?: boolean;
+    disableRenderPass?: boolean;
+    disableRender?: boolean;
+    depthBuffer?: boolean;
+    stencilBuffer?: boolean;
+    anisotropy?: number;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            effectComposer: ReactThreeFiber.Node<EffectComposer, typeof EffectComposer>;
+            renderPass: ReactThreeFiber.Node<RenderPass, typeof RenderPass>;
+            shaderPass: ReactThreeFiber.Node<ShaderPass, typeof ShaderPass>;
+        }
+    }
+}
+export declare const isWebGL2Available: () => boolean;
+export declare const Effects: ForwardRefComponent<Props, EffectComposer>;
+export {};

package/core/Environment.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import { Object3DNode, Euler } from '@react-three/fiber';
+import { Texture, Scene } from 'three';
+import { GroundProjectedEnv as GroundProjectedEnvImpl } from 'three-stdlib';
+import { PresetsType } from '../helpers/environment-assets';
+import { EnvironmentLoaderProps } from './useEnvironment';
+export 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;
+    preset?: PresetsType;
+    scene?: Scene | React.MutableRefObject<Scene>;
+    ground?: boolean | {
+        radius?: number;
+        height?: number;
+        scale?: number;
+    };
+} & EnvironmentLoaderProps;
+export declare function EnvironmentMap({ scene, background, map, ...config }: EnvironmentProps): null;
+export declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, ...rest }: EnvironmentProps): null;
+export 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 global {
+    namespace JSX {
+        interface IntrinsicElements {
+            groundProjectedEnvImpl: Object3DNode<GroundProjectedEnvImpl, typeof GroundProjectedEnvImpl>;
+        }
+    }
+}
+export declare function Environment(props: EnvironmentProps): React.JSX.Element;