@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Audio/sound.d.ts

@@ -0,0 +1,304 @@
+/**
+ * Defines a sound that can be played in the application.
+ * The sound can either be an ambient track or a simple sound played in reaction to a user action.
+ * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music
+ */
+export class Sound {
+    /**
+     * Parse a JSON representation of a sound to instantiate in a given scene
+     * @param parsedSound Define the JSON representation of the sound (usually coming from the serialize method)
+     * @param scene Define the scene the new parsed sound should be created in
+     * @param rootUrl Define the rooturl of the load in case we need to fetch relative dependencies
+     * @param sourceSound Define a sound place holder if do not need to instantiate a new one
+     * @returns the newly parsed sound
+     */
+    static Parse(parsedSound: any, scene: any, rootUrl: any, sourceSound: any): Sound;
+    /**
+     * Create a sound and attach it to a scene
+     * @param name Name of your sound
+     * @param urlOrArrayBuffer Url to the sound to load async or ArrayBuffer, it also works with MediaStreams and AudioBuffers
+     * @param scene defines the scene the sound belongs to
+     * @param readyToPlayCallback Provide a callback function if you'd like to load your code once the sound is ready to be played
+     * @param options Objects to provide with the current available options: autoplay, loop, volume, spatialSound, maxDistance, rolloffFactor, refDistance, distanceModel, panningModel, streaming
+     */
+    constructor(name: any, urlOrArrayBuffer: any, scene: any, readyToPlayCallback: null | undefined, options: any);
+    /**
+     * Does the sound autoplay once loaded.
+     */
+    autoplay: any;
+    _loop: any;
+    /**
+     * Does the sound use a custom attenuation curve to simulate the falloff
+     * happening when the source gets further away from the camera.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-your-own-custom-attenuation-function
+     */
+    useCustomAttenuation: any;
+    /**
+     * Is this sound currently played.
+     */
+    isPlaying: boolean;
+    /**
+     * Is this sound currently paused.
+     */
+    isPaused: boolean;
+    /**
+     * Define the reference distance the sound should be heard perfectly.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    refDistance: any;
+    /**
+     * Define the roll off factor of spatial sounds.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    rolloffFactor: any;
+    /**
+     * Define the max distance the sound should be heard (intensity just became 0 at this point).
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    maxDistance: any;
+    /**
+     * Define the distance attenuation model the sound will follow.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    distanceModel: any;
+    /**
+     * Gets or sets an object used to store user defined information for the sound.
+     */
+    metadata: any;
+    /**
+     * Observable event when the current playing sound finishes.
+     */
+    onEndedObservable: Observable<any>;
+    _spatialSound: any;
+    _panningModel: string;
+    _playbackRate: any;
+    _streaming: any;
+    _startTime: number;
+    _startOffset: number;
+    _position: Vector3;
+    _localDirection: Vector3;
+    _volume: any;
+    _isReadyToPlay: boolean;
+    _isDirectional: boolean;
+    _coneInnerAngle: number;
+    _coneOuterAngle: number;
+    _coneOuterGain: number;
+    _isOutputConnected: boolean;
+    _urlType: string;
+    name: any;
+    _scene: any;
+    _readyToPlayCallback: any;
+    _customAttenuationFunction: ((currentVolume: any, currentDistance: any, maxDistance: any, refDistance: any, rolloffFactor: any) => number) | undefined;
+    _length: any;
+    _offset: any;
+    _soundGain: GainNode | undefined;
+    _inputAudioNode: GainNode | undefined;
+    _outputAudioNode: GainNode | undefined;
+    _streamingSource: MediaElementAudioSourceNode | MediaStreamAudioSourceNode | undefined;
+    _htmlAudioElement: HTMLAudioElement | undefined;
+    set loop(arg: any);
+    /**
+     * Does the sound loop after it finishes playing once.
+     */
+    get loop(): any;
+    /**
+     * Gets the current time for the sound.
+     */
+    get currentTime(): number;
+    /**
+     * Does this sound enables spatial sound.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    set spatialSound(arg: any);
+    /**
+     * Does this sound enables spatial sound.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    get spatialSound(): any;
+    /**
+     * Release the sound and its associated resources
+     */
+    dispose(): void;
+    _soundPanner: any;
+    _soundSource: AudioBufferSourceNode | null | undefined;
+    _audioBuffer: any;
+    _connectedTransformNode: any;
+    /**
+     * Gets if the sounds is ready to be played or not.
+     * @returns true if ready, otherwise false
+     */
+    isReady(): boolean;
+    /**
+     * Get the current class name.
+     * @returns current class name
+     */
+    getClassName(): string;
+    _audioBufferLoaded(buffer: any): void;
+    _soundLoaded(audioData: any): void;
+    /**
+     * Sets the data of the sound from an audiobuffer
+     * @param audioBuffer The audioBuffer containing the data
+     */
+    setAudioBuffer(audioBuffer: any): void;
+    /**
+     * Updates the current sounds options such as maxdistance, loop...
+     * @param options A JSON object containing values named as the object properties
+     */
+    updateOptions(options: any): void;
+    _createSpatialParameters(): void;
+    _updateSpatialParameters(): void;
+    /**
+     * Switch the panning model to HRTF:
+     * Renders a stereo output of higher quality than equalpower — it uses a convolution with measured impulse responses from human subjects.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    switchPanningModelToHRTF(): void;
+    /**
+     * Switch the panning model to Equal Power:
+     * Represents the equal-power panning algorithm, generally regarded as simple and efficient. equalpower is the default value.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    switchPanningModelToEqualPower(): void;
+    _switchPanningModel(): void;
+    /**
+     * Connect this sound to a sound track audio node like gain...
+     * @param soundTrackAudioNode the sound track audio node to connect to
+     */
+    connectToSoundTrackAudioNode(soundTrackAudioNode: any): void;
+    /**
+     * Transform this sound into a directional source
+     * @param coneInnerAngle Size of the inner cone in degree
+     * @param coneOuterAngle Size of the outer cone in degree
+     * @param coneOuterGain Volume of the sound outside the outer cone (between 0.0 and 1.0)
+     */
+    setDirectionalCone(coneInnerAngle: any, coneOuterAngle: any, coneOuterGain: any): void;
+    /**
+     * Gets or sets the inner angle for the directional cone.
+     */
+    set directionalConeInnerAngle(arg: number);
+    /**
+     * Gets or sets the inner angle for the directional cone.
+     */
+    get directionalConeInnerAngle(): number;
+    /**
+     * Gets or sets the outer angle for the directional cone.
+     */
+    set directionalConeOuterAngle(arg: number);
+    /**
+     * Gets or sets the outer angle for the directional cone.
+     */
+    get directionalConeOuterAngle(): number;
+    /**
+     * Sets the position of the emitter if spatial sound is enabled
+     * @param newPosition Defines the new position
+     */
+    setPosition(newPosition: any): void;
+    /**
+     * Sets the local direction of the emitter if spatial sound is enabled
+     * @param newLocalDirection Defines the new local direction
+     */
+    setLocalDirectionToMesh(newLocalDirection: any): void;
+    _updateDirection(): void;
+    /** @internal */
+    updateDistanceFromListener(): void;
+    /**
+     * Sets a new custom attenuation function for the sound.
+     * @param callback Defines the function used for the attenuation
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-your-own-custom-attenuation-function
+     */
+    setAttenuationFunction(callback: any): void;
+    /**
+     * Play the sound
+     * @param time (optional) Start the sound after X seconds. Start immediately (0) by default.
+     * @param offset (optional) Start the sound at a specific time in seconds
+     * @param length (optional) Sound duration (in seconds)
+     */
+    play(time: any, offset: any, length: any): void;
+    _onended(): void;
+    /**
+     * Stop the sound
+     * @param time (optional) Stop the sound after X seconds. Stop immediately (0) by default.
+     */
+    stop(time: any): void;
+    /**
+     * Put the sound in pause
+     */
+    pause(): void;
+    /**
+     * Sets a dedicated volume for this sounds
+     * @param newVolume Define the new volume of the sound
+     * @param time Define time for gradual change to new volume
+     */
+    setVolume(newVolume: any, time: any): void;
+    /**
+     * Set the sound play back rate
+     * @param newPlaybackRate Define the playback rate the sound should be played at
+     */
+    setPlaybackRate(newPlaybackRate: any): void;
+    /**
+     * Gets the volume of the sound.
+     * @returns the volume of the sound
+     */
+    getVolume(): any;
+    /**
+     * Attach the sound to a dedicated mesh
+     * @param transformNode The transform node to connect the sound with
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#attaching-a-sound-to-a-mesh
+     */
+    attachToMesh(transformNode: any): void;
+    _registerFunc: ((transformNode: any) => void) | null | undefined;
+    /**
+     * Detach the sound from the previously attached mesh
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#attaching-a-sound-to-a-mesh
+     */
+    detachFromMesh(): void;
+    _onRegisterAfterWorldMatrixUpdate(node: any): void;
+    /**
+     * Clone the current sound in the scene.
+     * @returns the new sound clone
+     */
+    clone(): Sound | null;
+    /**
+     * Gets the current underlying audio buffer containing the data
+     * @returns the audio buffer
+     */
+    getAudioBuffer(): any;
+    /**
+     * Gets the WebAudio AudioBufferSourceNode, lets you keep track of and stop instances of this Sound.
+     * @returns the source node
+     */
+    getSoundSource(): AudioBufferSourceNode | null | undefined;
+    /**
+     * Gets the WebAudio GainNode, gives you precise control over the gain of instances of this Sound.
+     * @returns the gain node
+     */
+    getSoundGain(): GainNode | undefined;
+    /**
+     * Serializes the Sound in a JSON representation
+     * @returns the JSON representation of the sound
+     */
+    serialize(): {
+        name: any;
+        url: any;
+        autoplay: any;
+        loop: any;
+        volume: any;
+        spatialSound: any;
+        maxDistance: any;
+        rolloffFactor: any;
+        refDistance: any;
+        distanceModel: any;
+        playbackRate: any;
+        panningModel: string;
+        soundTrackId: any;
+        metadata: any;
+    };
+}
+export namespace Sound {
+    /**
+     * @internal
+     */
+    function _SceneComponentInitialization(_: any): never;
+}
+import { Observable } from "../Misc/observable.js";
+import { Vector3 } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Audio/soundTrack.d.ts

