@react-three/fiber 8.2.0 → 9.0.0-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @react-three/fiber
 
+## 8.2.2
+
+### Patch Changes
+
+- acd6f04: fix: warn on stray text
+
+## 8.2.1
+
+### Patch Changes
+
+- 25e35a1: fix: prefer useLayoutEffect in react-native
+
 ## 8.2.0
 
 ### Minor Changes

package/dist/declarations/src/core/events.d.ts

@@ -1,69 +1,69 @@
-import * as THREE from 'three';
-import type { UseBoundStore } from 'zustand';
-import type { RootState } from './store';
-export interface Intersection extends THREE.Intersection {
-    eventObject: THREE.Object3D;
-}
-export interface IntersectionEvent<TSourceEvent> extends Intersection {
-    eventObject: THREE.Object3D;
-    intersections: Intersection[];
-    unprojectedPoint: THREE.Vector3;
-    pointer: THREE.Vector2;
-    delta: number;
-    ray: THREE.Ray;
-    camera: Camera;
-    stopPropagation: () => void;
-    nativeEvent: TSourceEvent;
-    stopped: boolean;
-}
-export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-export declare type ThreeEvent<TEvent> = IntersectionEvent<TEvent>;
-export declare type DomEvent = PointerEvent | MouseEvent | WheelEvent;
-export declare type Events = {
-    onClick: EventListener;
-    onContextMenu: EventListener;
-    onDoubleClick: EventListener;
-    onWheel: EventListener;
-    onPointerDown: EventListener;
-    onPointerUp: EventListener;
-    onPointerLeave: EventListener;
-    onPointerMove: EventListener;
-    onPointerCancel: EventListener;
-    onLostPointerCapture: EventListener;
-};
-export declare type EventHandlers = {
-    onClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
-    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMissed?: (event: MouseEvent) => void;
-    onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
-    onWheel?: (event: ThreeEvent<WheelEvent>) => void;
-};
-export declare type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
-export declare type ComputeFunction = (event: DomEvent, root: RootState, previous?: RootState) => void;
-export interface EventManager<TTarget> {
-    enabled: boolean;
-    priority: number;
-    compute?: ComputeFunction;
-    filter?: FilterFunction;
-    connected?: TTarget;
-    handlers?: Events;
-    connect?: (target: TTarget) => void;
-    disconnect?: () => void;
-}
-export interface PointerCaptureTarget {
-    intersection: Intersection;
-    target: Element;
-}
-export declare function getEventPriority(): 1 | 4 | 16;
-export declare function removeInteractivity(store: UseBoundStore<RootState>, object: THREE.Object3D): void;
-export declare function createEvents(store: UseBoundStore<RootState>): {
-    handlePointer: (name: string) => (event: DomEvent) => void;
-};
+import * as THREE from 'three';
+import type { UseBoundStore } from 'zustand';
+import type { RootState } from './store';
+export interface Intersection extends THREE.Intersection {
+    eventObject: THREE.Object3D;
+}
+export interface IntersectionEvent<TSourceEvent> extends Intersection {
+    eventObject: THREE.Object3D;
+    intersections: Intersection[];
+    unprojectedPoint: THREE.Vector3;
+    pointer: THREE.Vector2;
+    delta: number;
+    ray: THREE.Ray;
+    camera: Camera;
+    stopPropagation: () => void;
+    nativeEvent: TSourceEvent;
+    stopped: boolean;
+}
+export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export declare type ThreeEvent<TEvent> = IntersectionEvent<TEvent>;
+export declare type DomEvent = PointerEvent | MouseEvent | WheelEvent;
+export declare type Events = {
+    onClick: EventListener;
+    onContextMenu: EventListener;
+    onDoubleClick: EventListener;
+    onWheel: EventListener;
+    onPointerDown: EventListener;
+    onPointerUp: EventListener;
+    onPointerLeave: EventListener;
+    onPointerMove: EventListener;
+    onPointerCancel: EventListener;
+    onLostPointerCapture: EventListener;
+};
+export declare type EventHandlers = {
+    onClick?: (event: ThreeEvent<MouseEvent>) => void;
+    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
+    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
+    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerMissed?: (event: MouseEvent) => void;
+    onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
+    onWheel?: (event: ThreeEvent<WheelEvent>) => void;
+};
+export declare type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
+export declare type ComputeFunction = (event: DomEvent, root: RootState, previous?: RootState) => void;
+export interface EventManager<TTarget> {
+    enabled: boolean;
+    priority: number;
+    compute?: ComputeFunction;
+    filter?: FilterFunction;
+    connected?: TTarget;
+    handlers?: Events;
+    connect?: (target: TTarget) => void;
+    disconnect?: () => void;
+}
+export interface PointerCaptureTarget {
+    intersection: Intersection;
+    target: Element;
+}
+export declare function getEventPriority(): 1 | 4 | 16;
+export declare function removeInteractivity(store: UseBoundStore<RootState>, object: THREE.Object3D): void;
+export declare function createEvents(store: UseBoundStore<RootState>): {
+    handlePointer: (name: string) => (event: DomEvent) => void;
+};

