@types/three 0.140.0 → 0.141.0

three/README.md

@@ -8,8 +8,8 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Tue, 03 May 2022 17:01:38 GMT
- * Dependencies: none
+ * Last updated: Tue, 31 May 2022 18:31:37 GMT
+ * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 
 # Credits

three/examples/jsm/exporters/GLTFExporter.d.ts

@@ -91,7 +91,7 @@ export class GLTFExporter {
 export class GLTFWriter {
     constructor();
 
-    setPlugins(plugins: GLTFExporterPlugin[]);
+    setPlugins(plugins: GLTFExporterPlugin[]): void;
 
     /**
      * Parse scenes and generate GLTF output

three/examples/jsm/exporters/KTX2Exporter.d.ts

@@ -0,0 +1,5 @@
+import { Data3DTexture, DataTexture, WebGLRenderer, WebGLRenderTarget } from '../../../src/Three';
+
+export class KTX2Exporter {
+    parse(arg1: Data3DTexture | DataTexture | WebGLRenderer, arg2?: WebGLRenderTarget): Uint8Array;
+}

three/examples/jsm/geometries/LightningStrike.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from '../../../src/Three';
+import { BufferGeometry, Vector3 } from '../../../src/Three';
 
 export interface RandomGenerator {
     random(): number;
@@ -87,7 +87,7 @@ export interface RayParameters {
     ) => void;
 }
 
-export class LightningStrike {
+export class LightningStrike extends BufferGeometry {
     constructor(rayParameters?: RayParameters);
     copyParameters(dest?: RayParameters, source?: RayParameters): RayParameters;
 
@@ -103,6 +103,6 @@ export class LightningStrike {
 
     update(time: number): void;
 
-    copy(source: LightningStrike): LightningStrike;
+    copy(source: LightningStrike): this;
     clone(): this;
 }

three/examples/jsm/loaders/NRRDLoader.d.ts

@@ -1,8 +1,8 @@
-import { LoadingManager } from '../../../src/Three';
+import { Loader, LoadingManager } from '../../../src/Three';
 
 import { Volume } from '../misc/Volume';
 
-export class NRRDLoader {
+export class NRRDLoader extends Loader {
     constructor(manager?: LoadingManager);
     manager: LoadingManager;
     path: string;

three/examples/jsm/misc/MorphAnimMesh.d.ts

@@ -9,5 +9,5 @@ export class MorphAnimMesh extends Mesh {
     setDirectionBackward(): void;
     playAnimation(label: string, fps: number): void;
     updateAnimation(delta: number): void;
-    copy(source: MorphAnimMesh): this;
+    copy(source: MorphAnimMesh, recursive?: boolean): this;
 }

three/examples/jsm/objects/LightningStorm.d.ts

@@ -1,4 +1,4 @@
-import { Material, Vector3 } from '../../../src/Three';
+import { Material, Object3D, Vector3 } from '../../../src/Three';
 
 import { LightningStrike, RayParameters } from '../geometries/LightningStrike';
 
@@ -24,9 +24,9 @@ export interface StormParams {
     onLightningDown?: (lightning: LightningStrike) => void;
 }
 
-export class LightningStorm {
+export class LightningStorm extends Object3D {
     constructor(stormParams?: StormParams);
     update(time: number): void;
-    copy(source: LightningStorm): LightningStorm;
+    copy(source: LightningStorm, recursive?: boolean): this;
     clone(): this;
 }

three/examples/jsm/webxr/ARButton.d.ts

@@ -1,5 +1,9 @@
 import { WebGLRenderer } from '../../../src/Three';
 
+export interface ARButtonSessionInit extends XRSessionInit {
+    domOverlay: { root: HTMLElement };
+}
+
 export namespace ARButton {
-    function createButton(renderer: WebGLRenderer, sessionInit?: any): HTMLElement;
+    function createButton(renderer: WebGLRenderer, sessionInit?: Partial<ARButtonSessionInit>): HTMLElement;
 }

three/examples/jsm/webxr/OculusHandModel.d.ts

@@ -1,8 +1,9 @@
-import { Object3D, Sphere, Box3, Mesh, Texture, Vector3 } from '../../../src/Three';
+import { Mesh, Object3D, Texture, Vector3 } from '../../../src/Three';
+import { XRHandMeshModel } from './XRHandMeshModel';
 
 export class OculusHandModel extends Object3D {
     controller: Object3D;
-    motionController: Object3D | null;
+    motionController: XRHandMeshModel | null;
     envMap: Texture | null;
 
     mesh: Mesh | null;

three/examples/jsm/webxr/OculusHandPointerModel.d.ts

@@ -1,3 +1,5 @@
+import 'webxr';
+
 import {
     BufferGeometry,
     Intersection,
@@ -10,10 +12,12 @@ import {
     Vector3,
 } from '../../../src/Three';
 
+import { XRHandMeshModel } from './XRHandMeshModel';
+
 export class OculusHandPointerModel extends Object3D {
     hand: Object3D;
     controller: Object3D;
-    motionController: Object3D | null;
+    motionController: XRHandMeshModel | null;
 
     envMap: Texture | null;
 
@@ -31,7 +35,7 @@ export class OculusHandPointerModel extends Object3D {
     raycaster: Raycaster;
 
     visible: boolean;
-    xrInputSource: unknown;
+    xrInputSource: XRInputSource;
 
     constructor(hand: Object3D, controller: Object3D);
 

three/examples/jsm/webxr/XRControllerModelFactory.d.ts

@@ -7,6 +7,8 @@ export class XRControllerModel extends Object3D {
 
     motionController: any;
 
+    envMap: Texture;
+
     setEnvironmentMap(envMap: Texture): XRControllerModel;
 }
 

three/examples/jsm/webxr/XREstimatedLight.d.ts

@@ -1,24 +1,24 @@
-import { DirectionalLight, Group, LightProbe, XRFrame, WebGLRenderer, Texture } from '../../../src/Three';
+import { DirectionalLight, Group, LightProbe, Texture, WebGLRenderer } from '../../../src/Three';
 
 export class SessionLightProbe {
     xrLight: XREstimatedLight;
     renderer: WebGLRenderer;
-    lightProbe: unknown;
-    xrWebGLBinding: unknown | null;
+    lightProbe: LightProbe;
+    xrWebGLBinding: XRWebGLBinding | null;
     estimationStartCallback: () => void;
     frameCallback: (this: SessionLightProbe, time: number, xrFrame: XRFrame) => void;
 
     constructor(
         xrLight: XREstimatedLight,
         renderer: WebGLRenderer,
-        lightProbe: unknown,
+        lightProbe: LightProbe,
         environmentEstimation: boolean,
         estimationStartCallback: () => void,
     );
 
     updateReflection: () => void;
 
-    onXRFrame: (time: number, xrFrame: XRFrame) => void;
+    onXRFrame: XRFrameRequestCallback;
 
     dispose: () => void;
 }

three/examples/jsm/webxr/XRHandModelFactory.d.ts

@@ -19,7 +19,7 @@ export class XRHandModelFactory {
 
     createHandModel(
         controller: Group,
-        profile?: 'spheres' | 'boxes' | 'oculus',
+        profile?: 'spheres' | 'boxes' | 'mesh',
         options?: XRHandPrimitiveModelOptions,
     ): XRHandModel;
 }

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.140
+// Type definitions for three 0.141
 // Project: https://threejs.org/
 // Definitions by: Josh Ellis <https://github.com/joshuaellis>
 //                 Nathan Bierema <https://github.com/Methuselah96>

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.140.0",
+    "version": "0.141.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -24,7 +24,9 @@
         "directory": "types/three"
     },
     "scripts": {},
-    "dependencies": {},
-    "typesPublisherContentHash": "0003f52bd6b42bfc5b77be02ad5eee29a50d1ddc25ce1b64506a2253f0420782",
+    "dependencies": {
+        "@types/webxr": "*"
+    },
+    "typesPublisherContentHash": "f2cb59cf51914baac1f0032481e5702cdf38ace7e83148c7e0faefc44ed80745",
     "typeScriptVersion": "3.9"
 }

three/src/Three.d.ts

@@ -207,7 +207,6 @@ export * from './renderers/webgl/WebGLShadowMap';
 export * from './renderers/webgl/WebGLState';
 export * from './renderers/webgl/WebGLTextures';
 export * from './renderers/webgl/WebGLUniforms';
-export * from './renderers/webxr/WebXR';
 export * from './renderers/webxr/WebXRController';
 export * from './renderers/webxr/WebXRManager';
 export { WebGLUtils } from './renderers/webgl/WebGLUtils.js';

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -156,4 +156,24 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      * @default null
      */
     specularColorMap: Texture | null;
+
+    /**
+     * @default null
+     */
+    iridescenceMap: Texture | null;
+
+    /**
+     * @default 1.3
+     */
+    iridescenceIOR: number;
+
+    /**
+     * @default [100, 400]
+     */
+    iridescenceThicknessRange: number[];
+
+    /**
+     * @default null
+     */
+    iridescenceThicknessMap: Texture | null;
 }

three/src/renderers/WebGLRenderTarget.d.ts

@@ -17,6 +17,12 @@ export interface WebGLRenderTargetOptions {
     generateMipmaps?: boolean | undefined; // true;
     depthTexture?: DepthTexture | undefined;
     encoding?: TextureEncoding | undefined;
+
+    /**
+     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+     * @default 0
+     */
+    samples?: number;
 }
 
 export class WebGLRenderTarget extends EventDispatcher {

three/src/renderers/WebGLRenderer.d.ts

@@ -19,7 +19,6 @@ import { WebXRManager } from '../renderers/webxr/WebXRManager';
 import { BufferGeometry } from './../core/BufferGeometry';
 import { Texture } from '../textures/Texture';
 import { Data3DTexture } from '../textures/Data3DTexture';
-import { XRAnimationLoopCallback } from './webxr/WebXR';
 import { Vector3 } from '../math/Vector3';
 import { Box3 } from '../math/Box3';
 import { DataArrayTexture } from '../textures/DataArrayTexture';
@@ -336,7 +335,7 @@ export class WebGLRenderer implements Renderer {
      * A build in function that can be used instead of requestAnimationFrame. For WebXR projects this function must be used.
      * @param callback The function will be called every available frame. If `null` is passed it will stop any already ongoing animation.
      */
-    setAnimationLoop(callback: XRAnimationLoopCallback | null): void;
+    setAnimationLoop(callback: XRFrameRequestCallback | null): void;
 
     /**
      * @deprecated Use {@link WebGLRenderer#setAnimationLoop .setAnimationLoop()} instead.

three/src/renderers/webxr/WebXRController.d.ts

@@ -1,14 +1,40 @@
 import { Group } from '../../objects/Group';
-import { XREventType, XRFrame, XRInputSource, XRReferenceSpace } from './WebXR';
+import { Vector3 } from '../../math/Vector3';
 
-export type XRControllerEventType = XREventType | 'disconnected' | 'connected';
+export type XRControllerEventType = XRSessionEventType | XRInputSourceEventType | 'disconnected' | 'connected';
+
+export type XRHandJoints = Record<XRHandJoint, number>;
+
+export interface XRHandInputState {
+    pinching: boolean;
+}
+
+export class XRHandSpace extends Group {
+    readonly joints: Partial<XRHandJoints>;
+    readonly inputState: XRHandInputState;
+}
+
+export class XRTargetRaySpace extends Group {
+    hasLinearVelocity: boolean;
+    readonly linearVelocity: Vector3;
+    hasAngularVelocity: boolean;
+    readonly angularVelocity: Vector3;
+}
+
+export class XRGripSpace extends Group {
+    hasLinearVelocity: boolean;
+    readonly linearVelocity: Vector3;
+    hasAngularVelocity: boolean;
+    readonly angularVelocity: Vector3;
+}
 
 export class WebXRController {
     constructor();
 
-    getTargetRaySpace(): Group;
-    getGripSpace(): Group;
-    dispatchEvent(event: { type: XRControllerEventType; data?: XRInputSource | undefined }): this;
+    getHandSpace(): XRHandSpace;
+    getTargetRaySpace(): XRTargetRaySpace;
+    getGripSpace(): XRGripSpace;
+    dispatchEvent(event: { type: XRControllerEventType; data?: XRInputSource }): this;
     disconnect(inputSource: XRInputSource): this;
     update(inputSource: XRInputSource, frame: XRFrame, referenceSpace: XRReferenceSpace): this;
 }

three/src/renderers/webxr/WebXRManager.d.ts

@@ -1,7 +1,13 @@
-import { Group } from '../../objects/Group';
-import { Camera } from '../../cameras/Camera';
+/// <reference types="webxr" />
+
+import { Vector4 } from '../../math/Vector4';
+import { ArrayCamera } from '../../cameras/ArrayCamera';
+import { PerspectiveCamera } from '../../cameras/PerspectiveCamera';
 import { EventDispatcher } from '../../core/EventDispatcher';
-import { XRFrameRequestCallback, XRReferenceSpace, XRReferenceSpaceType, XRSession } from './WebXR';
+import { XRTargetRaySpace, XRGripSpace, XRHandSpace } from './WebXRController';
+
+export type WebXRCamera = PerspectiveCamera & { viewport: Vector4 };
+export type WebXRArrayCamera = Omit<ArrayCamera, 'cameras'> & { cameras: [WebXRCamera, WebXRCamera] };
 
 export class WebXRManager extends EventDispatcher {
     constructor(renderer: any, gl: WebGLRenderingContext);
@@ -16,15 +22,25 @@ export class WebXRManager extends EventDispatcher {
      */
     isPresenting: boolean;
 
-    getController(index: number): Group;
-    getControllerGrip(index: number): Group;
-    getHand(index: number): Group;
+    /**
+     * @default true
+     */
+    cameraAutoUpdate: boolean;
+
+    getController(index: number): XRTargetRaySpace;
+    getControllerGrip(index: number): XRGripSpace;
+    getHand(index: number): XRHandSpace;
     setFramebufferScaleFactor(value: number): void;
     setReferenceSpaceType(value: XRReferenceSpaceType): void;
     getReferenceSpace(): XRReferenceSpace | null;
+    setReferenceSpace(value: XRReferenceSpace): void;
+    getBaseLayer(): XRWebGLLayer | XRProjectionLayer;
+    getBinding(): XRWebGLBinding;
+    getFrame(): XRFrame;
     getSession(): XRSession | null;
     setSession(value: XRSession): Promise<void>;
-    getCamera(camera: Camera): Camera;
+    getCamera(): WebXRArrayCamera;
+    updateCamera(camera: PerspectiveCamera): void;
     setAnimationLoop(callback: XRFrameRequestCallback | null): void;
     getFoveation(): number | undefined;
     setFoveation(foveation: number): void;

three/src/renderers/webxr/WebXR.d.ts

@@ -1,328 +0,0 @@
-export type XRSessionMode = 'inline' | 'immersive-vr' | 'immersive-ar';
-
-export type XRReferenceSpaceType = 'viewer' | 'local' | 'local-floor' | 'bounded-floor' | 'unbounded';
-
-export type XREnvironmentBlendMode = 'opaque' | 'additive' | 'alpha-blend';
-
-export type XRVisibilityState = 'visible' | 'visible-blurred' | 'hidden';
-
-export type XRHandedness = 'none' | 'left' | 'right';
-
-export type XRTargetRayMode = 'gaze' | 'tracked-pointer' | 'screen';
-
-export type XREye = 'none' | 'left' | 'right';
-
-export type XREventType =
-    | 'end'
-    | 'select'
-    | 'selectstart'
-    | 'selectend'
-    | 'squeeze'
-    | 'squeezestart'
-    | 'squeezeend'
-    | 'inputsourceschange';
-
-export type XRAnimationLoopCallback = (time: number, frame?: XRFrame) => void;
-
-export type XRFrameRequestCallback = (time: number, frame: XRFrame) => void;
-
-export interface XR extends EventTarget {
-    requestSession(mode: XRSessionMode, options?: XRSessionInit): Promise<XRSession>;
-    isSessionSupported(mode: XRSessionMode): Promise<boolean>;
-}
-
-export interface Window {
-    XRSession?: Constructor<XRSession> | undefined;
-    XR?: Constructor<XR> | undefined;
-}
-
-export interface Navigator {
-    xr?: XR | undefined;
-}
-
-export interface XRReferenceSpace extends EventTarget {
-    getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
-}
-export interface XRHitTestOptionsInit {
-    space: EventTarget;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRTransientInputHitTestOptionsInit {
-    profile: string;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRViewport {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-
-export interface WebGLRenderingContext {
-    makeXRCompatible(): Promise<void>;
-}
-
-export interface XRRenderState {
-    readonly depthNear: number;
-    readonly depthFar: number;
-    readonly inlineVerticalFieldOfView?: number | undefined;
-    readonly baseLayer?: XRWebGLLayer | undefined;
-}
-
-export interface XRRenderStateInit {
-    depthNear?: number | undefined;
-    depthFar?: number | undefined;
-    inlineVerticalFieldOfView?: number | undefined;
-    baseLayer?: XRWebGLLayer | undefined;
-}
-
-export interface XRGamepad {
-    readonly id: string;
-    readonly index: number; // long
-    readonly connected: boolean;
-    readonly timestamp: DOMHighResTimeStamp;
-    readonly mapping: GamepadMappingType;
-    readonly axes: Float32Array; // FrozenArray<double>;
-    readonly buttons: GamepadButton[]; // FrozenArray<GamepadButton>;
-}
-
-export interface XRInputSource {
-    readonly handedness: XRHandedness;
-    readonly targetRayMode: XRTargetRayMode;
-    readonly targetRaySpace: EventTarget;
-    readonly gripSpace?: EventTarget | undefined;
-    readonly profiles: string[];
-    readonly gamepad: XRGamepad;
-    readonly hand?: XRHand | undefined;
-}
-
-export interface XRSessionInit {
-    optionalFeatures?: string[] | undefined;
-    requiredFeatures?: string[] | undefined;
-}
-
-export interface XRSession extends EventTarget {
-    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace>;
-    updateRenderState(renderStateInit: XRRenderStateInit): Promise<void>;
-    requestAnimationFrame(callback: XRFrameRequestCallback): number;
-    cancelAnimationFrame(id: number): void;
-    end(): Promise<void>;
-    renderState: XRRenderState;
-    inputSources: XRInputSource[];
-    environmentBlendMode: XREnvironmentBlendMode;
-    visibilityState: XRVisibilityState;
-
-    // hit test
-    requestHitTestSource(options: XRHitTestOptionsInit): Promise<XRHitTestSource>;
-    requestHitTestSourceForTransientInput(
-        options: XRTransientInputHitTestOptionsInit,
-    ): Promise<XRTransientInputHitTestSource>;
-
-    // legacy AR hit test
-    requestHitTest(ray: XRRay, referenceSpace: XRReferenceSpace): Promise<XRHitResult[]>;
-
-    // legacy plane detection
-    updateWorldTrackingState(options: { planeDetectionState?: { enabled: boolean } | undefined }): void;
-}
-
-export interface XRReferenceSpace extends EventTarget {
-    getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
-    onreset: any;
-}
-
-export type XRPlaneSet = Set<XRPlane>;
-export type XRAnchorSet = Set<XRAnchor>;
-
-export interface XRFrame {
-    readonly session: XRSession;
-    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
-    getPose(space: EventTarget, baseSpace: EventTarget): XRPose | undefined;
-
-    // AR
-    getHitTestResults(hitTestSource: XRHitTestSource): XRHitTestResult[];
-    getHitTestResultsForTransientInput(hitTestSource: XRTransientInputHitTestSource): XRTransientInputHitTestResult[];
-    // Anchors
-    trackedAnchors?: XRAnchorSet | undefined;
-    createAnchor(pose: XRRigidTransform, space: EventTarget): Promise<XRAnchor>;
-    // Planes
-    worldInformation: {
-        detectedPlanes?: XRPlaneSet | undefined;
-    };
-    // Hand tracking
-    getJointPose(joint: XRJointSpace, baseSpace: EventTarget): XRJointPose;
-}
-
-export interface XRViewerPose {
-    readonly transform: XRRigidTransform;
-    readonly views: XRView[];
-}
-
-export interface XRPose {
-    readonly emulatedPosition: boolean;
-    readonly transform: XRRigidTransform;
-}
-
-export interface XRWebGLLayerInit {
-    antialias?: boolean | undefined;
-    depth?: boolean | undefined;
-    stencil?: boolean | undefined;
-    alpha?: boolean | undefined;
-    ignoreDepthValues?: boolean | undefined;
-    framebufferScaleFactor?: number | undefined;
-}
-
-export class XRWebGLLayer {
-    constructor(session: XRSession, gl: WebGLRenderingContext | undefined, options?: XRWebGLLayerInit);
-    framebuffer: WebGLFramebuffer;
-    framebufferWidth: number;
-    framebufferHeight: number;
-    getViewport(view: XRView): XRViewport;
-}
-
-export interface DOMPointInit {
-    w?: number | undefined;
-    x?: number | undefined;
-    y?: number | undefined;
-    z?: number | undefined;
-}
-
-export class XRRigidTransform {
-    constructor(matrix: Float32Array | DOMPointInit, direction?: DOMPointInit);
-    position: DOMPointReadOnly;
-    orientation: DOMPointReadOnly;
-    matrix: Float32Array;
-    inverse: XRRigidTransform;
-}
-
-export interface XRView {
-    readonly eye: XREye;
-    readonly projectionMatrix: Float32Array;
-    readonly viewMatrix: Float32Array;
-    readonly transform: XRRigidTransform;
-}
-
-export interface XRRayDirectionInit {
-    x?: number | undefined;
-    y?: number | undefined;
-    z?: number | undefined;
-    w?: number | undefined;
-}
-
-export class XRRay {
-    readonly origin: DOMPointReadOnly;
-    readonly direction: XRRayDirectionInit;
-    matrix: Float32Array;
-
-    constructor(transformOrOrigin: XRRigidTransform | DOMPointInit, direction?: XRRayDirectionInit);
-}
-
-export enum XRHitTestTrackableType {
-    'point',
-    'plane',
-    'mesh',
-}
-
-export interface XRHitResult {
-    hitMatrix: Float32Array;
-}
-
-export interface XRTransientInputHitTestResult {
-    readonly inputSource: XRInputSource;
-    readonly results: XRHitTestResult[];
-}
-
-export interface XRHitTestResult {
-    getPose(baseSpace: EventTarget): XRPose | undefined | null;
-    // When anchor system is enabled
-    createAnchor?(pose: XRRigidTransform): Promise<XRAnchor>;
-}
-
-export interface XRHitTestSource {
-    cancel(): void;
-}
-
-export interface XRTransientInputHitTestSource {
-    cancel(): void;
-}
-
-export interface XRHitTestOptionsInit {
-    space: EventTarget;
-    entityTypes?: XRHitTestTrackableType[] | undefined;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRTransientInputHitTestOptionsInit {
-    profile: string;
-    entityTypes?: XRHitTestTrackableType[] | undefined;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRAnchor {
-    anchorSpace: EventTarget;
-    delete(): void;
-}
-
-export interface XRPlane {
-    orientation: 'Horizontal' | 'Vertical';
-    planeSpace: EventTarget;
-    polygon: DOMPointReadOnly[];
-    lastChangedTime: number;
-}
-
-export enum XRHandJoint {
-    'wrist',
-    'thumb-metacarpal',
-    'thumb-phalanx-proximal',
-    'thumb-phalanx-distal',
-    'thumb-tip',
-    'index-finger-metacarpal',
-    'index-finger-phalanx-proximal',
-    'index-finger-phalanx-intermediate',
-    'index-finger-phalanx-distal',
-    'index-finger-tip',
-    'middle-finger-metacarpal',
-    'middle-finger-phalanx-proximal',
-    'middle-finger-phalanx-intermediate',
-    'middle-finger-phalanx-distal',
-    'middle-finger-tip',
-    'ring-finger-metacarpal',
-    'ring-finger-phalanx-proximal',
-    'ring-finger-phalanx-intermediate',
-    'ring-finger-phalanx-distal',
-    'ring-finger-tip',
-    'pinky-finger-metacarpal',
-    'pinky-finger-phalanx-proximal',
-    'pinky-finger-phalanx-intermediate',
-    'pinky-finger-phalanx-distal',
-    'pinky-finger-tip',
-}
-
-export interface XRJointSpace extends EventTarget {
-    readonly jointName: XRHandJoint;
-}
-
-export interface XRJointPose extends XRPose {
-    readonly radius: number | undefined;
-}
-
-export interface XRHand extends Map<XRHandJoint, XRJointSpace> {
-    readonly size: number;
-}
-
-export interface Constructor<T = object> {
-    new (...args: any[]): T;
-    prototype: T;
-}
-
-export interface XRInputSourceChangeEvent {
-    session: XRSession;
-    removed: XRInputSource[];
-    added: XRInputSource[];
-}
-
-export interface XRInputSourceEvent extends Event {
-    readonly frame: XRFrame;
-    readonly inputSource: XRInputSource;
-}