@@ -0,0 +1,65 @@
+/**
+ * It could be useful to isolate your music & sounds on several tracks to better manage volume on a grouped instance of sounds.
+ * It will be also used in a future release to apply effects on a specific track.
+ * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#using-sound-tracks
+ */
+export class SoundTrack {
+    /**
+     * Creates a new sound track.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#using-sound-tracks
+     * @param scene Define the scene the sound track belongs to
+     * @param options
+     */
+    constructor(scene: any, options?: {});
+    /**
+     * The unique identifier of the sound track in the scene.
+     */
+    id: number;
+    _isInitialized: boolean;
+    _scene: any;
+    soundCollection: any[] | undefined;
+    _options: {} | undefined;
+    _initializeSoundTrackAudioGraph(): void;
+    _outputAudioNode: GainNode | null | undefined;
+    /**
+     * Release the sound track and its associated resources
+     */
+    dispose(): void;
+    /**
+     * Adds a sound to this sound track
+     * @param sound define the sound to add
+     * @ignoreNaming
+     */
+    addSound(sound: any): void;
+    /**
+     * Removes a sound to this sound track
+     * @param sound define the sound to remove
+     * @ignoreNaming
+     */
+    removeSound(sound: any): void;
+    /**
+     * Set a global volume for the full sound track.
+     * @param newVolume Define the new volume of the sound track
+     */
+    setVolume(newVolume: any): void;
+    /**
+     * Switch the panning model to HRTF:
+     * Renders a stereo output of higher quality than equalpower — it uses a convolution with measured impulse responses from human subjects.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    switchPanningModelToHRTF(): void;
+    /**
+     * Switch the panning model to Equal Power:
+     * Represents the equal-power panning algorithm, generally regarded as simple and efficient. equalpower is the default value.
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#creating-a-spatial-3d-sound
+     */
+    switchPanningModelToEqualPower(): void;
+    /**
+     * Connect the sound track to an audio analyser allowing some amazing
+     * synchronization between the sounds/music and your visualization (VuMeter for instance).
+     * @see https://doc.babylonjs.com/how_to/playing_sounds_and_music#using-the-analyser
+     * @param analyser The analyser to connect to the engine
+     */
+    connectToAnalyser(analyser: any): void;
+    _connectedAnalyser: any;
+}