package/dist/declarations/src/core/hooks.d.ts

@@ -1,21 +1,23 @@
-import * as THREE from 'three';
-import { StateSelector, EqualityChecker } from 'zustand';
-import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-import { RootState, RenderCallback } from './store';
-import { ObjectMap } from './utils';
-export interface Loader<T> extends THREE.Loader {
-    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;
-}
-export declare type Extensions = (loader: THREE.Loader) => void;
-export declare type LoaderResult<T> = T extends any[] ? Loader<T[number]> : Loader<T>;
-export declare type ConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
-export declare type BranchingReturn<T, Parent, Coerced> = ConditionalType<T, Parent, Coerced, T>;
-export declare function useStore(): import("zustand").UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
-export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
-export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
-export declare function useGraph(object: THREE.Object3D): ObjectMap;
-export declare function useLoader<T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? BranchingReturn<T, GLTF, GLTF & ObjectMap>[] : BranchingReturn<T, GLTF, GLTF & ObjectMap>;
-export declare namespace useLoader {
-    var preload: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions | undefined) => undefined;
-    var clear: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U) => void;
-}
+import * as THREE from 'three';
+import { StateSelector, EqualityChecker } from 'zustand';
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { RootState, RenderCallback, StageTypes } from './store';
+import { ObjectMap } from './utils';
+import { UpdateCallback } from './stages';
+export interface Loader<T> extends THREE.Loader {
+    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;
+}
+export declare type Extensions = (loader: THREE.Loader) => void;
+export declare type LoaderResult<T> = T extends any[] ? Loader<T[number]> : Loader<T>;
+export declare type ConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
+export declare type BranchingReturn<T, Parent, Coerced> = ConditionalType<T, Parent, Coerced, T>;
+export declare function useStore(): import("zustand").UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
+export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
+export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
+export declare function useUpdate(callback: UpdateCallback, stage?: StageTypes): void;
+export declare function useGraph(object: THREE.Object3D): ObjectMap;
+export declare function useLoader<T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? BranchingReturn<T, GLTF, GLTF & ObjectMap>[] : BranchingReturn<T, GLTF, GLTF & ObjectMap>;
+export declare namespace useLoader {
+    var preload: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions | undefined) => undefined;
+    var clear: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U) => void;
+}

package/dist/declarations/src/core/index.d.ts

