@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/XR/features/WebXRWalkingLocomotion.d.ts

@@ -0,0 +1,114 @@
+/**
+ * A module that will enable VR locomotion by detecting when the user walks in place.
+ */
+export class WebXRWalkingLocomotion extends WebXRAbstractFeature {
+    /**
+     * The module's name.
+     */
+    static get Name(): string;
+    /**
+     * The (Babylon) version of this module.
+     * This is an integer representing the implementation version.
+     * This number has no external basis.
+     */
+    static get Version(): number;
+    /**
+     * Construct a new Walking Locomotion feature.
+     * @param sessionManager manager for the current XR session
+     * @param options creation options, prominently including the vector target for locomotion
+     */
+    constructor(sessionManager: any, options: any);
+    _up: Vector3;
+    _forward: Vector3;
+    _position: Vector3;
+    _movement: Vector3;
+    _sessionManager: any;
+    /**
+     * The target to be articulated by walking locomotion.
+     * When the walking locomotion feature detects walking in place, this element's
+     * X and Z coordinates will be modified to reflect locomotion. This target should
+     * be either the XR space's origin (i.e., the parent node of the WebXRCamera) or
+     * the WebXRCamera itself. Note that the WebXRCamera path will modify the position
+     * of the WebXRCamera directly and is thus discouraged.
+     */
+    set locomotionTarget(arg: any);
+    /**
+     * The target to be articulated by walking locomotion.
+     * When the walking locomotion feature detects walking in place, this element's
+     * X and Z coordinates will be modified to reflect locomotion. This target should
+     * be either the XR space's origin (i.e., the parent node of the WebXRCamera) or
+     * the WebXRCamera itself. Note that the WebXRCamera path will modify the position
+     * of the WebXRCamera directly and is thus discouraged.
+     */
+    get locomotionTarget(): any;
+    _locomotionTarget: any;
+    _isLocomotionTargetWebXRCamera: boolean | undefined;
+    /**
+     * Attaches the feature.
+     * Typically called automatically by the features manager.
+     * @returns true if attach succeeded, false otherwise
+     */
+    attach(): boolean;
+    _walker: Walker | null | undefined;
+    _onXRFrame(frame: any): void;
+}
+import { WebXRAbstractFeature } from "./WebXRAbstractFeature.js";
+import { Vector3 } from "../../Maths/math.vector.js";
+declare class Walker {
+    static get _MillisecondsPerUpdate(): number;
+    constructor(engine: any);
+    _detector: FirstStepDetector;
+    _walker: WalkingTracker | null;
+    _movement: Vector2;
+    _millisecondsSinceLastUpdate: number;
+    movementThisFrame: Vector3;
+    _engine: any;
+    update(position: any, forward: any): void;
+}
+declare class FirstStepDetector {
+    _samples: CircleBuffer;
+    _entropy: number;
+    onFirstStepDetected: Observable<any>;
+    update(posX: any, posY: any, forwardX: any, forwardY: any): void;
+    reset(): void;
+    get _samePointCheckStartIdx(): number;
+    get _samePointSquaredDistanceThreshold(): number;
+    get _apexSquaredDistanceThreshold(): number;
+    get _squaredProjectionDistanceThreshold(): number;
+    get _axisToApexShrinkFactor(): number;
+    get _axisToApexExtendFactor(): number;
+    get _entropyDecayFactor(): number;
+    get _entropyThreshold(): number;
+}
+declare class WalkingTracker {
+    constructor(leftApex: any, rightApex: any, currentPosition: any, currentStepDirection: any);
+    _leftApex: Vector2;
+    _rightApex: Vector2;
+    _currentPosition: Vector2;
+    _axis: Vector2;
+    _axisLength: number;
+    _forward: Vector2;
+    _steppingLeft: boolean;
+    _t: number;
+    _maxT: number;
+    _maxTPosition: Vector2;
+    _vitality: number;
+    onMovement: Observable<any>;
+    onFootfall: Observable<any>;
+    _reset(leftApex: any, rightApex: any, currentPosition: any, steppingLeft: any): void;
+    _updateTAndVitality(x: any, y: any): void;
+    update(x: any, y: any): boolean;
+    get _vitalityThreshold(): number;
+    get forward(): Vector2;
+}
+import { Vector2 } from "../../Maths/math.vector.js";
+declare class CircleBuffer {
+    constructor(numSamples: any, initializer: any);
+    _samples: any[];
+    _idx: number;
+    get length(): number;
+    push(x: any, y: any): void;
+    at(idx: any): any;
+}
+import { Observable } from "../../Misc/observable.js";
+export {};