package/dist/types/node_modules/@babylonjs/core/Audio/weightedsound.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Wraps one or more Sound objects and selects one with random weight for playback.
+ */
+export class WeightedSound {
+    /**
+     * Creates a new WeightedSound from the list of sounds given.
+     * @param loop When true a Sound will be selected and played when the current playing Sound completes.
+     * @param sounds Array of Sounds that will be selected from.
+     * @param weights Array of number values for selection weights; length must equal sounds, values will be normalized to 1
+     */
+    constructor(loop: any, sounds: any, weights: any);
+    /** When true a Sound will be selected and played when the current playing Sound completes. */
+    loop: any;
+    _coneInnerAngle: number;
+    _coneOuterAngle: number;
+    _volume: number;
+    /** A Sound is currently playing. */
+    isPlaying: boolean;
+    /** A Sound is currently paused. */
+    isPaused: boolean;
+    _sounds: any;
+    _weights: any;
+    /**
+     * The size of cone in degrees for a directional sound in which there will be no attenuation.
+     */
+    set directionalConeInnerAngle(arg: number);
+    /**
+     * The size of cone in degrees for a directional sound in which there will be no attenuation.
+     */
+    get directionalConeInnerAngle(): number;
+    /**
+     * Size of cone in degrees for a directional sound outside of which there will be no sound.
+     * Listener angles between innerAngle and outerAngle will falloff linearly.
+     */
+    set directionalConeOuterAngle(arg: number);
+    /**
+     * Size of cone in degrees for a directional sound outside of which there will be no sound.
+     * Listener angles between innerAngle and outerAngle will falloff linearly.
+     */
+    get directionalConeOuterAngle(): number;
+    /**
+     * Playback volume.
+     */
+    set volume(arg: number);
+    /**
+     * Playback volume.
+     */
+    get volume(): number;
+    _onended(): void;
+    /**
+     * Suspend playback
+     */
+    pause(): void;
+    /**
+     * Stop playback
+     */
+    stop(): void;
+    /**
+     * Start playback.
+     * @param startOffset Position the clip head at a specific time in seconds.
+     */
+    play(startOffset: any): void;
+    _currentIndex: number | undefined;
+}