@@ -1,57 +1,61 @@
-/// <reference types="react-reconciler" />
-import * as THREE from 'three';
-import * as React from 'react';
-import { UseBoundStore } from 'zustand';
-import * as ReactThreeFiber from '../three-types';
-import { Renderer, context, RootState, Size, Dpr, Performance, PrivateKeys } from './store';
-import { extend, Root } from './renderer';
-import { addEffect, addAfterEffect, addTail } from './loop';
-import { EventManager, ComputeFunction } from './events';
-import { dispose, getRootState, Camera } from './utils';
-declare const roots: Map<Element, Root>;
-declare const invalidate: (state?: RootState | undefined, frames?: number) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined, frame?: THREE.XRFrame | undefined) => void;
-declare const reconciler: import("react-reconciler").Reconciler<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>, import("./renderer").Instance, never, import("./renderer").Instance, import("./renderer").Instance>, applyProps: typeof import("./utils").applyProps;
-declare type Properties<T> = Pick<T, {
-    [K in keyof T]: T[K] extends (_: any) => any ? never : K;
-}[keyof T]>;
-declare type GLProps = Renderer | ((canvas: HTMLCanvasElement) => Renderer) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
-export declare type RenderProps<TCanvas extends Element> = {
-    gl?: GLProps;
-    size?: Size;
-    shadows?: boolean | Partial<THREE.WebGLShadowMap>;
-    legacy?: boolean;
-    linear?: boolean;
-    flat?: boolean;
-    orthographic?: boolean;
-    frameloop?: 'always' | 'demand' | 'never';
-    performance?: Partial<Omit<Performance, 'regress'>>;
-    dpr?: Dpr;
-    raycaster?: Partial<THREE.Raycaster>;
-    camera?: (Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
-        manual?: boolean;
-    };
-    events?: (store: UseBoundStore<RootState>) => EventManager<HTMLElement>;
-    onCreated?: (state: RootState) => void;
-    onPointerMissed?: (event: MouseEvent) => void;
-};
-export declare type ReconcilerRoot<TCanvas extends Element> = {
-    configure: (config?: RenderProps<TCanvas>) => ReconcilerRoot<TCanvas>;
-    render: (element: React.ReactNode) => UseBoundStore<RootState>;
-    unmount: () => void;
-};
-declare function createRoot<TCanvas extends Element>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
-declare function render<TCanvas extends Element>(children: React.ReactNode, canvas: TCanvas, config: RenderProps<TCanvas>): UseBoundStore<RootState>;
-declare function unmountComponentAtNode<TElement extends Element>(canvas: TElement, callback?: (canvas: TElement) => void): void;
-export declare type InjectState = Partial<Omit<RootState, PrivateKeys> & {
-    events?: {
-        enabled?: boolean;
-        priority?: number;
-        compute?: ComputeFunction;
-        connected?: any;
-    };
-    size?: Size;
-}>;
-declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): React.ReactNode;
-declare const act: any;
-export * from './hooks';
-export { context, render, createRoot, unmountComponentAtNode, createPortal, reconciler, applyProps, dispose, invalidate, advance, extend, addEffect, addAfterEffect, addTail, getRootState, act, roots as _roots, };
+/// <reference types="webxr" />
+/// <reference types="react-reconciler" />
+import * as THREE from 'three';
+import * as React from 'react';
+import { StoreApi, UseBoundStore } from 'zustand';
+import * as ReactThreeFiber from '../three-types';
+import { Renderer, context, RootState, Size, Dpr, Performance, PrivateKeys, Frameloop } from './store';
+import { extend, Root } from './renderer';
+import { addEffect, addAfterEffect, addTail } from './loop';
+import { EventManager, ComputeFunction } from './events';
+import { dispose, getRootState, Camera } from './utils';
+import { Stage } from './stages';
+declare const roots: Map<Element, Root>;
+declare const invalidate: (state?: RootState | undefined, frames?: number) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined, frame?: XRFrame | undefined) => void;
+declare const reconciler: import("react-reconciler").Reconciler<UseBoundStore<RootState, StoreApi<RootState>>, import("./renderer").Instance, void, import("./renderer").Instance, import("./renderer").Instance>, applyProps: typeof import("./utils").applyProps;
+declare type Properties<T> = Pick<T, {
+    [K in keyof T]: T[K] extends (_: any) => any ? never : K;
+}[keyof T]>;
+declare type GLProps = Renderer | ((canvas: HTMLCanvasElement) => Renderer) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
+export declare type RenderProps<TCanvas extends Element> = {
+    gl?: GLProps;
+    size?: Size;
+    shadows?: boolean | Partial<THREE.WebGLShadowMap>;
+    legacy?: boolean;
+    linear?: boolean;
+    flat?: boolean;
+    orthographic?: boolean;
+    frameloop?: Frameloop;
+    performance?: Partial<Omit<Performance, 'regress'>>;
+    dpr?: Dpr;
+    raycaster?: Partial<THREE.Raycaster>;
+    camera?: (Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
+        manual?: boolean;
+    };
+    events?: (store: UseBoundStore<RootState>) => EventManager<HTMLElement>;
+    onCreated?: (state: RootState) => void;
+    onPointerMissed?: (event: MouseEvent) => void;
+    stages?: Stage[];
+    render?: 'auto' | 'manual';
+};
+export declare type ReconcilerRoot<TCanvas extends Element> = {
+    configure: (config?: RenderProps<TCanvas>) => ReconcilerRoot<TCanvas>;
+    render: (element: React.ReactNode) => UseBoundStore<RootState>;
+    unmount: () => void;
+};
+declare function createRoot<TCanvas extends Element>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
+declare function render<TCanvas extends Element>(children: React.ReactNode, canvas: TCanvas, config: RenderProps<TCanvas>): UseBoundStore<RootState>;
+declare function unmountComponentAtNode<TElement extends Element>(canvas: TElement, callback?: (canvas: TElement) => void): void;
+export declare type InjectState = Partial<Omit<RootState, PrivateKeys> & {
+    events?: {
+        enabled?: boolean;
+        priority?: number;
+        compute?: ComputeFunction;
+        connected?: any;
+    };
+    size?: Size;
+}>;
+declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): React.ReactNode;
+declare const act: any;
+export * from './hooks';
+export { context, render, createRoot, unmountComponentAtNode, createPortal, reconciler, applyProps, dispose, invalidate, advance, extend, addEffect, addAfterEffect, addTail, getRootState, act, roots as _roots, };