package/dist/types/node_modules/@babylonjs/core/XR/features/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./WebXRAbstractFeature.js";
+export * from "./WebXRHitTestLegacy.js";
+export * from "./WebXRAnchorSystem.js";
+export * from "./WebXRPlaneDetector.js";
+export * from "./WebXRBackgroundRemover.js";
+export * from "./WebXRControllerTeleportation.js";
+export * from "./WebXRControllerPointerSelection.js";
+export * from "./WebXRControllerPhysics.js";
+export * from "./WebXRHitTest.js";
+export * from "./WebXRFeaturePointSystem.js";
+export * from "./WebXRHandTracking.js";
+export * from "./WebXRMeshDetector.js";
+export * from "./WebXRImageTracking.js";
+export * from "./WebXRNearInteraction.js";
+export * from "./WebXRDOMOverlay.js";
+export * from "./WebXRControllerMovement.js";
+export * from "./WebXRLightEstimation.js";
+export * from "./WebXREyeTracking.js";
+export * from "./WebXRWalkingLocomotion.js";
+export * from "./WebXRLayers.js";

package/dist/types/node_modules/@babylonjs/core/XR/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./webXRCamera.js";
+export * from "./webXREnterExitUI.js";
+export * from "./webXRExperienceHelper.js";
+export * from "./webXRInput.js";
+export * from "./webXRInputSource.js";
+export * from "./webXRManagedOutputCanvas.js";
+export * from "./webXRTypes.js";
+export * from "./webXRSessionManager.js";
+export * from "./webXRDefaultExperience.js";
+export * from "./webXRFeaturesManager.js";
+export * from "./features/index.js";
+export * from "./motionController/index.js";
+export * from "./native/index.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./webXRAbstractMotionController.js";
+export * from "./webXRControllerComponent.js";
+export * from "./webXRGenericHandController.js";
+export * from "./webXRGenericMotionController.js";
+export * from "./webXRMicrosoftMixedRealityController.js";
+export * from "./webXRMotionControllerManager.js";
+export * from "./webXROculusTouchMotionController.js";
+export * from "./webXRHTCViveMotionController.js";
+export * from "./webXRProfiledMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRAbstractMotionController.d.ts