package/dist/types/node_modules/@babylonjs/core/BakedVertexAnimation/bakedVertexAnimationManager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * This class is used to animate meshes using a baked vertex animation texture
+ * @see https://doc.babylonjs.com/divingDeeper/animation/baked_texture_animations
+ * @since 5.0
+ */
+export class BakedVertexAnimationManager {
+    /**
+     * Creates a new BakedVertexAnimationManager
+     * @param scene defines the current scene
+     */
+    constructor(scene: any);
+    _texture: any;
+    _isEnabled: boolean;
+    /**
+     * Enable or disable the vertex animation manager
+     */
+    isEnabled: boolean;
+    /**
+     * The time counter, to pick the correct animation frame.
+     */
+    time: number;
+    _scene: any;
+    animationParameters: Vector4 | undefined;
+    /** @internal */
+    _markSubMeshesAsAttributesDirty(): void;
+    /**
+     * Binds to the effect.
+     * @param effect The effect to bind to.
+     * @param useInstances True when it's an instance.
+     */
+    bind(effect: any, useInstances?: boolean): void;
+    /**
+     * Clone the current manager
+     * @returns a new BakedVertexAnimationManager
+     */
+    clone(): BakedVertexAnimationManager;
+    /**
+     * Sets animation parameters.
+     * @param startFrame The first frame of the animation.
+     * @param endFrame The last frame of the animation.
+     * @param offset The offset when starting the animation.
+     * @param speedFramesPerSecond The frame rate.
+     */
+    setAnimationParameters(startFrame: any, endFrame: any, offset?: number, speedFramesPerSecond?: number): void;
+    /**
+     * Disposes the resources of the manager.
+     * @param forceDisposeTextures - Forces the disposal of all textures.
+     */
+    dispose(forceDisposeTextures: any): void;
+    /**
+     * Get the current class name useful for serialization or dynamic coding.
+     * @returns "BakedVertexAnimationManager"
+     */
+    getClassName(): string;
+    /**
+     * Makes a duplicate of the current instance into another one.
+     * @param vatMap define the instance where to copy the info
+     */
+    copyTo(vatMap: any): void;
+    /**
+     * Serializes this vertex animation instance
+     * @returns - An object with the serialized instance.
+     */
+    serialize(): any;
+    /**
+     * Parses a vertex animation setting from a serialized object.
+     * @param source - Serialized object.
+     * @param scene Defines the scene we are parsing for
+     * @param rootUrl Defines the rootUrl to load from
+     */
+    parse(source: any, scene: any, rootUrl: any): void;
+}
+import { Vector4 } from "../Maths/math.vector.js";

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