package/dist/declarations/src/core/loop.d.ts

@@ -1,13 +1,13 @@
-import * as THREE from 'three';
-import { Root } from './renderer';
-import { RootState } from './store';
-declare type GlobalRenderCallback = (timeStamp: number) => void;
-export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
-export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
-export declare const addTail: (callback: GlobalRenderCallback) => () => void;
-export declare function createLoop<TCanvas>(roots: Map<TCanvas, Root>): {
-    loop: (timestamp: number) => void;
-    invalidate: (state?: RootState | undefined, frames?: number) => void;
-    advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined, frame?: THREE.XRFrame | undefined) => void;
-};
-export {};
+/// <reference types="webxr" />
+import { Root } from './renderer';
+import { RootState } from './store';
+declare type GlobalRenderCallback = (timeStamp: number) => void;
+export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
+export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
+export declare const addTail: (callback: GlobalRenderCallback) => () => void;
+export declare function createLoop<TCanvas>(roots: Map<TCanvas, Root>): {
+    loop: (timestamp: number) => void;
+    invalidate: (state?: RootState | undefined, frames?: number) => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined, frame?: XRFrame | undefined) => void;
+};
+export {};

package/dist/declarations/src/core/renderer.d.ts

@@ -1,51 +1,51 @@
-import * as THREE from 'three';
-import { UseBoundStore } from 'zustand';
-import Reconciler from 'react-reconciler';
-import { prepare, applyProps } from './utils';
-import { RootState } from './store';
-import { EventHandlers } from './events';
-export declare type Root = {
-    fiber: Reconciler.FiberRoot;
-    store: UseBoundStore<RootState>;
-};
-export declare type LocalState = {
-    type: string;
-    root: UseBoundStore<RootState>;
-    objects: Instance[];
-    parent: Instance | null;
-    primitive?: boolean;
-    eventCount: number;
-    handlers: Partial<EventHandlers>;
-    attach?: AttachType;
-    previousAttach: any;
-    memoizedProps: {
-        [key: string]: any;
-    };
-};
-export declare type AttachFnType = (parent: Instance, self: Instance) => () => void;
-export declare type AttachType = string | AttachFnType;
-export declare type BaseInstance = Omit<THREE.Object3D, 'children' | 'attach' | 'add' | 'remove' | 'raycast'> & {
-    __r3f: LocalState;
-    children: Instance[];
-    remove: (...object: Instance[]) => Instance;
-    add: (...object: Instance[]) => Instance;
-    raycast?: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
-};
-export declare type Instance = BaseInstance & {
-    [key: string]: any;
-};
-export declare type InstanceProps = {
-    [key: string]: unknown;
-} & {
-    args?: any[];
-    object?: object;
-    visible?: boolean;
-    dispose?: null;
-    attach?: AttachType;
-};
-declare let extend: (objects: object) => void;
-declare function createRenderer<TCanvas>(_roots: Map<TCanvas, Root>, _getEventPriority?: () => any): {
-    reconciler: Reconciler.Reconciler<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>, Instance, never, Instance, Instance>;
-    applyProps: typeof applyProps;
-};
-export { prepare, createRenderer, extend };
+import * as THREE from 'three';
+import { UseBoundStore } from 'zustand';
+import Reconciler from 'react-reconciler';
+import { prepare, applyProps } from './utils';
+import { RootState } from './store';
+import { EventHandlers } from './events';
+export declare type Root = {
+    fiber: Reconciler.FiberRoot;
+    store: UseBoundStore<RootState>;
+};
+export declare type LocalState = {
+    type: string;
+    root: UseBoundStore<RootState>;
+    objects: Instance[];
+    parent: Instance | null;
+    primitive?: boolean;
+    eventCount: number;
+    handlers: Partial<EventHandlers>;
+    attach?: AttachType;
+    previousAttach: any;
+    memoizedProps: {
+        [key: string]: any;
+    };
+};
+export declare type AttachFnType = (parent: Instance, self: Instance) => () => void;
+export declare type AttachType = string | AttachFnType;
+export declare type BaseInstance = Omit<THREE.Object3D, 'children' | 'attach' | 'add' | 'remove' | 'raycast'> & {
+    __r3f: LocalState;
+    children: Instance[];
+    remove: (...object: Instance[]) => Instance;
+    add: (...object: Instance[]) => Instance;
+    raycast?: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
+};
+export declare type Instance = BaseInstance & {
+    [key: string]: any;
+};
+export declare type InstanceProps = {
+    [key: string]: unknown;
+} & {
+    args?: any[];
+    object?: object;
+    visible?: boolean;
+    dispose?: null;
+    attach?: AttachType;
+};
+declare let extend: (objects: object) => void;
+declare function createRenderer<TCanvas>(_roots: Map<TCanvas, Root>, _getEventPriority?: () => any): {
+    reconciler: Reconciler.Reconciler<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>, Instance, void, Instance, Instance>;
+    applyProps: typeof applyProps;
+};
+export { prepare, createRenderer, extend };