@@ -0,0 +1,118 @@
+/**
+ * An Abstract Motion controller
+ * This class receives an xrInput and a profile layout and uses those to initialize the components
+ * Each component has an observable to check for changes in value and state
+ */
+export class WebXRAbstractMotionController {
+    /**
+     * constructs a new abstract motion controller
+     * @param scene the scene to which the model of the controller will be added
+     * @param layout The profile layout to load
+     * @param gamepadObject The gamepad object correlating to this controller
+     * @param handedness handedness (left/right/none) of this controller
+     * @param _doNotLoadControllerMesh set this flag to ignore the mesh loading
+     * @param _controllerCache a cache holding controller models already loaded in this session
+     */
+    constructor(scene: any, layout: any, gamepadObject: any, handedness: any, _doNotLoadControllerMesh: boolean | undefined, _controllerCache: any);
+    scene: any;
+    layout: any;
+    gamepadObject: any;
+    handedness: any;
+    _doNotLoadControllerMesh: boolean;
+    _controllerCache: any;
+    _initComponent: (id: any) => void;
+    _modelReady: boolean;
+    /**
+     * A map of components (WebXRControllerComponent) in this motion controller
+     * Components have a ComponentType and can also have both button and axis definitions
+     */
+    components: {};
+    /**
+     * Disable the model's animation. Can be set at any time.
+     */
+    disableAnimation: boolean;
+    /**
+     * Observers registered here will be triggered when the model of this controller is done loading
+     */
+    onModelLoadedObservable: Observable<any>;
+    /**
+     * Dispose this controller, the model mesh and all its components
+     */
+    dispose(): void;
+    /**
+     * Returns all components of specific type
+     * @param type the type to search for
+     * @returns an array of components with this type
+     */
+    getAllComponentsOfType(type: any): any[];
+    /**
+     * get a component based an its component id as defined in layout.components
+     * @param id the id of the component
+     * @returns the component correlates to the id or undefined if not found
+     */
+    getComponent(id: any): any;
+    /**
+     * Get the list of components available in this motion controller
+     * @returns an array of strings correlating to available components
+     */
+    getComponentIds(): string[];
+    /**
+     * Get the first component of specific type
+     * @param type type of component to find
+     * @returns a controller component or null if not found
+     */
+    getComponentOfType(type: any): any;
+    /**
+     * Get the main (Select) component of this controller as defined in the layout
+     * @returns the main component of this controller
+     */
+    getMainComponent(): any;
+    /**
+     * Loads the model correlating to this controller
+     * When the mesh is loaded, the onModelLoadedObservable will be triggered
+     * @returns A promise fulfilled with the result of the model loading
+     */
+    loadModel(): Promise<any>;
+    /**
+     * Update this model using the current XRFrame
+     * @param xrFrame the current xr frame to use and update the model
+     */
+    updateFromXRFrame(xrFrame: any): void;
+    /**
+     * Backwards compatibility due to a deeply-integrated typo
+     */
+    get handness(): any;
+    /**
+     * Pulse (vibrate) this controller
+     * If the controller does not support pulses, this function will fail silently and return Promise<false> directly after called
+     * Consecutive calls to this function will cancel the last pulse call
+     *
+     * @param value the strength of the pulse in 0.0...1.0 range
+     * @param duration Duration of the pulse in milliseconds
+     * @param hapticActuatorIndex optional index of actuator (will usually be 0)
+     * @returns a promise that will send true when the pulse has ended and false if the device doesn't support pulse or an error accrued
+     */
+    pulse(value: any, duration: any, hapticActuatorIndex?: number): any;
+    _getChildByName(node: any, name: any): any;
+    _getImmediateChildByName(node: any, name: any): any;
+    /**
+     * Moves the axis on the controller mesh based on its current state
+     * @param axisMap
+     * @param axisValue the value of the axis which determines the meshes new position
+     * @internal
+     */
+    _lerpTransform(axisMap: any, axisValue: any, fixValueCoordinates: any): void;
+    /**
+     * Update the model itself with the current frame data
+     * @param xrFrame the frame to use for updating the model mesh
+     */
+    updateModel(xrFrame: any): void;
+    _getGenericFilenameAndPath(): {
+        filename: string;
+        path: string;
+    };
+    _getGenericParentMesh(meshes: any): void;
+    rootMesh: Mesh | undefined;
+}
+import { Observable } from "../../Misc/observable.js";
+import { Mesh } from "../../Meshes/mesh.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRControllerComponent.d.ts