@@ -0,0 +1,2 @@
+export * from "./bakedVertexAnimationManager.js";
+export * from "./vertexAnimationBaker.js";

package/dist/types/node_modules/@babylonjs/core/BakedVertexAnimation/vertexAnimationBaker.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Class to bake vertex animation textures.
+ * @since 5.0
+ */
+export class VertexAnimationBaker {
+    /**
+     * Create a new VertexAnimationBaker object which can help baking animations into a texture.
+     * @param scene Defines the scene the VAT belongs to
+     * @param mesh Defines the mesh the VAT belongs to
+     */
+    constructor(scene: any, mesh: any);
+    _scene: any;
+    _mesh: any;
+    /**
+     * Bakes the animation into the texture. This should be called once, when the
+     * scene starts, so the VAT is generated and associated to the mesh.
+     * @param ranges Defines the ranges in the animation that will be baked.
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    bakeVertexData(ranges: any): Promise<Float32Array>;
+    /**
+     * Runs an animation frame and stores its vertex data
+     *
+     * @param vertexData The array to save data to.
+     * @param frameIndex Current frame in the skeleton animation to render.
+     * @param textureIndex Current index of the texture data.
+     */
+    _executeAnimationFrame(vertexData: any, frameIndex: any, textureIndex: any): Promise<any>;
+    /**
+     * Builds a vertex animation texture given the vertexData in an array.
+     * @param vertexData The vertex animation data. You can generate it with bakeVertexData().
+     * @returns The vertex animation texture to be used with BakedVertexAnimationManager.
+     */
+    textureFromBakedVertexData(vertexData: any): RawTexture;
+    /**
+     * Serializes our vertexData to an object, with a nice string for the vertexData.
+     * @param vertexData The vertex array data.
+     * @returns This object serialized to a JS dict.
+     */
+    serializeBakedVertexDataToObject(vertexData: any): {
+        vertexData: string;
+        width: number;
+        height: number;
+    };
+    /**
+     * Loads previously baked data.
+     * @param data The object as serialized by serializeBakedVertexDataToObject()
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    loadBakedVertexDataFromObject(data: any): Float32Array;
+    /**
+     * Serializes our vertexData to a JSON string, with a nice string for the vertexData.
+     * Should be called right after bakeVertexData().
+     * @param vertexData The vertex array data.
+     * @returns This object serialized to a safe string.
+     */
+    serializeBakedVertexDataToJSON(vertexData: any): string;
+    /**
+     * Loads previously baked data in string format.
+     * @param json The json string as serialized by serializeBakedVertexDataToJSON().
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    loadBakedVertexDataFromJSON(json: any): Float32Array;
+}
+import { RawTexture } from "../Materials/Textures/rawTexture.js";

package/dist/types/node_modules/@babylonjs/core/Behaviors/Cameras/autoRotationBehavior.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The autoRotation behavior (AutoRotationBehavior) is designed to create a smooth rotation of an ArcRotateCamera when there is no user interaction.
+ * @see https://doc.babylonjs.com/how_to/camera_behaviors#autorotation-behavior
+ */
+export class AutoRotationBehavior {
+    _zoomStopsAnimation: boolean;
+    _idleRotationSpeed: number;
+    _idleRotationWaitTime: number;
+    _idleRotationSpinupTime: number;
+    targetAlpha: any;
+    _isPointerDown: boolean;
+    _lastFrameTime: number | null;
+    _lastInteractionTime: number;
+    _cameraRotationSpeed: number;
+    _lastFrameRadius: number;
+    /**
+     * Gets the name of the behavior.
+     */
+    get name(): string;
+    /**
+     * Sets the flag that indicates if user zooming should stop animation.
+     */
+    set zoomStopsAnimation(arg: boolean);
+    /**
+     * Gets the flag that indicates if user zooming should stop animation.
+     */
+    get zoomStopsAnimation(): boolean;
+    /**
+     * Sets the default speed at which the camera rotates around the model.
+     */
+    set idleRotationSpeed(arg: number);
+    /**
+     * Gets the default speed at which the camera rotates around the model.
+     */
+    get idleRotationSpeed(): number;
+    /**
+     * Sets the time (in milliseconds) to wait after user interaction before the camera starts rotating.
+     */
+    set idleRotationWaitTime(arg: number);
+    /**
+     * Gets the time (milliseconds) to wait after user interaction before the camera starts rotating.
+     */
+    get idleRotationWaitTime(): number;
+    /**
+     * Sets the time (milliseconds) to take to spin up to the full idle rotation speed.
+     */
+    set idleRotationSpinupTime(arg: number);
+    /**
+     * Gets the time (milliseconds) to take to spin up to the full idle rotation speed.
+     */
+    get idleRotationSpinupTime(): number;
+    /**
+     * Gets a value indicating if the camera is currently rotating because of this behavior
+     */
+    get rotationInProgress(): boolean;
+    /**
+     * Initializes the behavior.
+     */
+    init(): void;
+    /**
+     * Attaches the behavior to its arc rotate camera.
+     * @param camera Defines the camera to attach the behavior to
+     */
+    attach(camera: any): void;
+    _attachedCamera: any;
+    _onPrePointerObservableObserver: any;
+    _onAfterCheckInputsObserver: any;
+    /**
+     * Detaches the behavior from its current arc rotate camera.
+     */
+    detach(): void;
+    /**
+     * Force-reset the last interaction time
+     * @param customTime an optional time that will be used instead of the current last interaction time. For example `Date.now()`
+     */
+    resetLastInteractionTime(customTime: any): void;
+    /**
+     * Returns true if camera alpha reaches the target alpha
+     * @returns true if camera alpha reaches the target alpha
+     */
+    _reachTargetAlpha(): boolean;
+    /**
+     * Returns true if user is scrolling.
+     * @returns true if user is scrolling.
+     */
+    _userIsZooming(): boolean;
+    _shouldAnimationStopForInteraction(): boolean;
+    /**
+     *  Applies any current user interaction to the camera. Takes into account maximum alpha rotation.
+     */
+    _applyUserInteraction(): void;
+    _userIsMoving(): boolean;
+}