package/dist/declarations/src/core/stages.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="webxr" />
+import { MutableRefObject } from 'react';
+import { StoreApi, UseBoundStore } from 'zustand';
+import { RootState } from './store';
+export interface UpdateCallback {
+    (state: RootState, delta: number, frame?: XRFrame): void;
+}
+export declare type UpdateCallbackRef = MutableRefObject<UpdateCallback>;
+declare type Store = UseBoundStore<RootState, StoreApi<RootState>>;
+export declare type UpdateSubscription = {
+    ref: UpdateCallbackRef;
+    store: Store;
+};
+export declare type FixedStageOptions = {
+    fixedStep?: number;
+    maxSubsteps?: number;
+};
+export declare type FixedStageProps = {
+    fixedStep: number;
+    maxSubsteps: number;
+    accumulator: number;
+    alpha: number;
+};
+export declare class Stage {
+    private subscribers;
+    private _frameTime;
+    constructor();
+    frame(delta: number, frame?: XRFrame): void;
+    add(ref: UpdateCallbackRef, store: Store): () => void;
+    get frameTime(): number;
+}
+export declare class FixedStage extends Stage {
+    private _fixedStep;
+    private _maxSubsteps;
+    private _accumulator;
+    private _alpha;
+    private _fixedFrameTime;
+    private _substepTimes;
+    constructor(fixedStep?: number, maxSubSteps?: number);
+    frame(delta: number, frame?: XRFrame): void;
+    get frameTime(): number;
+    get substepTimes(): number[];
+    get fixedStep(): number;
+    set fixedStep(fixedStep: number);
+    get maxSubsteps(): number;
+    set maxSubsteps(maxSubsteps: number);
+    get accumulator(): number;
+    get alpha(): number;
+}
+export declare const Stages: {
+    Early: Stage;
+    Fixed: FixedStage;
+    Update: Stage;
+    Late: Stage;
+    Render: Stage;
+    After: Stage;
+};
+export declare const Lifecycle: Stage[];
+export {};