@@ -0,0 +1,92 @@
+/**
+ * This class represents a single component (for example button or thumbstick) of a motion controller
+ */
+export class WebXRControllerComponent {
+    /**
+     * Creates a new component for a motion controller.
+     * It is created by the motion controller itself
+     *
+     * @param id the id of this component
+     * @param type the type of the component
+     * @param _buttonIndex index in the buttons array of the gamepad
+     * @param _axesIndices indices of the values in the axes array of the gamepad
+     */
+    constructor(id: any, type: any, _buttonIndex?: number, _axesIndices?: any[]);
+    id: any;
+    type: any;
+    _buttonIndex: number;
+    _axesIndices: any[];
+    _axes: {
+        x: number;
+        y: number;
+    };
+    _changes: {};
+    _currentValue: number;
+    _hasChanges: boolean;
+    _pressed: boolean;
+    _touched: boolean;
+    /**
+     * If axes are available for this component (like a touchpad or thumbstick) the observers will be notified when
+     * the axes data changes
+     */
+    onAxisValueChangedObservable: Observable<any>;
+    /**
+     * Observers registered here will be triggered when the state of a button changes
+     * State change is either pressed / touched / value
+     */
+    onButtonStateChangedObservable: Observable<any>;
+    /**
+     * The current axes data. If this component has no axes it will still return an object { x: 0, y: 0 }
+     */
+    get axes(): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get the changes. Elements will be populated only if they changed with their previous and current value
+     */
+    get changes(): {};
+    /**
+     * Return whether or not the component changed the last frame
+     */
+    get hasChanges(): boolean;
+    /**
+     * is the button currently pressed
+     */
+    get pressed(): boolean;
+    /**
+     * is the button currently touched
+     */
+    get touched(): boolean;
+    /**
+     * Get the current value of this component
+     */
+    get value(): number;
+    /**
+     * Dispose this component
+     */
+    dispose(): void;
+    /**
+     * Are there axes correlating to this component
+     * @returns true is axes data is available
+     */
+    isAxes(): boolean;
+    /**
+     * Is this component a button (hence - pressable)
+     * @returns true if can be pressed
+     */
+    isButton(): boolean;
+    /**
+     * update this component using the gamepad object it is in. Called on every frame
+     * @param nativeController the native gamepad controller object
+     */
+    update(nativeController: any): void;
+}
+export namespace WebXRControllerComponent {
+    const BUTTON_TYPE: string;
+    const SQUEEZE_TYPE: string;
+    const THUMBSTICK_TYPE: string;
+    const TOUCHPAD_TYPE: string;
+    const TRIGGER_TYPE: string;
+}
+import { Observable } from "../../Misc/observable.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRGenericHandController.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A generic hand controller class that supports select and a secondary grasp
+ */
+export class WebXRGenericHandController extends WebXRAbstractMotionController {
+    /**
+     * Create a new hand controller object, without loading a controller model
+     * @param scene the scene to use to create this controller
+     * @param gamepadObject the corresponding gamepad object
+     * @param handedness the handedness of the controller
+     */
+    constructor(scene: any, gamepadObject: any, handedness: any);
+    _processLoadedModel(_meshes: any): void;
+    _setRootMesh(meshes: any): void;
+    _updateModel(): void;
+}
+import { WebXRAbstractMotionController } from "./webXRAbstractMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRGenericMotionController.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A generic trigger-only motion controller for WebXR
+ */
+export class WebXRGenericTriggerMotionController extends WebXRAbstractMotionController {
+    constructor(scene: any, gamepadObject: any, handedness: any);
+    _processLoadedModel(meshes: any): void;
+    _setRootMesh(meshes: any): void;
+    _updateModel(): void;
+}
+export namespace WebXRGenericTriggerMotionController {
+    const ProfileId: string;
+}
+import { WebXRAbstractMotionController } from "./webXRAbstractMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRHTCViveMotionController.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The motion controller class for the standard HTC-Vive controllers
+ */
+export class WebXRHTCViveMotionController extends WebXRAbstractMotionController {
+    /**
+     * Create a new Vive motion controller object
+     * @param scene the scene to use to create this controller
+     * @param gamepadObject the corresponding gamepad object
+     * @param handedness the handedness of the controller
+     */
+    constructor(scene: any, gamepadObject: any, handedness: any);
+    _processLoadedModel(_meshes: any): void;
+    _setRootMesh(meshes: any): void;
+    _modelRootNode: any;
+    _updateModel(): void;
+}
+export namespace WebXRHTCViveMotionController {
+    const MODEL_BASE_URL: string;
+    const MODEL_FILENAME: string;
+}
+import { WebXRAbstractMotionController } from "./webXRAbstractMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRMicrosoftMixedRealityController.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The motion controller class for all microsoft mixed reality controllers
+ */
+export class WebXRMicrosoftMixedRealityController extends WebXRAbstractMotionController {
+    constructor(scene: any, gamepadObject: any, handedness: any);
+    _mapping: {
+        defaultButton: {
+            valueNodeName: string;
+            unpressedNodeName: string;
+            pressedNodeName: string;
+        };
+        defaultAxis: {
+            valueNodeName: string;
+            minNodeName: string;
+            maxNodeName: string;
+        };
+        buttons: {
+            "xr-standard-trigger": {
+                rootNodeName: string;
+                componentProperty: string;
+                states: string[];
+            };
+            "xr-standard-squeeze": {
+                rootNodeName: string;
+                componentProperty: string;
+                states: string[];
+            };
+            "xr-standard-touchpad": {
+                rootNodeName: string;
+                labelAnchorNodeName: string;
+                touchPointNodeName: string;
+            };
+            "xr-standard-thumbstick": {
+                rootNodeName: string;
+                componentProperty: string;
+                states: string[];
+            };
+        };
+        axes: {
+            "xr-standard-touchpad": {
+                "x-axis": {
+                    rootNodeName: string;
+                };
+                "y-axis": {
+                    rootNodeName: string;
+                };
+            };
+            "xr-standard-thumbstick": {
+                "x-axis": {
+                    rootNodeName: string;
+                };
+                "y-axis": {
+                    rootNodeName: string;
+                };
+            };
+        };
+    };
+    _processLoadedModel(_meshes: any): void;
+    _setRootMesh(meshes: any): void;
+    _updateModel(): void;
+}
+export namespace WebXRMicrosoftMixedRealityController {
+    const MODEL_BASE_URL: string;
+    const MODEL_LEFT_FILENAME: string;
+    const MODEL_RIGHT_FILENAME: string;
+}
+import { WebXRAbstractMotionController } from "./webXRAbstractMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRMotionControllerManager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Motion controller manager is managing the different webxr profiles and makes sure the right
+ * controller is being loaded.
+ */
+export class WebXRMotionControllerManager {
+    /**
+     * Clear the cache used for profile loading and reload when requested again
+     */
+    static ClearProfilesCache(): void;
+    /**
+     * Register the default fallbacks.
+     * This function is called automatically when this file is imported.
+     */
+    static DefaultFallbacks(): void;
+    /**
+     * Find a fallback profile if the profile was not found. There are a few predefined generic profiles.
+     * @param profileId the profile to which a fallback needs to be found
+     * @returns an array with corresponding fallback profiles
+     */
+    static FindFallbackWithProfileId(profileId: any): any;
+    /**
+     * When acquiring a new xrInput object (usually by the WebXRInput class), match it with the correct profile.
+     * The order of search:
+     *
+     * 1) Iterate the profiles array of the xr input and try finding a corresponding motion controller
+     * 2) (If not found) search in the gamepad id and try using it (legacy versions only)
+     * 3) search for registered fallbacks (should be redundant, nonetheless it makes sense to check)
+     * 4) return the generic trigger controller if none were found
+     *
+     * @param xrInput the xrInput to which a new controller is initialized
+     * @param scene the scene to which the model will be added
+     * @param forceProfile force a certain profile for this controller
+     * @returns A promise that fulfils with the motion controller class for this profile id or the generic standard class if none was found
+     */
+    static GetMotionControllerWithXRInput(xrInput: any, scene: any, forceProfile: any): Promise<any>;
+    /**
+     * Register a new controller based on its profile. This function will be called by the controller classes themselves.
+     *
+     * If you are missing a profile, make sure it is imported in your source, otherwise it will not register.
+     *
+     * @param type the profile type to register
+     * @param constructFunction the function to be called when loading this profile
+     */
+    static RegisterController(type: any, constructFunction: any): void;
+    /**
+     * Register a fallback to a specific profile.
+     * @param profileId the profileId that will receive the fallbacks
+     * @param fallbacks A list of fallback profiles
+     */
+    static RegisterFallbacksForProfileId(profileId: any, fallbacks: any): void;
+    /**
+     * Will update the list of profiles available in the repository
+     * @returns a promise that resolves to a map of profiles available online
+     */
+    static UpdateProfilesList(): Promise<any>;
+    /**
+     * Clear the controller's cache (usually happens at the end of a session)
+     */
+    static ClearControllerCache(): void;
+    static _LoadProfileFromRepository(profileArray: any, xrInput: any, scene: any): Promise<WebXRProfiledMotionController>;
+    static _LoadProfilesFromAvailableControllers(profileArray: any, xrInput: any, scene: any): Promise<any>;
+}
+export namespace WebXRMotionControllerManager {
+    const _ProfilesList: Promise<any> | null | undefined;
+    const _ProfileLoadingPromises: {} | undefined;
+    const _AvailableControllers: {};
+    const _Fallbacks: {};
+    const BaseRepositoryUrl: string;
+    const PrioritizeOnlineRepository: boolean;
+    const UseOnlineRepository: boolean;
+    const DisableControllerCache: boolean;
+}
+import { WebXRProfiledMotionController } from "./webXRProfiledMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXROculusTouchMotionController.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The motion controller class for oculus touch (quest, rift).
+ * This class supports legacy mapping as well the standard xr mapping
+ */
+export class WebXROculusTouchMotionController extends WebXRAbstractMotionController {
+    constructor(scene: any, gamepadObject: any, handedness: any, _legacyMapping?: boolean, _forceLegacyControllers?: boolean);
+    _forceLegacyControllers: boolean;
+    _processLoadedModel(_meshes: any): void;
+    _setRootMesh(meshes: any): void;
+    _modelRootNode: any;
+    _updateModel(): void;
+    /**
+     * Is this the new type of oculus touch. At the moment both have the same profile and it is impossible to differentiate
+     * between the touch and touch 2.
+     */
+    _isQuest(): boolean;
+}
+export namespace WebXROculusTouchMotionController {
+    const MODEL_BASE_URL: string;
+    const MODEL_LEFT_FILENAME: string;
+    const MODEL_RIGHT_FILENAME: string;
+    const QUEST_MODEL_BASE_URL: string;
+}
+import { WebXRAbstractMotionController } from "./webXRAbstractMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/motionController/webXRProfiledMotionController.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A profiled motion controller has its profile loaded from an online repository.
+ * The class is responsible of loading the model, mapping the keys and enabling model-animations
+ */
+export class WebXRProfiledMotionController extends WebXRAbstractMotionController {
+    constructor(scene: any, xrInput: any, _profile: any, _repositoryUrl: any, controllerCache: any);
+    _repositoryUrl: any;
+    controllerCache: any;
+    _buttonMeshMapping: {};
+    _touchDots: {};
+    profileId: any;
+    _processLoadedModel(_meshes: any): void;
+    _setRootMesh(meshes: any): void;
+    _updateModel(_xrFrame: any): void;
+}
+import { WebXRAbstractMotionController } from "./webXRAbstractMotionController.js";

package/dist/types/node_modules/@babylonjs/core/XR/native/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./nativeXRRenderTarget.js";
+export * from "./nativeXRFrame.js";

package/dist/types/node_modules/@babylonjs/core/XR/native/nativeXRFrame.d.ts

@@ -0,0 +1,29 @@
+/** @internal */
+export class NativeXRFrame {
+    constructor(_nativeImpl: any);
+    _nativeImpl: any;
+    _xrTransform: XRRigidTransform;
+    _xrPose: {
+        transform: XRRigidTransform;
+        emulatedPosition: boolean;
+    };
+    _xrPoseVectorData: Float32Array;
+    fillPoses: any;
+    getViewerPose: any;
+    getHitTestResults: any;
+    getHitTestResultsForTransientInput: () => never;
+    createAnchor: any;
+    getJointPose: any;
+    fillJointRadii: any;
+    getLightEstimate: () => never;
+    getImageTrackingResults: () => any;
+    get session(): any;
+    getPose(space: any, baseSpace: any): {
+        transform: XRRigidTransform;
+        emulatedPosition: boolean;
+    } | undefined;
+    get trackedAnchors(): any;
+    get worldInformation(): any;
+    get detectedPlanes(): any;
+    get featurePointCloud(): any;
+}